fix move_area computation

fall2022/fall2022.py

@@ -7,11 +7,16 @@ debug = True
 t0 = time.time()
 
 
+# Debugger : il y a des mouvements qui ne se font pas, faut tout vérifier
 # Faire des zones à l'intérieur des contigs, pour attirer le mouvement vers les zones à coloniser
 # Limiter les constructions agressives en fonction de ces zones
 # penser les recycleurs comme des obstacles!
-# Prendre en compte la menace d'un déplacement ennemi avant de spawn, parce que s'il joue en premier et qu'il occupe
-#    la case prévue, le spawn est annulé. Il faut gérer ça en fonction de l'amount
+# Identifier le moment où la situation est "verrouillée" (plus d'accès entre alliés et ennemis)
+#     et cesser les construction de recycleurs
+# Limiter la consommation de ressources des mouvements
+# si la tension autour d'une case est trop forte et que cette case est un "noeud" question passage,
+#     ne pas bouger et défendre!
+
 
 def log(*msg):
     if debug:
@@ -427,6 +432,7 @@ class Grid(BaseClass):
                 continue
 
             contig = Contig(c.pos)
+
             candidates = self.neighbors(*c.pos)
 
             while candidates:
@@ -568,20 +574,18 @@ class Grid(BaseClass):
         build_actions = Queue()
 
         # List available build actions
-        k0 = 100000
+        k0 = 80000
         kmax_build = 70000
-        k_map_size = -50
-        k_on_site_amount = -2400
-        k_available_amount = -800
+        k_available_amount = -1000
         k_already_exploited = 30000
-        k_area_unit = 1000
+        k_area_unit = 500
         k_area_owned = 1000
         k_area_neutral = 0
-        k_area_opponents = -3000
+        k_area_opponents = -4000
         k_area_opponent_unit = -1000
-        k_recyclers_owned = 4000
-        k_space_around = -500
-        k_aggressive_build = 10000
+        k_recyclers_owned = 5000
+        k_space_around = -1000
+        k_aggressive_build = 8000
         k_aggressive_build_for_defense = -6000
         k_aggressive_build_tension = -1000
         k_first_rounds = 5000  # on décourage le build lors des premiers rounds, il bloque l'avancée
@@ -599,13 +603,10 @@ class Grid(BaseClass):
                     continue
 
                 k = k0
-                k += k_map_size * len(self.cells)
 
                 if self.round <= 3:
                     k += (4 - self.round) * k_first_rounds
 
-                k += k_on_site_amount * self.cells[p].amount
-
                 area = [place.pos] + self.neighbors(*place.pos)
                 destination = Build.SUPPORT if not any(self.cells[p].is_opponents for p in area) else Build.AGGRESSIVE
                 k0_already_exploited = 0
@@ -711,7 +712,7 @@ class Grid(BaseClass):
                     k += k_reinforcement
 
         # log('---')
-        # for action in sorted(build_actions.values(), key=lambda x: x.priority)[:10]:
+        # for action in sorted([a for a in build_actions.values() if type(a) is Spawn], key=lambda x: x.priority)[:10]:
         #     log(action)
 
         if not build_actions:
@@ -751,11 +752,11 @@ class Grid(BaseClass):
         move_actions = []
 
         k0_position = 60000
-        k_position_distance = 2000
+        k_position_distance = 3000
         k_position_opponents = -5000
         k_position_destroy = -3000
         k_dist_to_enemy = 1000
-        k_colonize = -5000
+        k_colonize = -3000
         k_expand = -800
         k_threat = -1500
         ki = 0  # little hack to avoid the while in queue.put
@@ -771,17 +772,14 @@ class Grid(BaseClass):
             # on ne conserve que les cases voisines ou limitrophes du territoire
             move_area = []
             for pos in contig.area:
-                owned_neighbor, not_owned_neighbor = False, False
-                for n in self.neighbors(*pos):
-                    owned = self.cells[n].owned
-                    if owned:
-                        owned_neighbor = True
-                    else:
-                        not_owned_neighbor = True
+                c = self.cells[pos]
+
+                if (c.owned and any(not self.cells[n].owned for n in self.neighbors(*pos))) or \
+                    (not c.owned and any(self.cells[n].owned for n in self.neighbors(*pos))):
+                    move_area.append(pos)
 
-                    if owned_neighbor and not_owned_neighbor:
-                        move_area.append(pos)
-                        break
+            if contig.start == (0, 0):
+                log(move_area)
 
             # list destinations
             for pos in move_area: