Merge pull request #17 from dgets/develop

Develop

Author: dgets

MyBot-v2b.py

@@ -2,7 +2,7 @@
 import logging
 from operator import itemgetter
 
-game = hlt.Game("D4m0b0t - v2b - rewrite & flow restructuring")
+game = hlt.Game("D4m0b0t - v2.1b - rewrite & flow restructuring")
 
 def docked_actions(current_ship):
     """
@@ -36,41 +36,21 @@ def docked_actions(current_ship):
                 undock_process_list[current_ship] = current_ship.planet
                 command_queue.append(ship.undock(current_ship.planet))
 
-def undocked_actions(current_ship):
+def target_planet(current_ship, planets_ranked_by_distance, planets_ranked_ours_by_docked, planets_ranked_untapped):
     """
-    Determine what to do with the undocked ship
+    Determine if a planet is a viable target for mining; create the navigation command if so
     :param Ship current_ship:
-    :return: command to append to the command_queue
-    :rtype: List
+    :param List of Tuples planets_ranked_by_distance:
+    :param List of Tuples planets_ranked_ours_by_docked:
+    :param List of Tuples planets_ranked_untapped:
+    :return: navigation command for command_queue or None
+    :rtype: String or None
     """
-    if DEBUGGING['method_entry']:
-        log.debug("undocked_actions():")
-        
-    if DEBUGGING['ship_loop']:
-        log.debug("-+=Undocked ship #" + str(current_ship.id) + "=+-")
-                
-    #did we just complete undocking?
-    if current_ship in undock_process_list.keys():
-        if DEBUGGING['docking_procedures']:
-            log.debug(" - completed undocking")
-            
-        undock_process_list.remove(current_ship)
-                
-    success = False
-    ranked_planets_by_distance = entity_sort_by_distance(current_ship, game_map.all_planets())
-    ranked_our_planets_by_docked = planet_sort_ours_by_docked(game_map.all_planets())
-    enemies = get_enemy_ships()
     navigate_command = None
 
-    #avoid boobytraps in our considerations
-    #if len(planets_to_avoid) > 0:
-    ranked_untapped_planets = remove_tapped_planets(ranked_planets_by_distance, planets_to_avoid)
-    #else:
-    #    ranked_untapped_planets = ranked_planets_by_distance
-        
     #do we navigate to a planet, reinforce, or go offensive?
     #navigate to a planet or begin docking (this also currently handles reinforcing)
-    for potential_planet in remove_held_planets(ranked_untapped_planets):
+    for potential_planet in remove_held_planets(planets_ranked_untapped):
         if (potential_planet['entity_object'] in targeted_list) or \
             (potential_planet['entity_object'].num_docking_spots == len(potential_planet['entity_object'].all_docked_ships())):
                 if DEBUGGING['targeting']:
@@ -85,7 +65,7 @@ def undocked_actions(current_ship):
             navigate_command = current_ship.dock(potential_planet['entity_object'])
             if potential_planet['entity_object'] in targeted_list:
                 if DEBUGGING['planet_selection']:
-                    log.debug(" - removing planet #" + str(potential_planet['entity_object'].id + " from targeted_list"))
+                    log.debug(" - removing planet #" + str(potential_planet['entity_object'].id) + " from targeted_list")
 
                 targeted_list.remove(potential_planet['entity_object'])
             break
@@ -101,37 +81,117 @@ def undocked_actions(current_ship):
                     ignore_ships = False)
             break
 
-    if not navigate_command:    
-        #potential_angle = other_entities_in_vicinity(current_ship, enemies, ranked_untapped_planets[0]['distance'])
-        if ALGORITHM['offense']: # and potential_angle:
-            #another entity is closer or at the same distance; we need to go offensive
-            if DEBUGGING['offense']:
-                log.debug("Engaging enemy")
+    return navigate_command
 
-                navigate_command = current_ship.navigate(
-                    current_ship.closest_point_to(entity_sort_by_distance(current_ship, enemies)[0]['entity_object']),
-                    game_map,
-                    speed = default_speed,
-                    ignore_ships = False)
-            elif ALGORITHM['reinforce'] and len(ranked_our_planets_by_docked) > 0:
-                #reinforce that sucker
-                if DEBUGGING['reinforce']:
-                    log.debug("Reinforcing planet #" + str(ranked_our_planets_by_docked[0]['entity_object'].id))
-
-                if current_ship.can_dock(ranked_our_planets_by_docked[0]['entity_object']):
-                    if DEBUGGING['reinforce']:
-                        log.debug(" - docking @ planet #" + str(ranked_our_planets_by_docked[0]['entity_object'].id))
+def go_offensive(current_ship, enemies):
+    """
+    Returns navigation command for offense, or None if not the best course of action at this juncture
+    :param Ship current_ship:
+    :param List of Tuples enemies:
+    :return navigation_command or None:
+    :rtype: String or None
+    """
+    navigate_command = None
+
+    if DEBUGGING['offense']:
+        log.debug("Engaging enemy")
+
+    closest_enemy = entity_sort_by_distance(current_ship, enemies)[0]['entity_object']
+            
+    if ALGORITHM['kamikaze']:
+        potential_kamikaze_angle = other_entities_in_vicinity(current_ship, enemies, 100)
+                
+        if DEBUGGING['kamikaze']:
+            log.debug(" - potential_kamikaze_angle: " + str(potential_kamikaze_angle))
+                
+        if potential_kamikaze_angle:
+            if DEBUGGING['kamikaze'] and DEBUGGING['offense']:
+                log.debug(" - going kamikaze")
+                    
+            navigate_command = current_ship.thrust(hlt.constants.MAX_SPEED, potential_kamikaze_angle)
+
+    if not navigate_command:
+        if DEBUGGING['offense']:
+            log.debug(" - engaging ship #" + str(closest_enemy.id))
+                    
+        navigate_command = current_ship.navigate(
+            current_ship.closest_point_to(closest_enemy),
+            game_map,
+            speed = default_speed,
+            ignore_ships = False)
+
+    return navigate_command
+
+def reinforce_planet(current_ship, our_planets_by_docked, our_ranked_untapped_planets):
+    """
+    Create navigation command to reinforce the nearest planet with an open docking spot
+    NOTE: This is currently not utilized, and almost certainly broken
+    :param Ship current_ship: derp
+    :param List our_planets_by_docked: List of Tuples
+    :param List our_ranked_untapped_planets: List of Tuples
+    :return String navigation_command:
+    :rtype: String
+    """
+    navigation_command = None
+
+    #reinforce that sucker
+    if DEBUGGING['reinforce']:
+        log.debug("Reinforcing planet #" + str(ranked_our_planets_by_docked[0]['entity_object'].id))
+
+    if current_ship.can_dock(ranked_our_planets_by_docked[0]['entity_object']):
+        if DEBUGGING['reinforce']:
+            log.debug(" - docking @ planet #" + str(ranked_our_planets_by_docked[0]['entity_object'].id))
+            
+        navigate_command = current_ship.dock(ranked_our_planets_by_docked[0]['entity_object'])
+    else:
+        if DEBUGGING['reinforce']:
+            log.debug(" - navigating to reinforce planet #" + str(ranked_untapped_planets[0]['entity_object']))
+               
+        navigate_command = current_ship.navigate(
+            current_ship.closest_point_to(ranked_untapped_planets[0]['entity_object']),
+            game_map,
+            speed = default_speed,
+            ignore_ships = False)
+
+    return navigation_command
+
+def undocked_actions(current_ship):
+    """
+    Determine what to do with the undocked ship
+    :param Ship current_ship:
+    :return: command to append to the command_queue
+    :rtype: List
+    """
+    if DEBUGGING['method_entry']:
+        log.debug("undocked_actions():")
+        
+    if DEBUGGING['ship_loop']:
+        log.debug("-+=Undocked ship #" + str(current_ship.id) + "=+-")
+                
+    #did we just complete undocking?
+    if current_ship in undock_process_list.keys():
+        if DEBUGGING['docking_procedures']:
+            log.debug(" - completed undocking")
 
-                    navigate_command = current_ship.dock(ranked_our_planets_by_docked[0]['entity_object'])
-                else:
-                    if DEBUGGING['reinforce']:
-                        log.debug(" - navigating to reinforce planet #" + str(ranked_untapped_planets[0]['entity_object']))
+        undock_process_list.remove(current_ship)
 
-                    navigate_command = current_ship.navigate(
-                        current_ship.closest_point_to(ranked_untapped_planets[0]['entity_object']),
-                        game_map,
-                        speed = default_speed,
-                        ignore_ships = False)
+    success = False
+    ranked_planets_by_distance = entity_sort_by_distance(current_ship, game_map.all_planets())
+    ranked_our_planets_by_docked = planet_sort_ours_by_docked(game_map.all_planets())
+    ranked_untapped_planets = remove_tapped_planets(ranked_planets_by_distance, planets_to_avoid)
+    enemies = get_enemy_ships()
+    
+    #get our command, if navigation to/docking with a planet is the best course of action
+    #else None
+    navigate_command = target_planet(current_ship, ranked_planets_by_distance, ranked_our_planets_by_docked, \
+                                     ranked_untapped_planets)
+
+    if not navigate_command:    
+        #potential_angle = other_entities_in_vicinity(current_ship, enemies, ranked_untapped_planets[0]['distance'])
+        if ALGORITHM['offense']: # and potential_angle:
+            navigate_command = go_offensive(current_ship, enemies)
+        elif ALGORITHM['reinforce'] and len(ranked_our_planets_by_docked) > 0:
+            navigate_command = reinforce_planet(current_ship, ranked_our_planets_by_docked, ranked_untapped_planets)
 
     return navigate_command
 
@@ -200,15 +260,41 @@ def other_entities_in_vicinity(current_entity, other_entities, scan_distance):
     :param Entity current_entity:
     :param List other_entities:
     :param integer scan_distance:
-    :return: Angle between this entity and the first other found within collision risk area, or None
-    :rtype: float
+    :return: Collision angle if any
+    :rtype: Collision angle or none
     """
     if DEBUGGING['method_entry']:
         log.debug("other_entities_in_vicinity()")
