fix: helper fn for abilities

Author: shubham-1806

.vscode/c_cpp_properties.json

@@ -0,0 +1,20 @@
+{
+    "configurations": [
+      {
+        "name": "Linux-GCC",
+        "includePath": ["${workspaceFolder}/**"],
+        "defines": [],
+        "compilerPath": "/usr/bin/g++",
+        "cStandard": "c17",
+        "cppStandard": "c++20",
+        "intelliSenseMode": "gcc-x64",
+        "browse": {
+          "path": ["${workspaceFolder}"],
+          "limitSymbolsToIncludedHeaders": true,
+          "databaseFilename": ""
+        }
+      }
+    ],
+    "version": 4
+  }
+  

cpp/player_code.cpp

@@ -130,6 +130,7 @@ void Game::set_target(const Attacker &attacker, const Attacker &opponent) {
 
 void Game::activate_ability(size_t attacker_id) {
   this->_ability_activations.push_back(attacker_id);
+  this-> already_activated_attacker_ids.insert(attacker_id);
 }
 
 std::ostringstream &Game::logr() { return this->_logr; }

cpp/player_code.h

@@ -129,6 +129,7 @@ class Game {
   const std::vector<std::pair<size_t, Position>> &get_spawn_positions() const;
   const std::set<Position> &get_already_spawned_positions() const;
   const std::vector<size_t> &get_ability_activations() const;
+  static std::set<size_t> already_activated_attacker_ids;
 private:
   std::unordered_map<size_t, size_t> _player_set_targets;
   std::vector<std::pair<size_t, Position>> _spawn_postions;

cpp/run.cpp

@@ -85,6 +85,11 @@ Game run(const State &state) {
   if (!attackers.empty() && !defenders.empty()) {
     // check if they are empty beforehand to be safe from unexpected errors
     game.set_target(attackers.front(), defenders.front());
+    //lets say i want to activate the ability of the first attacker
+    //check if ability wasnt activated before to avoid getting penalized
+    if (!Game::already_activated_attacker_ids.contains(attackers.front().get_id())){
+      game.activate_ability(attackers.front().get_id());
+    }
   }
 
   // Lets log all the spawned positions for this turn

cpp/runpvp.cpp

@@ -14,7 +14,7 @@ Game run(const PvPState &state) {
 
   game.logr() << "TURN " << state.get_turn_no() << " LOGS:";
 
-  // Get all the attackers and defenders in the game and store it
+  // Get all the attackers and opponent in the game and store it
   const std::vector<Attacker> &attackers = state.get_attackers();
   const std::vector<Attacker> &opponent_attackers = state.get_opponent_attackers();
 
@@ -31,55 +31,60 @@ Game run(const PvPState &state) {
   // static variable in c++
 
   static int last_spawned = 0;
-    for (size_t type_id = 1; type_id <= Constants::NO_OF_ATTACKER_TYPES;
-         type_id++) {
-      // Spawn the attacker of type_id at position
-      // all_valid_spawn_positions[last_spawned]
-
-      // There are two cases when you might be panalized
-      //    - Spawning at invalid position
-      //    - Spawning at position where you have already spawned one attacker
-      //    in the same turn
-      //
-      // We have provided helpers to check just that
-
-      // game class will keep track of all your spawned positions for you and
-      // provides a helper method called already_spawned_at_position(Position)
-      // to check if you already spawned in the position
-
-      // Mostly a good practice to check with these two helpers before spawning,
-      // to save up on accidental penalties
-      if (is_valid_spawn_position(all_valid_spawn_positions[last_spawned]) &&
-          !game.already_spawned_at_position(
-              all_valid_spawn_positions[last_spawned])) {
-        // If lets say you had run out of coins left, the game will just ignore
-        // the spawn
-        game.spawn_attacker(type_id, all_valid_spawn_positions[last_spawned]);
-
-        // This has the starting attributes for the attacker we are about to
-        // spawn
-        // For full information about the Attributes class refer the
-        // documentation
-        // This can be used for strategizing
-        Attributes attackers_attributes =
-            Constants::ATTACKER_TYPE_ATTRIBUTES.at(type_id);
-
-        // You can use the logger we provide to show log messages in the
-        // rendered game
-        game.logr() << "To to be spawned at Position("
-                    << all_valid_spawn_positions[last_spawned].get_x() << ","
-                    << all_valid_spawn_positions[last_spawned].get_y() << ")"
-                    << '\n';
-        (last_spawned += 1) %= all_valid_spawn_positions.size();
-      }
+  for (size_t type_id = 1; type_id <= Constants::NO_OF_ATTACKER_TYPES;
+        type_id++) {
+    // Spawn the attacker of type_id at position
+    // all_valid_spawn_positions[last_spawned]
+
+    // There are two cases when you might be panalized
+    //    - Spawning at invalid position
+    //    - Spawning at position where you have already spawned one attacker
+    //    in the same turn
+    //
+    // We have provided helpers to check just that
+
+    // game class will keep track of all your spawned positions for you and
+    // provides a helper method called already_spawned_at_position(Position)
+    // to check if you already spawned in the position
+
+    // Mostly a good practice to check with these two helpers before spawning,
+    // to save up on accidental penalties
+    if (is_valid_spawn_position(all_valid_spawn_positions[last_spawned]) &&
+        !game.already_spawned_at_position(
+            all_valid_spawn_positions[last_spawned])) {
+      // If lets say you had run out of coins left, the game will just ignore
+      // the spawn
+      game.spawn_attacker(type_id, all_valid_spawn_positions[last_spawned]);
+
+      // This has the starting attributes for the attacker we are about to
+      // spawn
+      // For full information about the Attributes class refer the
+      // documentation
+      // This can be used for strategizing
+      Attributes attackers_attributes =
+          Constants::ATTACKER_TYPE_ATTRIBUTES.at(type_id);
+
+      // You can use the logger we provide to show log messages in the
+      // rendered game
+      game.logr() << "To to be spawned at Position("
+                  << all_valid_spawn_positions[last_spawned].get_x() << ","
+                  << all_valid_spawn_positions[last_spawned].get_y() << ")"
+                  << '\n';
+      (last_spawned += 1) %= all_valid_spawn_positions.size();
     }
+  }
 
   // Now lets say you always want to set the target for the attackers[0] to
   // defenders[0]
   // To do that you do
   if (!attackers.empty() && !opponent_attackers.empty()) {
     // check if they are empty beforehand to be safe from unexpected errors
     game.set_target(attackers.front(), opponent_attackers.front());
+    //lets say i want to activate the ability of the first attacker
+    //check if ability wasnt activated before to avoid getting penalized
+    if (!Game::already_activated_attacker_ids.contains(attackers.front().get_id())){
+      game.activate_ability(attackers.front().get_id());
+    }
   }
 
   // Lets log all the spawned positions for this turn

java/Game.java

@@ -11,6 +11,7 @@ public class Game {
     private final Set<Position> _alreadySpawnedPositions;
     private final StringBuilder _logr;
     private final List<Integer> _ability_activations;
+    public static Set<Integer> already_activated_attacker_ids;
 
     public Game() {
         _playerSetTargets = new HashMap<>();
@@ -27,6 +28,7 @@ public void spawnAttacker(int id, Position pos) {
 
     public void activateAbility(int attacker_id) {
         _ability_activations.add(attacker_id);
+        already_activated_attacker_ids.add(attacker_id);
     }
 
     public List<SpawnDetail> getSpawnPositions() {
@@ -53,6 +55,10 @@ public void setTarget(Attacker attacker, Defender defender) {
         setTarget(attacker.getId(), defender.getId());
     }
 
+    public void setTarget(Attacker attacker, Attacker opponent_attacker) {
+        setTarget(attacker.getId(), opponent_attacker.getId());
+    }
+
     public void log(String s) {
         _logr.append(s + "\n");
     }

java/Run.java

@@ -95,6 +95,11 @@ public Game run(State state) {
         if (!attackers.isEmpty() && !defenders.isEmpty()) {
             // check if they are empty beforehand to be safe from unexpected errors
             game.setTarget(attackers.get(0).getId(), defenders.get(0).getId());
+             //lets say i want to activate the ability of the first attacker
+            //check if ability wasnt activated before to avoid getting penalized
+            if (!Game.already_activated_attacker_ids.contains(attackers.get(0).getId())) {
+                game.activateAbility(attackers.get(0).getId());
+            }
         }
 
         // Lets log all the spawned positions for this turn

java/RunPvP.java

@@ -28,7 +28,7 @@ public Game run(PvPState state) {
         int remainingCoins = state.getCoinsLeft();
         game.log("TURN " + state.getTurnNo() + " LOGS:");
 
-        // Get all the attackers and defenders in the game and store it
+        // Get all the attackers and opponent in the game and store it
         List<Attacker> attackers = state.getAttackers();
         List<Attacker> opponentAttackers = state.getOpponentAttackers();
 
@@ -91,6 +91,11 @@ public Game run(PvPState state) {
         if (!attackers.isEmpty() && !opponentAttackers.isEmpty()) {
             // check if they are empty beforehand to be safe from unexpected errors
             game.setTarget(attackers.get(0).getId(), opponentAttackers.get(0).getId());
+            //lets say i want to activate the ability of the first attacker
+            //check if ability wasnt activated before to avoid getting penalized
+            if (!Game.already_activated_attacker_ids.contains(attackers.get(0).getId())) {
+                game.activateAbility(attackers.get(0).getId());
+            }
         }
 
         // Lets log all the spawned positions for this turn

python/player_code.py

@@ -70,6 +70,7 @@ class PvPState:
     turn_no: int
 
 class Game:
+    already_activated_attacker_ids: set[int]
     def __init__(self):
         self._log = ""
         self.player_set_targets: dict[int, int] = {}
@@ -92,6 +93,7 @@ def set_target(self, attacker_id: int, defender_id: int):
     def activate_ability(self, attacker_id: int):
         assert (type(attacker_id)== int)
         self.ability_activations.append(attacker_id)
+        Game.already_activated_attacker_ids.add(attacker_id)
 
     def log(self, line: str):
         self._log += line + "\n"

python/run.py

@@ -89,9 +89,11 @@ def run(state: State) -> Game:
     #To do that you do
     if len(attackers)!=0 and len(defenders)!=0:
         game.set_target(attackers[0].id,defenders[0].id)
-        game.activate_ability(attackers[0].id)
-    
-        
+    #lets say i want to activate the ability of the first attacker
+    #check if ability wasnt activated before to avoid getting penalized
+        if attackers[0].id not in Game.already_activated_attacker_ids:
+            game.activate_ability(attackers[0].id)
+
     #Lets log all the spawned positions for this turn
     for type_id, pos in game.spawn_positions:
         game.log("Type {} at Position ({},{})".