GameStatistics Halite::runGame() {
std::vector<bool> result(number_of_players, true);
std::vector<unsigned char> rankings;
const int maxTurnNumber = game_map.map_width * game_map.map_height;
while(std::count(result.begin(), result.end(), true) > 1 && turn_number < maxTurnNumber) {
//Increment turn number:
turn_number++;
if(!program_output_style) std::cout << "Turn " << turn_number << "\n";
//Frame logic.
std::vector<bool> newResult = processNextFrame(result);
//Add to vector of players that should be dead.
for(unsigned char a = 0; a < number_of_players; a++) if(result[a] && !newResult[a]) {
rankings.push_back(a);
}
result = newResult;
}
for(int a = 0; a < number_of_players; a++) if(result[a]) rankings.push_back(a);
std::reverse(rankings.begin(), rankings.end());
GameStatistics stats;
int chunkSize = game_map.map_width * game_map.map_height / number_of_players;
for(unsigned char a = 0; a < number_of_players; a++) {
PlayerStatistics p;
p.tag = a + 1;
p.rank = std::distance(rankings.begin(), std::find(rankings.begin(), rankings.end(), a)) + 1;
p.average_territory_count = full_territory_count[a] / double(chunkSize * alive_frame_count[a]);
p.average_strength_count = full_strength_count[a] / double(chunkSize * alive_frame_count[a]);
p.average_production_count = full_production_count[a] / double(chunkSize * (alive_frame_count[a] - 1)); //For this, we want turns rather than frames.
p.average_response_time = total_response_time[a] / double(alive_frame_count[a]); //In milliseconds.
p.still_percentage = full_still_count[a] / double(full_cardinal_count[a] + full_still_count[a]);
stats.player_statistics.push_back(p);
}
stats.timeout_tags = timeout_tags;
return stats;
}
void FrameGrabber<Camera>::
initialise()
{
loadParams();
frame_data.disp.create(frame_data.cam_vec[0].image_size(),
CV_32F);
#ifdef SCAVISLAM_CUDA_SUPPORT
frame_data.gpu_disp_32f.create(frame_data.cam_vec[0].image_size(),
CV_32F);
for (int l=0; l<NUM_PYR_LEVELS; ++l)
{
frame_data.cur_left().gpu_pyr_float32[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
frame_data.gpu_pyr_float32_dx[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
frame_data.gpu_pyr_float32_dy[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
frame_data.prev_left().gpu_pyr_float32[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
frame_data.gpu_pyr_float32_dx[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
frame_data.gpu_pyr_float32_dy[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
}
frame_data.right.gpu_pyr_float32[0]
.create(frame_data.cam_vec[0].image_size(), CV_32FC1);
#else
frame_data.pyr_float32.resize(NUM_PYR_LEVELS);
frame_data.pyr_float32_dx.resize(NUM_PYR_LEVELS);
frame_data.pyr_float32_dy.resize(NUM_PYR_LEVELS);
for (int l=0; l<NUM_PYR_LEVELS; ++l)
{
frame_data.pyr_float32[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
frame_data.pyr_float32_dx[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
frame_data.pyr_float32_dy[l]
.create(frame_data.cam_vec[l].image_size(), CV_32FC1);
}
#endif
if (params_.livestream)
{
#ifdef SCAVISLAM_PCL_SUPPORT
grabber.initialize();
boost::thread(boost::ref(grabber));
#else
assert(false);
#endif
}
else
{
//preprocessFiles(params_.path_str,true);
file_grabber_.initialize(params_.path_str,
params_.base_str,
params_.format_str,
frame_data.frame_id,
params_.color_img,
!params_.color_img,
params_.right_img,
params_.disp_img,
params_.right_img,
&file_grabber_mon_);
if (params_.rectify_frame)
{
intializeRectifier();
}
}
#ifdef SCAVISLAM_CUDA_SUPPORT
dx_filter_ =
cv::gpu::createDerivFilter_GPU(frame_data.cur_left()
.gpu_pyr_float32[0].type(),
frame_data.gpu_pyr_float32_dx[0]
.type(),
1, 0, 1, cv::BORDER_REPLICATE);
dy_filter_ =
cv::gpu::createDerivFilter_GPU(frame_data.cur_left()
.gpu_pyr_float32[0].type(),
frame_data.gpu_pyr_float32_dy[0]
.type(),
0, 1, 1, cv::BORDER_REPLICATE);
#endif
processNextFrame();
}