-        
+    
+    #closest_docked_distance = scan_distance
+    target_planet = None
+    
     for other_entity in other_entities:
-        if current_entity.calculate_distance_between(other_entity) <= scan_distance:
-            return current_entity.calculate_angle_between(other_entity)
+        #if other_entity.docking_status == current_entity.DockingStatus.DOCKED or \
+        #   other_entity.docking_status == current_entity.DockingStatus.DOCKING:
+        if current_entity.planet:
+            continue
+        
+        proximity = int(current_entity.calculate_distance_between(other_entity))
+        if DEBUGGING['kamikaze']:
+            log.debug("\t- current_entity's proximity: " + str(proximity) + " vs scan_distance: " + str(scan_distance))
+            
+        if proximity < scan_distance:
+            if DEBUGGING['kamikaze']:
+                log.debug("\t- proximity is less than scan_distance")
+            
+            if current_entity.docking_status == current_entity.DockingStatus.DOCKED or \
+               current_entity.docking_status == current_entity.DockingStatus.DOCKING:
+                if DEBUGGING['kamikaze']:
+                    log.debug("\t\t- setting target_planet to current_entity.planet")
+                    
+                target_planet = current_entity.planet
+                break
+            else:
+                continue
+                
+    if target_planet:
+        return current_entity.calculate_angle_between(target_planet)
 
     return None
 
@@ -268,17 +354,19 @@ def remove_tapped_planets(testing_planets, avoid_planets):
 #constants
 DEBUGGING = {
         'ship_loop': True,
-        'docking_procedures': True,
-        'reinforce': True,
+        'docking_procedures': False,
+        'reinforce': False,
         'offense': True,
+        'kamikaze': False,
         'planet_selection': True,
         'targeting': True,
-        'boobytrapping': True,
+        'boobytrapping': False,
         'method_entry': True
 }
 ALGORITHM = {
         'reinforce': False,
         'offense': True,
+        'kamikaze': False,
         'boobytrapping': True
 }
 
@@ -288,6 +376,7 @@ def remove_tapped_planets(testing_planets, avoid_planets):
 planets_to_avoid = []
 dock_process_list = {}
 undock_process_list = {}
+enemy_data = {}
 
 #init
 log = logging.getLogger(__name__)
@@ -321,6 +410,3 @@ def remove_tapped_planets(testing_planets, avoid_planets):
     #end per-ship iteration
 
     game.send_command_queue(command_queue)
-    
-
-

version.txt

@@ -0,0 +1 @@
+v2.0