feat: abilities

Author: shubham-1806

cpp/main.cpp

@@ -2,16 +2,18 @@
 
 std::ostringstream all_logs;
 
+//make global object for holding all ids of attackers whose abilities activated
+
 void init_constants() {
   // All the attacker types
   std::cin >> Constants::NO_OF_ATTACKER_TYPES;
 
   std::unordered_map<size_t, Attributes> attacker_type_to_attributes;
   for (size_t i = 1; i <= Constants::NO_OF_ATTACKER_TYPES; i++) {
-    unsigned hp, range, attack_power, speed, price, is_aerial , weight;
-    std::cin >> hp >> range >> attack_power >> speed >> price >> is_aerial >> weight;
+    unsigned hp, range, attack_power, speed, price, is_aerial , weight, num_ability_turns, ability_activation_cost;
+    std::cin >> hp >> range >> attack_power >> speed >> price >> is_aerial >> weight >> num_ability_turns >> ability_activation_cost;
     attacker_type_to_attributes.insert(
-        std::make_pair(i, Attributes(hp, range, attack_power, speed, price, is_aerial,weight)));
+        std::make_pair(i, Attributes(hp, range, attack_power, speed, price, is_aerial,weight, num_ability_turns,ability_activation_cost)));
   }
   Constants::ATTACKER_TYPE_ATTRIBUTES = attacker_type_to_attributes;
 
@@ -23,7 +25,7 @@ void init_constants() {
     unsigned hp, range, attack_power, speed, price, is_aerial;
     std::cin >> hp >> range >> attack_power >> speed >> price >> is_aerial;
     defender_type_to_attributes.insert(
-        std::make_pair(i, Attributes(hp, range, attack_power, speed, price, is_aerial,0)));
+        std::make_pair(i, Attributes(hp, range, attack_power, speed, price, is_aerial,0,0,0)));
   }
   Constants::DEFENDER_TYPE_ATTRIBUTES = defender_type_to_attributes;
 }
