ArenaRealTime Class Reference

#include <ArenaRealTime.h>

Inheritance diagram for ArenaRealTime:

[legend]Collaboration diagram for ArenaRealTime:

[legend]

Public Member Functions
	ArenaRealTime ()
virtual	~ArenaRealTime ()
void	clear ()
bool	timeout_function ()
void	start_tournament (const List< start_tournament_info_t > &robotfilename_list, const List< start_tournament_info_t > &arenafilename_list, const int robots_p_game, const int games_p_sequence, const int n_o_sequences)
void	end_game ()
void	broadcast (enum message_to_robot_type...)
void	parse_arena_file (String &filename)
void	set_filenames (String &log_fname, const String &statistics_fname, const String &tournament_fname, String &message_fname, const String &option_fname)
void	print_to_logfile (const char first_letter...)
bool	get_use_message_file ()
Vector2D	get_random_position ()
List< String >	get_arena_filenames ()
int	get_current_arena_nr ()
int	set_debug_level (const int new_level)
int	get_max_debug_level ()
void	quit_ordered ()
long int	find_free_colour (const long int home_colour, const long int away_colour, const class Robot *, const bool random_colours=false)
Static Public Member Functions
void	start_tournament_from_tournament_file (const List< start_tournament_info_t > &robotfilename_list, const List< start_tournament_info_t > &arenafilename_list, const int robots_p_game, const int games_p_sequence, const int n_o_sequences, ArenaRealTime *ar_p)
Private Member Functions
void	check_initialization ()
void	update ()
void	update_robots ()
void	read_robot_messages ()
void	check_robots ()
void	add_cookie ()
void	add_mine ()
bool	is_colour_allowed (const long int col, const double min_dist, const class Robot *)
double	colour_dist (const long int col1, const long int col2)
void	start_game ()
void	start_sequence ()
void	end_sequence ()
void	start_sequence_follow_up ()
void	end_sequence_follow_up ()
void	end_tournament ()
Private Attributes
String	tournament_file_name
ofstream	LOG_FILE
bool	use_log_file
int	update_count_for_logging
int **	robots_in_sequence
double	next_check_time
int	number_of_arenas
int	current_arena_nr

---

Constructor & Destructor Documentation

ArenaRealTime::ArenaRealTime (   )

Definition at line 61 of file ArenaRealTime.cc. References ArenaController::game_mode, ArenaController::log_filename, ArenaController::message_filename, ArenaController::option_filename, robots_in_sequence, set_filenames(), ArenaBase::set_game_mode(), ArenaController::statistics_filename, the_arena_controller, and ArenaController::tournament_filename. { set_game_mode( (ArenaBase::game_mode_t)the_arena_controller.game_mode ); set_filenames( the_arena_controller.log_filename, the_arena_controller.statistics_filename, the_arena_controller.tournament_filename, the_arena_controller.message_filename, the_arena_controller.option_filename ); robots_in_sequence = NULL; }

Here is the call graph for this function:

ArenaRealTime::~ArenaRealTime (   )  [virtual]

Definition at line 73 of file ArenaRealTime.cc. References LOG_FILE, robots_in_sequence, and use_log_file. { for(int i=0; i < sequences_in_tournament; i++) delete [] robots_in_sequence[i]; if( robots_in_sequence != NULL ) delete robots_in_sequence; if( use_log_file && LOG_FILE ) LOG_FILE.close(); if( use_message_file && message_file ) message_file.close(); }

---

Member Function Documentation

void ArenaRealTime::add_cookie (   )  [private]

Definition at line 521 of file ArenaRealTime.cc. References Options::get_d(), Shape::get_id(), get_random_position(), List< T >::insert_last(), OPTION_COOKIE_MAX_ENERGY, OPTION_COOKIE_MIN_ENERGY, OPTION_COOKIE_RADIUS, print_to_logfile(), ArenaBase::space_available(), and the_opts. Referenced by timeout_function(). { double en = the_opts.get_d(OPTION_COOKIE_MIN_ENERGY) + (the_opts.get_d(OPTION_COOKIE_MAX_ENERGY) - the_opts.get_d(OPTION_COOKIE_MIN_ENERGY)) * (double)rand() / (double)RAND_MAX; bool found_space = false; double r = the_opts.get_d(OPTION_COOKIE_RADIUS); Vector2D pos; for( int i=0; i<100 && !found_space; i++ ) { pos = get_random_position(); found_space = space_available(pos, r*2.0); } if( !found_space ) return; Cookie* cookiep = new Cookie(pos, en); object_lists[COOKIE].insert_last( cookiep ); print_to_logfile('C', cookiep->get_id(), pos[0], pos[1]); }

Here is the call graph for this function:

void ArenaRealTime::add_mine (   )  [private]

Definition at line 545 of file ArenaRealTime.cc. References Options::get_d(), Shape::get_id(), get_random_position(), List< T >::insert_last(), OPTION_MINE_MAX_ENERGY, OPTION_MINE_MIN_ENERGY, OPTION_MINE_RADIUS, print_to_logfile(), ArenaBase::space_available(), and the_opts. Referenced by timeout_function(). { double en = the_opts.get_d(OPTION_MINE_MIN_ENERGY) + (the_opts.get_d(OPTION_MINE_MAX_ENERGY) - the_opts.get_d(OPTION_MINE_MIN_ENERGY)) * (double)rand() / (double)RAND_MAX; bool found_space = false; double r = the_opts.get_d(OPTION_MINE_RADIUS); Vector2D pos; for( int i=0; i<100 && !found_space; i++) { pos = get_random_position(); found_space = space_available(pos, r*2.0); } if( !found_space ) return; Mine* minep = new Mine(pos, en); object_lists[MINE].insert_last( minep ); print_to_logfile('M', minep->get_id(), pos[0], pos[1]); }

Here is the call graph for this function:

void ArenaRealTime::broadcast (  enum  message_to_robot_type...  )

Referenced by end_game(), set_debug_level(), start_game(), and update_robots().

void ArenaRealTime::check_initialization (   )  [private]

void ArenaRealTime::check_robots (   )  [private]

Definition at line 569 of file ArenaRealTime.cc. References List< T >::first(), Options::get_d(), next_check_time, ListIterator< T >::ok(), OPTION_CHECK_INTERVAL, and the_opts. Referenced by timeout_function(). { ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { if( li()->is_process_running() ) { li()->check_process(); } } next_check_time = total_time + the_opts.get_d(OPTION_CHECK_INTERVAL); }

Here is the call graph for this function:

void ArenaRealTime::clear (   )

Definition at line 87 of file ArenaRealTime.cc. References ArenaBase::delete_lists(), NOT_STARTED, robots_in_sequence, and ArenaBase::set_state(). Referenced by start_tournament(). { delete_lists(true, true, true, true); for(int i=0; i < sequences_in_tournament; i++) delete [] robots_in_sequence[i]; sequence_nr = 0; sequences_in_tournament = 0; set_state( NOT_STARTED ); }

Here is the call graph for this function:

double ArenaRealTime::colour_dist (  const long int  col1, const long int  col2 )  [private]

void ArenaRealTime::end_game (   )  [virtual]

Implements ArenaBase. Definition at line 853 of file ArenaRealTime.cc. References broadcast(), ArenaBase::delete_lists(), Robot::die(), end_sequence(), List< T >::first(), GAME_FINISHES, Robot::is_alive(), Robot::is_dead_but_stats_not_set(), ListIterator< T >::ok(), Robot::set_stats(), and start_game(). Referenced by timeout_function(). { Robot* robotp; ListIterator<Robot> li; int robots_died_by_timeout = robots_left; robots_left = 0; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { robotp = li(); if( robotp->is_alive() || robotp->is_dead_but_stats_not_set() ) { robotp->die(); robotp->set_stats(robots_died_by_timeout, true); } } broadcast(GAME_FINISHES); delete_lists(false, false, false, false); if(game_nr == games_per_sequence) end_sequence(); else start_game(); }

Here is the call graph for this function:

void ArenaRealTime::end_sequence (   )  [private, virtual]

Implements ArenaBase. Definition at line 966 of file ArenaRealTime.cc. References List< T >::first(), next_check_time, ListIterator< T >::ok(), ArenaBase::set_state(), and SHUTTING_DOWN_ROBOTS. Referenced by end_game(). { // kill all robot processes ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { li()->end_process(); } // wait a second before checking set_state( SHUTTING_DOWN_ROBOTS); next_check_time = total_time + 1.0; }

Here is the call graph for this function:

void ArenaRealTime::end_sequence_follow_up (   )  [private]

Definition at line 983 of file ArenaRealTime.cc. References Robot::delete_pipes(), end_tournament(), List< T >::first(), Robot::is_process_running(), Robot::kill_process_forcefully(), ListIterator< T >::ok(), List< T >::remove(), and start_sequence(). Referenced by timeout_function(). { // check if the process have stopped, otherwise kill Robot* robotp; ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { robotp = li(); if( robotp->is_process_running() ) robotp->kill_process_forcefully(); robotp->delete_pipes(); all_robots_in_sequence.remove(li); } if( sequence_nr == sequences_in_tournament ) end_tournament(); else start_sequence(); }

Here is the call graph for this function:

void ArenaRealTime::end_tournament (   )  [private, virtual]

Implements ArenaBase. Definition at line 1165 of file ArenaRealTime.cc. References Gui::close_arenawindow(), FINISHED, ArenaBase::set_state(), and the_gui. Referenced by end_sequence_follow_up(). { set_state( FINISHED ); #ifndef NO_GRAPHICS if( !no_graphics ) { // if( !use_message_file ) // the_gui.close_messagewindow(); // the_gui.close_scorewindow(); the_gui.close_arenawindow(); } #endif }

Here is the call graph for this function:

long int ArenaRealTime::find_free_colour (  const long int  home_colour, const long int  away_colour, const class Robot *  , const bool  random_colours = false )

Referenced by start_sequence_follow_up().

List<String> ArenaRealTime::get_arena_filenames (   )  [inline]

Definition at line 59 of file ArenaRealTime.h. { return arena_filenames; }

int ArenaRealTime::get_current_arena_nr (   )  [inline]

Definition at line 60 of file ArenaRealTime.h. { return current_arena_nr; }

int ArenaRealTime::get_max_debug_level (   )  [inline]

Definition at line 64 of file ArenaRealTime.h. { return max_debug_level; }

Vector2D ArenaRealTime::get_random_position (   )

Definition at line 344 of file ArenaRealTime.cc. Referenced by add_cookie(), add_mine(), and start_game(). { return Vector2D( boundary[0][0] + (boundary[1][0] - boundary[0][0])* (double)rand()/(double)RAND_MAX, boundary[0][1] + (boundary[1][1] - boundary[0][1])* (double)rand()/(double)RAND_MAX ); }

bool ArenaRealTime::get_use_message_file (   )  [inline]

Definition at line 57 of file ArenaRealTime.h. { return use_message_file; }

bool ArenaRealTime::is_colour_allowed (  const long int  col, const double  min_dist, const class Robot *  )  [private]

void ArenaRealTime::parse_arena_file (  String &  filename  )

Definition at line 170 of file ArenaRealTime.cc. References String::chars(), Error(), Options::get_d(), OPTION_ARENA_SCALE, ArenaBase::parse_arena_line(), print_to_logfile(), and the_opts. Referenced by start_game(). { Vector2D vec1, vec2, vec0; ifstream file(filename.chars()); if( !file ) Error(true, "Couldn't open arena file" + filename, "ArenaBase::parse_arena_file"); int succession = 1; double scale = the_opts.get_d(OPTION_ARENA_SCALE); double angle_factor = 1.0; do { parse_arena_line(file, scale, succession, angle_factor); } while( !file.eof() ); file.close(); if( use_log_file ) // copy the arena file to the log file { char buffer[500]; ifstream file(filename.chars()); if( !file ) Error(true, "Couldn't open arena file for log file" + filename, "ArenaBase::parse_arena_file"); do { file >> ws; file.get(buffer, 500, '\n'); if( buffer[0] != '\0' ) print_to_logfile('A', buffer); } while( buffer[0] != '\0' ); } }

Here is the call graph for this function:

void ArenaRealTime::print_to_logfile (  const char  first_letter...  )

Definition at line 209 of file ArenaRealTime.cc. References String::chars(), Error(), hex2str(), LOG_FILE, and update_count_for_logging. Referenced by add_cookie(), add_mine(), parse_arena_file(), start_game(), start_sequence_follow_up(), start_tournament(), and update(). { if( !use_log_file ) return; va_list args; va_start(args, first_letter); // log 'R' only each OPTION_LOG_EVERY_NTH_UPDATE_INTERVAL if( update_count_for_logging != 0 && first_letter == 'R' ) { va_end(args); return; } LOG_FILE << first_letter; int prec = 2; LOG_FILE << setiosflags(ios::fixed) << setprecision(prec); switch(first_letter) { case 'R': // Robot position info LOG_FILE << va_arg(args, int ) << " "; // robot id; LOG_FILE << va_arg(args, double) << " "; // x LOG_FILE << va_arg(args, double) << " "; // y LOG_FILE << va_arg(args, double) << " "; // robot angle LOG_FILE << va_arg(args, double) << " "; // cannon angle LOG_FILE << va_arg(args, double) << " "; // radar angle LOG_FILE << va_arg(args, double); // energy break; case 'T': // Time LOG_FILE << setprecision(prec+1) << va_arg(args, double); // time elapsed break; case 'P': // Print a robot message LOG_FILE << va_arg(args, int ) << " "; // robot id LOG_FILE << va_arg(args, char* ); // message to print break; case 'C': // Cookie LOG_FILE << va_arg(args, int ) << " "; // cookie id LOG_FILE << va_arg(args, double) << " "; // x LOG_FILE << va_arg(args, double); // y break; case 'M': // Mine LOG_FILE << va_arg(args, int ) << " "; // mine id LOG_FILE << va_arg(args, double) << " "; // x LOG_FILE << va_arg(args, double); // y break; case 'S': // Shot LOG_FILE << va_arg(args, int ) << " "; // shot id LOG_FILE << va_arg(args, double) << " "; // x LOG_FILE << va_arg(args, double) << " "; // y LOG_FILE << setprecision(prec+1) << va_arg(args, double) << " "; // dx/dt LOG_FILE << setprecision(prec+1) << va_arg(args, double); // dy/dt break; case 'D': // Die { int obj_type = va_arg(args, int ); LOG_FILE << (char)obj_type << " "; // object type to kill LOG_FILE << va_arg(args, int) << " "; // object id if( obj_type == 'R' ) { LOG_FILE << setprecision(1) << va_arg(args, double) << " "; // robot points received LOG_FILE << va_arg(args, int); // position this game } } break; case 'G': // Game begins LOG_FILE << va_arg(args, int ) << " "; // sequence number LOG_FILE << va_arg(args, int ) << " "; // game number // LOG_FILE << va_arg(args, char*); // arena filename break; case 'H': // Header LOG_FILE << va_arg(args, int ) << " "; // number of games per sequence LOG_FILE << va_arg(args, int ) << " "; // number of robots per sequence LOG_FILE << va_arg(args, int ) << " "; // number of sequences LOG_FILE << va_arg(args, int ) << " "; // number of robots // LOG_FILE << va_arg(args, char*); // name of optionfile break; case 'L': // List of robot properties { LOG_FILE << va_arg(args, int ) << " "; // robot id LOG_FILE << hex2str(va_arg(args, long )) << " "; // robot colour String name = va_arg(args, char*); // robot name if( name == "" ) name = "Anonymous"; LOG_FILE << name; } break; case 'A': // Arena file line LOG_FILE << va_arg(args, char*); // line of arena file break; case 'O': { char option_type = (char)va_arg(args, int); LOG_FILE << va_arg(args, char*); // Option label switch( option_type ) { case 'D': LOG_FILE << String( va_arg(args, double) ).chars(); // Option value break; case 'L': LOG_FILE << String( va_arg(args, long) ).chars(); // Option value break; case 'H': LOG_FILE << hex2str( va_arg(args, long) ).chars(); // Option value break; case 'S': LOG_FILE << String( va_arg(args, char*) ).chars(); // Option value break; } } break; default: Error(true, "Unrecognized first letter in logfile", "ArenaRealTime::print_to_logfile"); break; } LOG_FILE << endl; va_end(args); }

Here is the call graph for this function:

void ArenaRealTime::quit_ordered (   )

Definition at line 389 of file ArenaRealTime.cc. References EXITING, and ArenaBase::set_state(). { set_state( EXITING ); }

Here is the call graph for this function:

void ArenaRealTime::read_robot_messages (   )  [private]

Definition at line 584 of file ArenaRealTime.cc. References List< T >::first(), and ListIterator< T >::ok(). Referenced by timeout_function(), and update(). { ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { if( li()->is_alive() || state != GAME_IN_PROGRESS ) li()->get_messages(); } }

Here is the call graph for this function:

int ArenaRealTime::set_debug_level (  const int  new_level  )  [virtual]

Reimplemented from ArenaBase. Definition at line 733 of file ArenaRealTime.cc. References broadcast(), DEBUG_LEVEL, GAME_OPTION, and ArenaBase::set_debug_level(). { ArenaBase::set_debug_level(new_level); if( GAME_IN_PROGRESS ) { broadcast(GAME_OPTION, DEBUG_LEVEL, (double)debug_level); } return debug_level; }

Here is the call graph for this function:

void ArenaRealTime::set_filenames (  String &  log_fname, const String &  statistics_fname, const String &  tournament_fname, String &  message_fname, const String &  option_fname )

Definition at line 101 of file ArenaRealTime.cc. References String::chars(), Error(), LOG_FILE, tournament_file_name, and use_log_file. Referenced by ArenaRealTime(). { bool log_stdout = false; if( log_fname == "" ) { use_log_file = false; } else if( log_fname == "-" || log_fname == "STDOUT" ) // use stdout as log_file { cout << "Attach -- Muss gefixt werden in ArenaREaltime.cc 113" << endl; //LOG_FILE.attach(STDOUT_FILENO); use_log_file = true; log_stdout = true; } else { //LOG_FILE.open(log_fname.chars(), ios::out, S_IRUSR | S_IWUSR); LOG_FILE.open(log_fname.chars(), ios::out); use_log_file = true; if( !LOG_FILE ) { Error( false, "Couldn't open log file. Contuing without log file", "ArenaRealTime::set_filenames" ); use_log_file = false; } } if( message_fname == "" ) { use_message_file = false; } else if( message_fname == "-" || message_fname == "STDOUT" ) { if( !log_stdout ) { use_message_file = true; //message_file.attach( STDOUT_FILENO ); } else { use_message_file = false; } } else { use_message_file = true; //message_file.open( message_fname.chars(), ios::out, S_IRUSR | S_IWUSR ); if( !message_file ) { Error( false, "Couldn't open message file. Message file disabled", "ArenaRealTime::set_filenames" ); use_message_file = false; } } statistics_file_name = statistics_fname; tournament_file_name = tournament_fname; option_file_name = option_fname; }

Here is the call graph for this function:

void ArenaRealTime::start_game (   )  [private, virtual]

Implements ArenaBase. Definition at line 746 of file ArenaRealTime.cc. References _, BEFORE_GAME_START, broadcast(), Options::broadcast_opts(), ArenaWindow::clear_area(), current_arena_nr, ArenaWindow::drawing_area_scale_changed(), Error(), String::find(), List< T >::first(), GAME_IN_PROGRESS, GAME_STARTS, Gui::get_arenawindow_p(), Options::get_d(), Robot::get_messages(), List< T >::get_nth(), get_random_position(), Gui::get_scorewindow_p(), get_segment(), List< T >::insert_last(), Robot::live(), Robot::move(), next_check_time, number_of_arenas, ListIterator< T >::ok(), OPTION_CHECK_INTERVAL, OPTION_ROBOT_RADIUS, parse_arena_file(), PAUSING_BETWEEN_GAMES, ArenaBase::print_message(), print_to_logfile(), ArenaBase::reset_timer(), ROBOTS_LEFT, Robot::send_signal(), ArenaBase::set_state(), Robot::set_values_before_game(), ArenaWindow::set_window_title(), ScoreWindow::set_window_title(), ArenaBase::space_available(), the_gui, the_opts, update_count_for_logging, and ScoreWindow::update_robots(). Referenced by end_game(), start_sequence_follow_up(), and timeout_function(). { // put the arena together if( pause_after_next_game ) { set_state( PAUSING_BETWEEN_GAMES ); return; } current_arena_nr = current_arena_nr % number_of_arenas + 1; String* filename = arena_filenames.get_nth(current_arena_nr); print_to_logfile('G', sequence_nr, game_nr + 1); parse_arena_file(*filename); int charpos; if( (charpos = filename->find('/',0,true)) != -1 ) current_arena_filename = get_segment(*filename, charpos+1, -1); else Error(true, "Incomplete arena file path" + *filename, "ArenaRealTime::start_game"); char msg[128]; snprintf( msg, 127, _("Game %d of sequence %d begins on arena"), game_nr+1, sequence_nr ); print_message( "RealTimeBattle", String(msg) + " " + current_arena_filename ); // reset some variables shot_count = 0; cookie_count = 0; mine_count = 0; // Place robots on the arena Robot* robotp; bool found_space; double angle; Vector2D pos; robots_left = 0; set_state( BEFORE_GAME_START ); ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { robotp = li(); robotp->get_messages(); found_space = false; for( int i=0; i<100 && !found_space; i++) { pos = get_random_position(); found_space = space_available(pos, the_opts.get_d(OPTION_ROBOT_RADIUS)*1.2); } if( !found_space ) Error(true, "Couldn't find space for all robots", "ArenaRealTime::start_game"); angle = ((double)rand())*2.0*M_PI/RAND_MAX; robotp->set_values_before_game(pos, angle); object_lists[ROBOT].insert_last(robotp); robots_left++; robotp->live(); } // print_to_logfile('G', sequence_nr, games_per_sequence - games_remaining_in_sequence + 1); broadcast(GAME_STARTS); broadcast(ROBOTS_LEFT, robots_left); the_opts.broadcast_opts(); update_count_for_logging = 0; print_to_logfile('T', 0.0); ListIterator<Shape> li2; for( object_lists[ROBOT].first(li2); li2.ok(); li2++ ) { robotp = (Robot*)li2(); robotp->send_signal(); robotp->move(0.0); // To log current position } set_state( GAME_IN_PROGRESS ); game_nr++; #ifndef NO_GRAPHICS if( !no_graphics ) { the_gui.get_arenawindow_p()->clear_area(); the_gui.get_arenawindow_p()->drawing_area_scale_changed(); the_gui.get_scorewindow_p()->update_robots(); reset_timer(); // Time should be zero in score window the_gui.get_scorewindow_p()->set_window_title(); the_gui.get_arenawindow_p()->set_window_title(); } #endif reset_timer(); // Game starts ! next_check_time = total_time + the_opts.get_d(OPTION_CHECK_INTERVAL); }

Here is the call graph for this function:

void ArenaRealTime::start_sequence (   )  [private, virtual]

Implements ArenaBase. Definition at line 883 of file ArenaRealTime.cc. References current_arena_nr, List< T >::first(), Options::get_d(), Robot::get_outstreamp(), Robot::is_networked(), next_check_time, ListIterator< T >::ok(), OPTION_ROBOT_STARTUP_TIME, ArenaBase::reset_timer(), robots_in_sequence, ArenaBase::set_state(), Robot::set_values_at_process_start_up(), Robot::start_process(), STARTING_ROBOTS, and the_opts. Referenced by end_sequence_follow_up(), and start_tournament(). { game_nr = 0; current_arena_nr = 0; // Make list of robots in this sequence for(int i=0; i<robots_per_game; i++) { all_robots_in_sequence. insert_last( all_robots_in_tournament. get_nth(robots_in_sequence[sequence_nr][i])); } // execute robot processes Robot* robotp; ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { robotp = li(); if( robotp->is_networked() ) { *robotp->get_outstreamp() << "@R" << endl; robotp->set_values_at_process_start_up(); } else robotp->start_process(); } // wait a second before checking set_state( STARTING_ROBOTS ); sequence_nr++; reset_timer(); next_check_time = total_time + the_opts.get_d(OPTION_ROBOT_STARTUP_TIME); }

Here is the call graph for this function:

void ArenaRealTime::start_sequence_follow_up (   )  [private]

Definition at line 923 of file ArenaRealTime.cc. References _, String::chars(), COLOUR_NOT_GIVEN, find_free_colour(), List< T >::first(), Shape::get_id(), Shape::get_rgb_colour(), Robot::get_robot_filename(), Robot::get_robot_name(), Robot::is_colour_given(), Robot::is_name_given(), Robot::is_networked(), Robot::is_process_running(), NAME_NOT_GIVEN, ListIterator< T >::ok(), ArenaBase::print_message(), print_to_logfile(), List< T >::remove(), Robot::send_message(), Robot::set_and_get_has_competed(), Shape::set_colour(), Robot::set_colour_given(), start_game(), and WARNING. Referenced by timeout_function(). { // check if the process have started correctly Robot* robotp = NULL; ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) { robotp = li(); if( !(robotp->is_networked()) && !(robotp->is_process_running()) ) { all_robots_in_sequence.remove(li); robots_left--; } else { if( !robotp->set_and_get_has_competed() ) print_to_logfile('L', robotp->get_id(), robotp->get_rgb_colour(), robotp->get_robot_name().chars()); if( !robotp->is_name_given() ) { robotp->send_message(WARNING, NAME_NOT_GIVEN, ""); char msg[128]; snprintf( msg, 127, _("Robot with filename %s has not given any name"), robotp->get_robot_filename().chars() ); print_message( "RealTimeBattle", String(msg) ); } if( !robotp->is_colour_given() ) { robotp->send_message(WARNING, COLOUR_NOT_GIVEN, ""); robotp->set_colour( find_free_colour( 0, 0, robotp, true ) ); robotp->set_colour_given( true ); } } } start_game(); }

Here is the call graph for this function:

void ArenaRealTime::start_tournament (  const List< start_tournament_info_t > &  robotfilename_list, const List< start_tournament_info_t > &  arenafilename_list, const int  robots_p_game, const int  games_p_sequence, const int  n_o_sequences )

Definition at line 1017 of file ArenaRealTime.cc. References binomial(), clear(), MessageWindow::clear_clist(), Error(), start_tournament_info_t::filename, List< T >::first(), Gui::get_messagewindow_p(), Timer::get_random_seed(), List< T >::insert_last(), Gui::is_arenawindow_up(), Gui::is_messagewindow_up(), Gui::is_scorewindow_up(), Options::log_all_options(), number_of_arenas, ListIterator< T >::ok(), Gui::open_arenawindow(), Gui::open_messagewindow(), Gui::open_scorewindow(), print_to_logfile(), reorder_pointer_array(), robots_in_sequence, start_sequence(), the_gui, and the_opts. { clear(); // Open windows if they were closed, else clear them #ifndef NO_GRAPHICS if( !no_graphics ) { if( the_gui.is_messagewindow_up() ) MessageWindow::clear_clist( NULL, the_gui.get_messagewindow_p() ); else //if( !use_message_file ) the_gui.open_messagewindow(); if( !the_gui.is_scorewindow_up() ) the_gui.open_scorewindow(); if( !the_gui.is_arenawindow_up() ) the_gui.open_arenawindow(); } #endif // Create robot classes and put them into the list all_robots_in_tournament number_of_robots = 0; robot_count = 0; Robot* robotp; start_tournament_info_t* infop = NULL; String* stringp; ListIterator<start_tournament_info_t> li; for( robotfilename_list.first(li); li.ok(); li++ ) { infop = li(); robotp = new Robot(infop->filename); all_robots_in_tournament.insert_last( robotp ); number_of_robots++; } // Create list of arena filenames number_of_arenas = 0; for( arenafilename_list.first(li); li.ok(); li++ ) { stringp = new String(li()->filename); arena_filenames.insert_last( stringp ); number_of_arenas++; } robots_per_game = robots_p_game; games_per_sequence = games_p_sequence; sequences_in_tournament = n_o_sequences; // make list of robots to compete in the sequences int games_per_round = binomial(number_of_robots, robots_per_game); int complete_rounds = n_o_sequences / games_per_round; int rem_games = n_o_sequences % games_per_round; robots_in_sequence = new (int*)[n_o_sequences]; for(int i=0; i<n_o_sequences; i++) robots_in_sequence[i] = new int[robots_per_game]; int current_sequence[robots_per_game]; int current_nr = 0; // for(int i=0; i<robots_per_game; i++) current_sequence[i] = i+1; // set complete rounds first for(int round_nr=0; round_nr < complete_rounds; round_nr++) { int k, i, j; for(i=0; i<robots_per_game; i++) current_sequence[i] = i+1; current_sequence[robots_per_game-1]--; // To be increased first time for(i=0; i< games_per_round; i++) { k = robots_per_game - 1; while( current_sequence[k] == number_of_robots + 1 - robots_per_game + k ) k--; if( k < 0 ) Error(true, "Problem generating list of participants, k < 0", "ArenaRealTime::start_tournament"); current_sequence[k]++; for(j=k+1; j<robots_per_game; j++) current_sequence[j] = current_sequence[j-1]+1; for(j=0; j<robots_per_game; j++) robots_in_sequence[current_nr][j] = current_sequence[j]; current_nr++; } reorder_pointer_array((void**)robots_in_sequence, games_per_round); } // the remaining game will be randomly chosen int robot_matches_played[number_of_robots]; for(int i=0; i<number_of_robots; i++) robot_matches_played[i] = 0; bool robot_playing_this_match[number_of_robots]; int min_matches_played = 0; int number_of_robots_on_min_matches = number_of_robots; int nr; for(int i=0; i< rem_games; i++) { for(int i2=0; i2<number_of_robots; i2++) robot_playing_this_match[i2] = false; for(int j=0; j<robots_per_game; j++) { do nr = (int)floor(number_of_robots*((double)rand() / (double)RAND_MAX)); while( robot_playing_this_match[nr] || robot_matches_played[nr] != min_matches_played ); robot_playing_this_match[nr] = true; robot_matches_played[nr]++; number_of_robots_on_min_matches--; if( number_of_robots_on_min_matches == 0 ) { min_matches_played++; number_of_robots_on_min_matches = number_of_robots; } robots_in_sequence[current_nr][j] = nr + 1; // robot count will start from 1 } current_nr++; } // set random seed srand(timer.get_random_seed()); // start first sequence print_to_logfile('H', games_per_sequence, robots_per_game, sequences_in_tournament, number_of_robots); the_opts.log_all_options(); sequence_nr = 0; start_sequence(); }

Here is the call graph for this function:

void ArenaRealTime::start_tournament_from_tournament_file (  const List< start_tournament_info_t > &  robotfilename_list, const List< start_tournament_info_t > &  arenafilename_list, const int  robots_p_game, const int  games_p_sequence, const int  n_o_sequences, ArenaRealTime *  ar_p )  [static]

Definition at line 1006 of file ArenaRealTime.cc. Referenced by timeout_function(). { ar_p->start_tournament( robotfilename_list, arenafilename_list, robots_p_game, games_p_sequence, n_o_sequences ); }

bool ArenaRealTime::timeout_function (   )  [virtual]

Implements ArenaBase. Definition at line 395 of file ArenaRealTime.cc. References add_cookie(), add_mine(), ArenaController::auto_start_and_end, BEFORE_GAME_START, check_robots(), end_game(), end_sequence_follow_up(), Error(), EXITING, FINISHED, List< T >::first(), GAME_IN_PROGRESS, Options::get_d(), Gui::get_scorewindow_p(), NO_STATE, NOT_STARTED, ListIterator< T >::ok(), OPTION_COOKIE_FREQUENCY, OPTION_MINE_FREQUENCY, OPTION_TIMEOUT, parse_tournament_file(), PAUSED, PAUSING_BETWEEN_GAMES, Quit(), read_robot_messages(), ArenaBase::save_statistics_to_file(), ArenaBase::set_state(), ScoreWindow::set_window_title(), SHUTTING_DOWN_ROBOTS, start_game(), start_sequence_follow_up(), start_tournament_from_tournament_file(), STARTING_ROBOTS, StartTournamentFunction, the_arena_controller, the_gui, the_opts, tournament_file_name, update(), and ArenaBase::update_timer(). { #ifndef NO_GRAPHICS int old_total = (int)total_time; #endif if( state != PAUSED ) { update_timer (); } switch(state) { case NOT_STARTED: if( the_arena_controller.auto_start_and_end ) parse_tournament_file( tournament_file_name, (StartTournamentFunction) ArenaRealTime::start_tournament_from_tournament_file, this ); break; case FINISHED: if( the_arena_controller.auto_start_and_end ) { if( statistics_file_name != "" ) save_statistics_to_file( statistics_file_name ); Quit(); } break; case STARTING_ROBOTS: { read_robot_messages(); if( total_time > next_check_time ) start_sequence_follow_up(); } break; case SHUTTING_DOWN_ROBOTS: { ListIterator<Robot> li; for( all_robots_in_sequence.first(li); li.ok(); li++ ) li()->get_messages(); if( total_time > next_check_time ) end_sequence_follow_up(); } break; case GAME_IN_PROGRESS: { update(); #ifndef NO_GRAPHICS if((int)total_time > old_total && !no_graphics) the_gui.get_scorewindow_p()->set_window_title(); #endif if( robots_left <= 1 || total_time > the_opts.get_d(OPTION_TIMEOUT) ) { end_game(); } else { if( game_mode == COMPETITION_MODE && total_time > next_check_time ) check_robots(); // Place mines and cookies if( ((double)rand()) / (double)RAND_MAX <= timestep*the_opts.get_d(OPTION_COOKIE_FREQUENCY) ) add_cookie(); if( ((double)rand()) / (double)RAND_MAX <= timestep*the_opts.get_d(OPTION_MINE_FREQUENCY) ) add_mine(); if( halt_next ) { set_state( PAUSED ); halt_next = false; } } } break; case PAUSED: break; case PAUSING_BETWEEN_GAMES: if( !pause_after_next_game ) start_game(); break; case EXITING: return false; case BEFORE_GAME_START: case NO_STATE: Error(true, "Arena shouldn't be in this state here!!", "ArenaRealTime::timeout_function"); } return true; }

Here is the call graph for this function:

void ArenaRealTime::update (   )  [private, virtual]

Implements ArenaBase. Definition at line 494 of file ArenaRealTime.cc. References ArenaWindow::draw_moving_objects(), MessageWindow::freeze_clist(), GAME_IN_PROGRESS, Gui::get_arenawindow_p(), Options::get_l(), Gui::get_messagewindow_p(), ArenaBase::move_shots(), OPTION_LOG_EVERY_NTH_UPDATE_INTERVAL, print_to_logfile(), read_robot_messages(), MessageWindow::thaw_clist(), the_gui, the_opts, update_count_for_logging, and update_robots(). Referenced by timeout_function(). { print_to_logfile('T', total_time); #ifndef NO_GRAPHICS if( state == GAME_IN_PROGRESS && !no_graphics) the_gui.get_messagewindow_p()->freeze_clist(); #endif read_robot_messages(); move_shots(timestep); update_robots(); #ifndef NO_GRAPHICS if( state == GAME_IN_PROGRESS && !no_graphics) { the_gui.get_arenawindow_p()->draw_moving_objects( true ); the_gui.get_messagewindow_p()->thaw_clist(); } #endif update_count_for_logging++; if( update_count_for_logging == the_opts.get_l(OPTION_LOG_EVERY_NTH_UPDATE_INTERVAL) ) update_count_for_logging = 0; }

Here is the call graph for this function:

void ArenaRealTime::update_robots (   )  [private]

Definition at line 595 of file ArenaRealTime.cc. References broadcast(), Robot::change_velocity(), Robot::display_score(), ENERGY, List< T >::first(), Robot::get_energy(), Options::get_l(), Robot::get_messages(), Robot::is_alive(), Robot::move(), ListIterator< T >::ok(), OPTION_ROBOT_ENERGY_LEVELS, List< T >::remove(), ROBOTS_LEFT, Robot::send_message(), the_opts, and Robot::update_radar_and_cannon(). Referenced by update(). { Robot* robotp; robots_killed_this_round = 0; ListIterator<Shape> li; for( object_lists[ROBOT].first(li); li.ok(); li++ ) { robotp = (Robot*)li(); if( robotp->is_alive() ) { robotp->update_radar_and_cannon(timestep); robotp->change_velocity(timestep); robotp->move(timestep); } if( robotp->is_alive() ) robotp->get_messages(); } // Check if robots have died and send energy level for( object_lists[ROBOT].first(li); li.ok(); li++ ) { robotp = (Robot*)li(); if( !robotp->is_alive() ) { object_lists[ROBOT].remove(li); robots_killed_this_round++; } else { double lvls = (double)the_opts.get_l(OPTION_ROBOT_ENERGY_LEVELS); robotp->send_message( ENERGY, rint( robotp->get_energy() / lvls ) * lvls ); } } robots_left -= robots_killed_this_round; if( robots_killed_this_round > 0 ) { for( object_lists[ROBOT].first(li); li.ok(); li++ ) { robotp = (Robot*)li(); // robotp->add_points(robots_killed_this_round); #ifndef NO_GRAPHICS if( robots_left < 15 && !no_graphics ) robotp->display_score(); #endif } ListIterator<Robot> li2; for( all_robots_in_sequence.first(li2); li2.ok(); li2++ ) if( li2()->is_dead_but_stats_not_set() ) li2()->set_stats(robots_killed_this_round); broadcast(ROBOTS_LEFT, robots_left); } for( object_lists[ROBOT].first(li); li.ok(); li++ ) ((Robot*)li())->send_signal(); }

Here is the call graph for this function:

---

Field Documentation

int ArenaRealTime::current_arena_nr [private]

Definition at line 107 of file ArenaRealTime.h. Referenced by start_game(), and start_sequence().

ofstream ArenaRealTime::LOG_FILE [private]

Definition at line 98 of file ArenaRealTime.h. Referenced by print_to_logfile(), set_filenames(), and ~ArenaRealTime().

double ArenaRealTime::next_check_time [private]

Definition at line 104 of file ArenaRealTime.h. Referenced by check_robots(), end_sequence(), start_game(), and start_sequence().

int ArenaRealTime::number_of_arenas [private]

Definition at line 106 of file ArenaRealTime.h. Referenced by start_game(), and start_tournament().

int** ArenaRealTime::robots_in_sequence [private]

Definition at line 102 of file ArenaRealTime.h. Referenced by ArenaRealTime(), clear(), start_sequence(), start_tournament(), and ~ArenaRealTime().

String ArenaRealTime::tournament_file_name [private]

Definition at line 96 of file ArenaRealTime.h. Referenced by set_filenames(), and timeout_function().

int ArenaRealTime::update_count_for_logging [private]

Definition at line 100 of file ArenaRealTime.h. Referenced by print_to_logfile(), start_game(), and update().

bool ArenaRealTime::use_log_file [private]

Definition at line 99 of file ArenaRealTime.h. Referenced by set_filenames(), and ~ArenaRealTime().

---

The documentation for this class was generated from the following files:

• ArenaRealTime.h
• ArenaRealTime.cc

---