added cutoff options to playgame and ants, tracking winning and ranking turn in db

Author: McLeopold

ants/ants.py

@@ -2,7 +2,7 @@
 from random import randrange, choice, shuffle, randint, seed
 from math import sqrt
 import os
-from collections import deque, defaultdict
+from collections import deque, defaultdict, OrderedDict
 from fractions import Fraction
 import operator
 import string
@@ -54,14 +54,16 @@ def __init__(self, options=None):
         if type(self.food_visible) in (list, tuple):
             self.food_visible = randrange(*self.food_visible)
         self.food_extra = Fraction(0,1)
+        
+        self.cutoff_percent = options.get('cutoff_percent', 0.90)
+        self.cutoff_turn = options.get('cutoff_turn', 100)
 
         self.do_attack = {
-            'occupied': self.do_attack_power,
-            'power':   self.do_attack_power,
+            'focus':   self.do_attack_focus,
             'closest': self.do_attack_closest,
             'support': self.do_attack_support,
             'damage':  self.do_attack_damage
-        }.get(options.get('attack'), self.do_attack_power)
+        }.get(options.get('attack'), self.do_attack_focus)
 
         self.do_food = {
             'none':      self.do_food_none,
@@ -86,13 +88,17 @@ def __init__(self, options=None):
         self.score = [Fraction(0,1)]*self.num_players
         self.score_history = [[s] for s in self.score]
         self.bonus = [0 for s in self.score]
-        self.pop_count = {i: 0 for i in range(self.num_players)}
-        self.pop_count[FOOD] = 0
-        self.winning_ant = LAND # Can be ant owner, FOOD or LAND
-        self.winning_turns = 0
-        self.cutoff_percent = 0.90
-        self.cutoff_turns = 100
-
+        
+        # used to cutoff games early
+        self.cutoff_bot = LAND # Can be ant owner, FOOD or LAND
+        self.cutoff_turns = 0        
+        # used to calculate the turn when the winner took the lead
+        self.winning_bot = None
+        self.winning_turn = 0
+        # used to calculate when the player rank last changed
+        self.ranking_bots = None
+        self.ranking_turn = 0
+        
         # initialise size
         self.height, self.width = map_data['size']
         self.land_area = self.height*self.width - len(map_data['water'])
@@ -766,12 +772,12 @@ def do_attack_support(self):
             for enemy in enemies:
                 self.score[enemy.owner] += Fraction(1, score_share)
 
-    def do_attack_power(self):
+    def do_attack_focus(self):
         """ Kill ants which are the most surrounded by enemies
 
-            For a given ant define: Power = 1/NumOpponents
+            For a given ant define: Focus = 1/NumOpponents
             An ant's Opponents are enemy ants which are within the attackradius.
-            Ant alive if its Power is greater than Power of any of his Opponents.
+            Ant alive if its Focus is greater than Focus of any of his Opponents.
             If an ant dies 1 point is shared equally between its Opponents.
         """
 
@@ -783,12 +789,12 @@ def do_attack_power(self):
         # determine which ants to kill
         ants_to_kill = []
         for ant in self.current_ants.values():
-            # determine this ants weakness (1/power)
+            # determine this ants weakness (1/focus)
             weakness = len(nearby_enemies[ant])
             # an ant with no enemies nearby can't be attacked
             if weakness == 0:
                 continue
-            # determine the most powerful nearby enemy
+            # determine the most focused nearby enemy
             min_enemy_weakness = min(len(nearby_enemies[enemy]) for enemy in nearby_enemies[ant])
             # ant dies if it is weak as or weaker than an enemy weakness
             if min_enemy_weakness <= weakness:
@@ -1113,7 +1119,7 @@ def game_over(self):
         """
         if self.remaining_players() <= 1:
             return True
-        if self.winning_turns >= self.cutoff_turns:
+        if self.cutoff_turns >= self.cutoff_turn:
             return True
         return False
 
@@ -1134,11 +1140,13 @@ def finish_game(self):
         """ Called by engine at the end of the game """
         players = [p for p in range(self.num_players) if self.is_alive(p)]
 
-        # food bonus is split between the surviving players
-        # if there is more than one player, then the game either
-        #   went the full length and there is no bonus
-        #   or the game was cut off
-        if self.turn < self.turns:
+        # if there is exactly one player remaining they get food bonus
+        # if the game ends early there is no bonus
+        #    the bonus only exists to ensure a lone survivor the best chance at winning
+        #    simply removing the bonus is the best disincentive to not ending the game
+        #    games ending do to inactivity would not have the player rank changed by splitting the bonus
+        if len(players) == 1:
+            player = players[0]
             # the food bonus represents the maximum points a bot can get with perfect play
             # remaining food and food to be spawned would be 1 point
             #   either from collecting the food and spawning an ant
@@ -1150,12 +1158,11 @@ def finish_game(self):
                 + self.food_extra
                 + len(self.current_food) # food that hasn't been collected
                 # enemy ants (player ants already received point when spawned)
-                + len([ant for ant in self.current_ants.values() if not ant.owner in players])
+                + len([ant for ant in self.current_ants.values() if ant.owner != player])
             )
-            for player in players:
-                self.score[player] += food_bonus // len(players)
-                # separate bonus from score history
-                self.bonus[player] = food_bonus // len(players)
+            self.score[player] += food_bonus
+            # separate bonus from score history
+            self.bonus[player] = food_bonus
 
     def start_turn(self):
         """ Called by engine at the start of the turn """
@@ -1202,17 +1209,27 @@ def finish_turn(self):
         pop_total = sum(pop_count.values())
         for owner, count in pop_count.items():
             if count >= pop_total * self.cutoff_percent:
-                if self.winning_ant == owner:
-                    self.winning_turns += 1
+                if self.cutoff_bot == owner:
+                    self.cutoff_turns += 1
                 else:
-                    self.winning_ant = owner
-                    self.winning_turns = 1
+                    self.cutoff_bot = owner
+                    self.cutoff_turns = 1
                 break
         else:
-            self.winning_ant = LAND
-            self.winning_turns = 0
-        self.pop_count = pop_count
-
+            self.cutoff_bot = LAND
+            self.cutoff_turns = 0
+        
+        scores = [int(score) for score in self.score]
+        ranking_bots = [sorted(set(scores), reverse=True).index(x) for x in scores]
+        if self.ranking_bots != ranking_bots:
+            self.ranking_turn = self.turn
+        self.ranking_bots = ranking_bots
+        
+        winning_bot = [p for p in range(len(scores)) if scores[p] == max(scores)]
+        if self.winning_bot != winning_bot:
+            self.winning_turn = self.turn
+        self.winning_bot = winning_bot
+        
     def get_state(self):
         """ Get all state changes
 
@@ -1308,9 +1325,18 @@ def get_stats(self):
         ant_count = [0 for i in range(self.num_players+1)]
         for loc, ant in self.current_ants.items():
             ant_count[ant.owner] += 1
-        ant_count[-1] = len(self.current_food)
-        return {'ant_count': ant_count, 'winning_ant': self.winning_ant, 'winning_turns': self.winning_turns}
-
+        stats = OrderedDict()
+        stats['ant_count'] = ant_count
+        stats['food'] = len(self.current_food)
+        stats['cutoff'] = 'Food' if self.cutoff_bot == FOOD else '-' if self.cutoff_bot == LAND else self.cutoff_bot
+        stats['c_turns'] = self.cutoff_turns
+        stats['winning'] = self.winning_bot
+        stats['w_turn'] = self.winning_turn
+        stats['ranking_bots'] = self.ranking_bots
+        stats['r_turn'] = self.ranking_turn
+        stats['score'] = map(int, self.score)
+        return stats
+    
     def get_replay(self):
         """ Return a summary of the entire game
 
@@ -1368,6 +1394,9 @@ def get_replay(self):
         # score_history contains Fraction objects, so round down with int function
         replay['scores'] = [map(int, s) for s in self.score_history]
         replay['bonus'] = map(int, self.bonus)
+        replay['winning_turn'] = self.winning_turn
+        replay['ranking_turn'] = self.ranking_turn
+        replay['cutoff'] = bool(self.remaining_players() <= 1 and self.turns > self.turn)
 
         return replay
 

ants/play_one_game.cmd

@@ -1,3 +1,3 @@
 @echo off
-python %~dp0playgame.py --player_seed 42 --end_wait=0.25 --verbose --log_dir game_logs --turns 1000 --map_file %~dp0maps\symmetric_maps\symmetric_10.map %* "python %~dp0dist\sample_bots\python\HoldBot.py" "python %~dp0dist\sample_bots\python\HoldBot.py" "python %~dp0dist\sample_bots\python\HunterBot.py" "python %~dp0dist\sample_bots\python\LeftyBot.py"
+python %~dp0playgame.py --engine_seed 42 --player_seed 42 --end_wait=0.25 --verbose --log_dir game_logs --turns 1000 --map_file %~dp0maps\symmetric_maps\symmetric_10.map %* "python %~dp0dist\sample_bots\python\HunterBot.py" "python %~dp0dist\sample_bots\python\LeftyBot.py" "python %~dp0dist\sample_bots\python\HunterBot.py" "python %~dp0dist\sample_bots\python\LeftyBot.py"
 

ants/playgame.py

@@ -4,7 +4,7 @@
 import sys
 import os
 import time
-from optparse import OptionParser
+from optparse import OptionParser, OptionGroup
 import random
 import cProfile
 import visualizer.visualize_locally
@@ -133,21 +133,35 @@ def main(argv):
                       help='Player position for first bot specified')
 
     # ants specific game options
-    parser.add_option("--attack", dest="attack",
-                      default="occupied",
-                      help="Attack method to use for engine. (closest, occupied, support, damage)")
-    parser.add_option("--food", dest="food",
-                      default="symmetric",
-                      help="Food spawning method. (none, random, sections, symmetric)")
-    parser.add_option("--viewradius2", dest="viewradius2",
-                      default=55, type="int",
-                      help="Vision radius of ants squared")
-    parser.add_option("--spawnradius2", dest="spawnradius2",
-                      default=1, type="int",
-                      help="Spawn radius of ants squared")
-    parser.add_option("--attackradius2", dest="attackradius2",
-                      default=5, type="int",
-                      help="Attack radius of ants squared")
+    game_group = OptionGroup(parser, "Game Options", "Options that affect the game mechanics for ants")
+    game_group.add_option("--attack", dest="attack",
+                          default="focus",
+                          help="Attack method to use for engine. (closest, focus, support, damage)")
+    game_group.add_option("--food", dest="food",
+                          default="symmetric",
+                          help="Food spawning method. (none, random, sections, symmetric)")
+    game_group.add_option("--viewradius2", dest="viewradius2",
+                          default=55, type="int",
+                          help="Vision radius of ants squared")
+    game_group.add_option("--spawnradius2", dest="spawnradius2",
+                          default=1, type="int",
+                          help="Spawn radius of ants squared")
+    game_group.add_option("--attackradius2", dest="attackradius2",
+                          default=5, type="int",
+                          help="Attack radius of ants squared")
+    game_group.add_option("--food_rate", dest="food_rate", nargs=2, type="int", default=(2,8),
+                          help="Numerator of food per turn per player rate")
+    game_group.add_option("--food_turn", dest="food_turn", nargs=2, type="int", default=(12,30),
+                          help="Denominator of food per turn per player rate")
+    game_group.add_option("--food_start", dest="food_start", nargs=2, type="int", default=(75,175),
+                          help="One over percentage of land area filled with food at start")
+    game_group.add_option("--food_visible", dest="food_visible", nargs=2, type="int", default=(1,3),
+                          help="Amount of food guaranteed to be visible to starting ants")
+    game_group.add_option("--cutoff_turn", dest="cutoff_turn", type="int", default=100,
+                          help="Number of turns cutoff percentage is maintained to end game early")
+    game_group.add_option("--cutoff_percent", dest="cutoff_percent", type="float", default=0.90,
+                          help="Number of turns cutoff percentage is maintained to end game early")
+    parser.add_option_group(game_group)
 
     # the log directory must be specified for any logging to occur, except:
     #    bot errors to stderr
@@ -156,43 +170,45 @@ def main(argv):
     # the log directory will contain
     #    the replay or stream file used by the visualizer, if requested
     #    the bot input/output/error logs, if requested    
-    parser.add_option("-g", "--game", dest="game_id", default=0, type='int',
-                      help="game id to start at when numbering log files")
-    parser.add_option("-l", "--log_dir", dest="log_dir", default=None,
-                      help="Directory to dump replay files to.")
-    parser.add_option('-R', '--log_replay', dest='log_replay',
-                       action='store_true', default=False),
-    parser.add_option('-S', '--log_stream', dest='log_stream',
-                       action='store_true', default=False),
-    parser.add_option("-I", "--log_input", dest="log_input",
-                       action="store_true", default=False,
-                       help="Log input streams sent to bots")
-    parser.add_option("-O", "--log_output", dest="log_output",
-                       action="store_true", default=False,
-                       help="Log output streams from bots")
-    parser.add_option("-E", "--log_error", dest="log_error",
-                       action="store_true", default=False,
-                       help="log error streams from bots")
-    parser.add_option('-e', '--log_stderr', dest='log_stderr',
-                       action='store_true', default=False,
-                       help='additionally log bot errors to stderr')
-    parser.add_option('-o', '--log_stdout', dest='log_stdout',
-                       action='store_true', default=False,
-                       help='additionally log replay/stream to stdout')
+    log_group = OptionGroup(parser, "Logging Options", "Options that control the logging")
+    log_group.add_option("-g", "--game", dest="game_id", default=0, type='int',
+                         help="game id to start at when numbering log files")
+    log_group.add_option("-l", "--log_dir", dest="log_dir", default=None,
+                         help="Directory to dump replay files to.")
+    log_group.add_option('-R', '--log_replay', dest='log_replay',
+                         action='store_true', default=False),
+    log_group.add_option('-S', '--log_stream', dest='log_stream',
+                         action='store_true', default=False),
+    log_group.add_option("-I", "--log_input", dest="log_input",
+                         action="store_true", default=False,
+                         help="Log input streams sent to bots")
+    log_group.add_option("-O", "--log_output", dest="log_output",
+                         action="store_true", default=False,
+                         help="Log output streams from bots")
+    log_group.add_option("-E", "--log_error", dest="log_error",
+                         action="store_true", default=False,
+                         help="log error streams from bots")
+    log_group.add_option('-e', '--log_stderr', dest='log_stderr',
+                         action='store_true', default=False,
+                         help='additionally log bot errors to stderr')
+    log_group.add_option('-o', '--log_stdout', dest='log_stdout',
+                         action='store_true', default=False,
+                         help='additionally log replay/stream to stdout')
     # verbose will not print bot input/output/errors
     # only info+debug will print bot error output
-    parser.add_option("-v", "--verbose", dest="verbose",
-                      action='store_true', default=False,
-                      help="Print out status as game goes.")
-    parser.add_option("--profile", dest="profile",
-                       action="store_true", default=False,
-                       help="Run under the python profiler")
+    log_group.add_option("-v", "--verbose", dest="verbose",
+                         action='store_true', default=False,
+                         help="Print out status as game goes.")
+    log_group.add_option("--profile", dest="profile",
+                         action="store_true", default=False,
+                         help="Run under the python profiler")
     parser.add_option("--nolaunch", dest="nolaunch",
                       action='store_true', default=False,
                       help="Prevent visualizer from launching")
-    parser.add_option("--html", dest="html_file",
-                      default=None,
-                      help="Output file name for an html replay")
+    log_group.add_option("--html", dest="html_file",
+                         default=None,
+                         help="Output file name for an html replay")
+    parser.add_option_group(log_group)
 
     (opts, args) = parser.parse_args(argv)
     if opts.map is None or not os.path.exists(opts.map):
@@ -253,7 +269,13 @@ def get_cmd_name(cmd):
         "turntime": opts.turntime,
         "turns": opts.turns,
         "player_seed": opts.player_seed,
-        "engine_seed": opts.engine_seed }
+        "engine_seed": opts.engine_seed,
+        "food_rate": opts.food_rate,
+        "food_turn": opts.food_turn,
+        "food_start": opts.food_start,
+        "food_visible": opts.food_visible,
+        "cutoff_turn": opts.cutoff_turn,
+        "cutoff_percent": opts.cutoff_percent }
     engine_options = {
         "loadtime": opts.loadtime,
         "turntime": opts.turntime,

setup/server_info.php.template

@@ -16,10 +16,10 @@ $server_info = array(
     "api_create_key" => "",
     "api_log" => "{log_dir}/api_log.txt",
     "game_options" => array (
-        "turns" => 2000,
+        "turns" => 1500,
         "loadtime" => 3000,
         "turntime" => 500,
-        "viewradius2" => 55,
+        "viewradius2" => 77,
         "attackradius2" => 5,
         "spawnradius2" => 1,
         "location" => "{api_url}",
@@ -29,7 +29,9 @@ $server_info = array(
         "food_start" => array(75,175),
         "food_visible" => array(1,3),
         "food" => "symmetric",
-        "attack" => "power"
+        "attack" => "focus",
+        "cutoff_turn" => 100,
+        "cutoff_percent" => 0.90
     )
 );