@@ -47,6 +49,7 @@ void output(size_t turn_no, Game &game) {
   // Game details logged
   const auto &spawn_positions = game.get_spawn_positions();
   const auto &player_set_targets = game.get_player_set_targets();
+  const auto &ability_activations = game.get_ability_activations();
 
   std::cout << spawn_positions.size() << std::endl;
   for (const auto &entry : spawn_positions) {
@@ -58,6 +61,11 @@ void output(size_t turn_no, Game &game) {
   for (const auto &entry : player_set_targets) {
     std::cout << entry.first << " " << entry.second << std::endl;
   }
+
+  std::cout << ability_activations.size() << std::endl;
+  for (const auto &attacker_id : ability_activations) {
+    std::cout << attacker_id << std::endl;
+  }
 }
 
 void dump_logs(State &state, Game &game) {}
@@ -71,9 +79,9 @@ State next_state(size_t cur_turn_no) {
   std::cin >> no_of_active_attackers;
   std::vector<Attacker> attackers;
   for (size_t i = 0; i < no_of_active_attackers; i++) {
-    size_t id, hp, x, y, type;
-    std::cin >> id >> x >> y >> type >> hp;
-    attackers.push_back(Attacker(id, hp, type, Position(x, y)));
+    size_t id, hp, x, y, type, is_ability_active;
+    std::cin >> id >> x >> y >> type >> hp >> is_ability_active;
+    attackers.push_back(Attacker(id, hp, type, Position(x, y), is_ability_active));
   }
 
   std::cin >> no_of_active_defenders;
@@ -97,17 +105,17 @@ PvPState pvp_next_state(size_t cur_turn_no) {
   std::cin >> no_of_active_attackers;
   std::vector<Attacker> attackers;
   for (size_t i = 0; i < no_of_active_attackers; i++) {
-    size_t id, hp, x, y, type;
-    std::cin >> id >> x >> y >> type >> hp;
-    attackers.push_back(Attacker(id, hp, type, Position(x, y)));
+    size_t id, hp, x, y, type, is_ability_active;
+    std::cin >> id >> x >> y >> type >> hp >> is_ability_active;
+    attackers.push_back(Attacker(id, hp, type, Position(x, y), is_ability_active));
   }
 
   std::cin >> no_of_opponent_attackers;
   std::vector<Attacker> opponent_attackers;
   for (size_t i = 0; i < no_of_opponent_attackers; i++) {
-    size_t id, hp, x, y, type;
-    std::cin >> id >> x >> y >> type >> hp;
-    opponent_attackers.push_back(Attacker(id, hp, type, Position(x, y)));
+    size_t id, hp, x, y, type, is_ability_active;
+    std::cin >> id >> x >> y >> type >> hp >> is_ability_active;
+    opponent_attackers.push_back(Attacker(id, hp, type, Position(x, y), is_ability_active));
   }
 
   return {move(attackers), move(opponent_attackers), Constants::PVP_FIXED_COINS, cur_turn_no + 1};

cpp/player_code.cpp

@@ -10,9 +10,9 @@
 #include <vector>
 
 Attributes::Attributes(unsigned hp, unsigned range, unsigned attack_power,
-                       unsigned speed, unsigned price, unsigned is_aerial, unsigned weight)
+                       unsigned speed, unsigned price, unsigned is_aerial, unsigned weight, unsigned num_ability_turns, unsigned ability_activation_cost)
     : hp(hp), range(range), attack_power(attack_power), speed(speed),
-      price(price), is_aerial(is_aerial), weight(weight) {}
+      price(price), is_aerial(is_aerial), weight(weight), num_ability_turns(num_ability_turns), ability_activation_cost(ability_activation_cost) {}
 
 Position::Position(int x, int y) : _x(x), _y(y) {}
 
@@ -73,8 +73,8 @@ size_t Actor::get_hp() const { return _hp; }
 size_t Actor::get_type() const { return _type; }
 Position Actor::get_position() const { return _position; }
 
-Attacker::Attacker(size_t id, size_t hp, size_t type, Position pos)
-    : Actor(id, hp, type, pos) {}
+Attacker::Attacker(size_t id, size_t hp, size_t type, Position pos, size_t is_ability_active)
+    : Actor(id, hp, type, pos), is_ability_active(is_ability_active) {}
 
 Defender::Defender(size_t id, size_t hp, size_t type, Position pos)
     : Actor(id, hp, type, pos) {}
@@ -128,6 +128,10 @@ void Game::set_target(const Attacker &attacker, const Attacker &opponent) {
   this->_player_set_targets.insert({attacker.get_id(), opponent.get_id()});
 }
 
+void Game::activate_ability(size_t attacker_id) {
+  this->_ability_activations.push_back(attacker_id);
+}
+
 std::ostringstream &Game::logr() { return this->_logr; }
 
 const std::unordered_map<size_t, size_t> &Game::get_player_set_targets() const {
@@ -141,6 +145,10 @@ const std::set<Position> &Game::get_already_spawned_positions() const {
   return this->_already_spawned_positions;
 }
 
+const std::vector<size_t> &Game::get_ability_activations() const {
+  return this->_ability_activations;
+}
+
 Map::Map(std::vector<std::vector<int>> map_as_grid)
     : _grid(move(map_as_grid)) {}
 

cpp/player_code.h

@@ -15,8 +15,10 @@ struct Attributes {
   const unsigned price;
   const unsigned is_aerial;
   const unsigned weight;
+  const unsigned num_ability_turns;
+  const unsigned ability_activation_cost;
   Attributes(unsigned hp, unsigned range, unsigned attack_power, unsigned speed,
-             unsigned price, unsigned is_aerial, unsigned weight);
+             unsigned price, unsigned is_aerial, unsigned weight, unsigned num_ability_turns, unsigned ability_activation_cost);
 };
 
 struct Constants {
@@ -71,7 +73,8 @@ class Actor {
 
 class Attacker : public Actor {
 public:
-  Attacker(size_t id, size_t hp, size_t type, Position pos);
+  Attacker(size_t id, size_t hp, size_t type, Position pos, size_t is_ability_active);
+  size_t is_ability_active;
 };
 
 class Defender : public Actor {
@@ -119,16 +122,19 @@ class Game {
   void set_target(size_t attacker_id, size_t defender_id);
   void set_target(const Attacker &attacker, const Defender &defender);
   void set_target(const Attacker &attacker, const Attacker &opponent);
+  void activate_ability(size_t attacker_id);
   std::ostringstream &logr();
 
   const std::unordered_map<size_t, size_t> &get_player_set_targets() const;
   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;
 private:
   std::unordered_map<size_t, size_t> _player_set_targets;
   std::vector<std::pair<size_t, Position>> _spawn_postions;
   std::set<Position> _already_spawned_positions;
-  
+  std::vector<size_t> _ability_activations;
+
   std::ostringstream _logr;
 };
 

cpp/run

@@ -1,5 +1,7 @@
 public class Attacker extends Actor {
-    public Attacker(int id, int hp, int type, Position pos) {
+    public final int is_ability_active;
+    public Attacker(int id, int hp, int type, Position pos, int is_ability_active) {
         super(id, hp, type, pos);
+        this.is_ability_active = is_ability_active;
     }
 }

java/Attacker.java

@@ -6,14 +6,18 @@ public class Attributes {
     public final int price;
     public final int is_aerial;
     public final int weight;
+    public final int num_ability_turns;
+    public final int ability_activation_cost;
 
-    public Attributes(int hp, int range, int attackPower, int speed, int price, int is_aerial, int weight) {
+    public Attributes(int hp, int range, int attackPower, int speed, int price, int is_aerial, int weight, int num_ability_turns, int ability_activation_cost) {
         this.hp = hp;
         this.range = range;
         this.attackPower = attackPower;
         this.speed = speed;
         this.price = price;
         this.is_aerial = is_aerial;
         this.weight = weight;
+        this.num_ability_turns = num_ability_turns;
+        this.ability_activation_cost = ability_activation_cost;
     }
 }

java/Attributes.java

@@ -10,19 +10,25 @@ public class Game {
     private final List<SpawnDetail> _spawnPositions;
     private final Set<Position> _alreadySpawnedPositions;
     private final StringBuilder _logr;
+    private final List<Integer> _ability_activations;
 
     public Game() {
         _playerSetTargets = new HashMap<>();
         _spawnPositions = new ArrayList<>();
         _alreadySpawnedPositions = new HashSet<>();
         _logr = new StringBuilder();
+        _ability_activations = new ArrayList<>();
     }
 
     public void spawnAttacker(int id, Position pos) {
         _spawnPositions.add(new SpawnDetail(id, pos));
         _alreadySpawnedPositions.add(pos);
     }
 
+    public void activateAbility(int attacker_id) {
+        _ability_activations.add(attacker_id);
+    }
+
     public List<SpawnDetail> getSpawnPositions() {
         return _spawnPositions;
     }
@@ -31,6 +37,10 @@ public Map<Integer, Integer> getPlayerSetTargets() {
         return _playerSetTargets;
     }
 
+    public List<Integer> getAbilityActivations() {
+        return _ability_activations;
+    }
+
     public boolean alreadySpawnedAtPosition(Position pos) {
         return _alreadySpawnedPositions.contains(pos);
     }

java/Game.java

@@ -32,7 +32,7 @@ private static State nextState(int currentTurnNo) {
         List<Attacker> attackers = new ArrayList<>();
         for (int i = 0; i < noOfActiveAttackers; i++) {
             attackers.add(
-                    new Attacker(in.nextInt(), in.nextInt(), in.nextInt(), new Position(in.nextInt(), in.nextInt())));
+                    new Attacker(in.nextInt(), in.nextInt(), in.nextInt(), new Position(in.nextInt(), in.nextInt()), in.nextInt()));
         }
 
         int noOfActiveDefenders = in.nextInt();
@@ -52,14 +52,14 @@ private static PvPState nextPvPState(int currentTurnNo) {
         List<Attacker> attackers = new ArrayList<>();
         for (int i = 0; i < noOfActiveAttackers; i++) {
             attackers.add(
-                    new Attacker(in.nextInt(), in.nextInt(), in.nextInt(), new Position(in.nextInt(), in.nextInt())));
+                    new Attacker(in.nextInt(), in.nextInt(), in.nextInt(), new Position(in.nextInt(), in.nextInt()), in.nextInt()));
         }
 
         int noOfActiveOpponentAttackers = in.nextInt();
         List<Attacker> opponentAttackers = new ArrayList<>();
         for (int i = 0; i < noOfActiveOpponentAttackers; i++) {
             opponentAttackers.add(
-                    new Attacker(in.nextInt(), in.nextInt(), in.nextInt(), new Position(in.nextInt(), in.nextInt())));
+                    new Attacker(in.nextInt(), in.nextInt(), in.nextInt(), new Position(in.nextInt(), in.nextInt()),in.nextInt()));
         }
 
         return new PvPState(attackers, opponentAttackers, Constants.PVP_FIXED_COINS, currentTurnNo + 1);
@@ -90,6 +90,7 @@ private static void output(int turnNo, Game game) {
         }
 
         List<SpawnDetail> spawnPositions = game.getSpawnPositions();
+        List<Integer> abilityActivations = game.getAbilityActivations();
 
         System.out.println(spawnPositions.size());
         for (SpawnDetail entry : spawnPositions) {
@@ -101,6 +102,11 @@ private static void output(int turnNo, Game game) {
         for (Map.Entry<Integer, Integer> entry : playerSetTargets.entrySet()) {
             System.out.println(entry.getKey() + " " + entry.getValue());
         }
+
+        System.out.println(abilityActivations.size());
+        for (Integer attacker_id : abilityActivations) {
+            System.out.println(attacker_id);
+        }
     }
 
     public static void main(String[] args) {
@@ -123,14 +129,14 @@ public static void main(String[] args) {
         Constants.ATTACKER_TYPE_ATTRIBUTES = new HashMap<Integer, Attributes>();
         for (int i = 1; i <= Constants.NO_OF_ATTACKER_TYPES; i++) {
             Constants.ATTACKER_TYPE_ATTRIBUTES.put(i,
-                    new Attributes(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt()));
+                    new Attributes(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt()));
         }
 
         Constants.NO_OF_DEFENDER_TYPES = in.nextInt();
         Constants.DEFENDER_TYPE_ATTRIBUTES = new HashMap<Integer, Attributes>();
         for (int i = 1; i <= Constants.NO_OF_DEFENDER_TYPES; i++) {
             Constants.DEFENDER_TYPE_ATTRIBUTES.put(i,
-                    new Attributes(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(),0));
+                    new Attributes(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(),0,0,0));
         }
 
         switch (gameType) {

java/Main.java

@@ -29,17 +29,20 @@ def output(turn_no: int, game: Game):
     sys.stdout.write(f"{len(game.player_set_targets)}\n")
     for (attacker_id, defender_id) in game.player_set_targets.items():
         sys.stdout.write(f"{attacker_id} {defender_id}\n")
-
+    
+    sys.stdout.write(f"{len(game.ability_activations)}\n")
+    for attacker_id in game.ability_activations:
+        sys.stdout.write(f"{attacker_id}\n")
 
 
 def next_state(cur_turn_no: int) -> State:
     no_of_active_attackers = int(sys.stdin.readline())
     attackers = []
 
     for _ in range(no_of_active_attackers):
-        id, x, y, a_type, hp = map(int, sys.stdin.readline().split())
+        id, x, y, a_type, hp, is_ability_active = map(int, sys.stdin.readline().split())
         attackers.append(
-            Attacker(id, hp, Constants.ATTACKER_TYPE_ATTRIBUTES[a_type], Position(x, y))
+            Attacker(id, hp, Constants.ATTACKER_TYPE_ATTRIBUTES[a_type], Position(x, y), is_ability_active)
         )
 
     no_of_active_defenders = int(sys.stdin.readline())
@@ -60,18 +63,18 @@ def next_pvp_state(cur_turn_no: int) -> PvPState:
     attackers = []
 
     for _ in range(no_of_active_attackers):
-        id, x, y, a_type, hp = map(int, sys.stdin.readline().split())
+        id, x, y, a_type, hp, is_ability_active = map(int, sys.stdin.readline().split())
         attackers.append(
-            Attacker(id, hp, Constants.ATTACKER_TYPE_ATTRIBUTES[a_type], Position(x, y))
+            Attacker(id, hp, Constants.ATTACKER_TYPE_ATTRIBUTES[a_type], Position(x, y), is_ability_active)
         )
 
     no_of_opponent_attackers = int(sys.stdin.readline())
     opponent_attackers = []
 
     for _ in range(no_of_opponent_attackers):
-        id, x, y, d_type, hp = map(int, sys.stdin.readline().split())
+        id, x, y, d_type, hp, is_ability_active = map(int, sys.stdin.readline().split())
         opponent_attackers.append(
-            Attacker(id, hp, Constants.DEFENDER_TYPE_ATTRIBUTES[d_type], Position(x, y))
+            Attacker(id, hp, Constants.DEFENDER_TYPE_ATTRIBUTES[d_type], Position(x, y), is_ability_active)
         )
 
     return PvPState(attackers, opponent_attackers, Constants.PVP_FIXED_COINS, cur_turn_no + 1)

python/main.py

@@ -29,6 +29,8 @@ class ActorType:
 class AttackerType(ActorType):
     speed: int
     weight: int
+    num_ability_turns: int
+    ability_activation_cost: int
 
 
 @dataclass(frozen=True)
@@ -42,6 +44,7 @@ class Attacker:
     hp: int
     type: AttackerType
     position: Position
+    is_ability_active: int
 
 
 @dataclass(frozen=True)
@@ -72,6 +75,7 @@ def __init__(self):
         self.player_set_targets: dict[int, int] = {}
         self.spawn_positions: list[tuple[int, Position]] = []
         self.already_spawned_positions: set[Position] = set()
+        self.ability_activations: list[int] = []
 
     def spawn_attacker(self, id: int, position: Position):
         self.spawn_positions.append((id, position))
@@ -85,6 +89,10 @@ def set_target(self, attacker_id: int, defender_id: int):
         assert (type(defender_id)== int)
         self.player_set_targets[attacker_id] = defender_id
 
+    def activate_ability(self, attacker_id: int):
+        assert (type(attacker_id)== int)
+        self.ability_activations.append(attacker_id)
+
     def log(self, line: str):
         self._log += line + "\n"
 
@@ -117,9 +125,9 @@ def initialize(cls,game_type:GameType):
         cls.NO_OF_ATTACKER_TYPES = int(input())
         cls.ATTACKER_TYPE_ATTRIBUTES = {}
         for i in range(1, cls.NO_OF_ATTACKER_TYPES + 1):
-            hp, a_range, attack_power, speed, price, is_aerial, weight = map(int, input().split())
+            hp, a_range, attack_power, speed, price, is_aerial, weight, num_ability_turns, ability_activation_cost = map(int, input().split())
             cls.ATTACKER_TYPE_ATTRIBUTES[i] = AttackerType(
-                hp, a_range, attack_power, price, is_aerial, speed, weight
+                hp, a_range, attack_power, price, is_aerial, speed, weight, num_ability_turns, ability_activation_cost
             )
 
         cls.NO_OF_DEFENDER_TYPES = int(input())