sans the skeleton from undertale

src/battle_game/core/bullets/bullets.h

@@ -1,2 +1,4 @@
 #pragma once
 #include "battle_game/core/bullets/cannon_ball.h"
+#include "battle_game/core/bullets/skeleton_attack.h"
+#include "battle_game/core/bullets/piercing_bullet.h"

src/battle_game/core/bullets/piercing_bullet.cpp

@@ -0,0 +1,61 @@
+#include "battle_game/core/bullets/piercing_bullet.h"
+
+#include "battle_game/core/game_core.h"
+#include "battle_game/core/particles/particles.h"
+
+namespace battle_game::bullet {
+PiercingBullet::PiercingBullet(GameCore *core,
+                       uint32_t id,
+                       uint32_t unit_id,
+                       uint32_t player_id,
+                       glm::vec2 position,
+                       float rotation,
+                       float damage_scale,
+                       glm::vec2 velocity)
+    : Bullet(core, id, unit_id, player_id, position, rotation, damage_scale),
+      velocity_(velocity) {
+
+    touched.resize(game_core_->GetUnits().size());
+}
+
+void PiercingBullet::Render() {
+  SetTransformation(position_, rotation_, glm::vec2{0.1f});
+  SetColor(game_core_->GetPlayerColor(player_id_));
+  SetTexture(BATTLE_GAME_ASSETS_DIR "textures/particle1.png");
+  DrawModel(0);
+}
+
+void PiercingBullet::Update() {
+  position_ += velocity_ * kSecondPerTick;
+  bool should_die = false;
+  if (game_core_->IsBlockedByObstacles(position_)) {
+    should_die = true;
+  }
+
+  auto &units = game_core_->GetUnits();
+  int idx = 0;
+  for (auto &unit : units) {
+    if (unit.first == unit_id_) {
+      continue;
+    }
+    if (unit.second->IsHit(position_)) {
+      if (!touched[idx]) game_core_->PushEventDealDamage(unit.first, id_, damage_scale_ * 10.0f);
+      // should_die = true; // It doesn't disappear.
+      touched[idx] = 1;
+    } else touched[idx] = 0;
+    ++idx;
+  }
+
+  if (should_die) {
+    game_core_->PushEventRemoveBullet(id_);
+  }
+}
+
+PiercingBullet::~PiercingBullet() {
+  for (int i = 0; i < 5; i++) {
+    game_core_->PushEventGenerateParticle<particle::Smoke>(
+        position_, rotation_, game_core_->RandomInCircle() * 2.0f, 0.2f,
+        glm::vec4{0.0f, 0.0f, 0.0f, 1.0f}, 3.0f);
+  }
+}
+}  // namespace battle_game::bullet

src/battle_game/core/bullets/piercing_bullet.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "battle_game/core/bullet.h"
+
+namespace battle_game::bullet {
+class PiercingBullet : public Bullet {
+ public:
+  PiercingBullet(GameCore *core,
+             uint32_t id,
+             uint32_t unit_id,
+             uint32_t player_id,
+             glm::vec2 position,
+             float rotation,
+             float damage_scale,
+             glm::vec2 velocity);
+  ~PiercingBullet() override;
+  void Render() override;
+  void Update() override;
+
+ private:
+  std::vector<bool> touched;
+  glm::vec2 velocity_{};
+};
+}  // namespace battle_game::bullet

src/battle_game/core/bullets/skeleton_attack.cpp

@@ -0,0 +1,56 @@
+#include "battle_game/core/bullets/skeleton_attack.h"
+
+#include "battle_game/core/game_core.h"
+#include "battle_game/core/particles/particles.h"
+
+namespace battle_game::bullet {
+SkeletonAttack::SkeletonAttack(GameCore *core,
+                       uint32_t id,
+                       uint32_t unit_id,
+                       uint32_t player_id,
+                       glm::vec2 position,
+                       float rotation,
+                       float damage_scale,
+                       glm::vec2 velocity)
+    : Bullet(core, id, unit_id, player_id, position, rotation, damage_scale),
+      velocity_(velocity) {
+}
+
+void SkeletonAttack::Render() {
+  SetTransformation(position_, rotation_, glm::vec2{0.1f});
+  SetColor(game_core_->GetPlayerColor(player_id_));
+  SetTexture(BATTLE_GAME_ASSETS_DIR "textures/skeleton.png");
+  DrawModel(0);
+}
+
+void SkeletonAttack::Update() {
+  position_ += velocity_ * kSecondPerTick;
+  bool should_die = false;
+  if (game_core_->IsBlockedByObstacles(position_)) {
+    should_die = true;
+  }
+
+  auto &units = game_core_->GetUnits();
+  for (auto &unit : units) {
+    if (unit.first == unit_id_) {
+      continue;
+    }
+    if (unit.second->IsHit(position_)) {
+      game_core_->PushEventDealDamage(unit.first, id_, damage_scale_);
+      // should_die = true; // The Skeleton won't disappear.
+    }
+  }
+
+  if (should_die) {
+    game_core_->PushEventRemoveBullet(id_);
+  }
+}
+
+SkeletonAttack::~SkeletonAttack() {
+  for (int i = 0; i < 5; i++) {
+    game_core_->PushEventGenerateParticle<particle::Smoke>(
+        position_, rotation_, game_core_->RandomInCircle() * 2.0f, 0.2f,
+        glm::vec4{0.0f, 0.0f, 0.0f, 1.0f}, 3.0f);
+  }
+}
+}  // namespace battle_game::bullet

src/battle_game/core/bullets/skeleton_attack.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "battle_game/core/bullet.h"
+
+namespace battle_game::bullet {
+class SkeletonAttack : public Bullet {
+ public:
+  SkeletonAttack(GameCore *core,
+             uint32_t id,
+             uint32_t unit_id,
+             uint32_t player_id,
+             glm::vec2 position,
+             float rotation,
+             float damage_scale,
+             glm::vec2 velocity);
+  ~SkeletonAttack() override;
+  void Render() override;
+  void Update() override;
+
+ private:
+  glm::vec2 velocity_{};
+};
+}  // namespace battle_game::bullet

src/battle_game/core/selectable_units.cpp

@@ -22,6 +22,8 @@ void GameCore::GeneratePrimaryUnitList() {
    * TODO: Add Your Unit Here!
    * */
   ADD_SELECTABLE_UNIT(unit::Tank);
+  ADD_SELECTABLE_UNIT(unit::SansTheSkeleton);
+  ADD_SELECTABLE_UNIT(unit::PiercingBulletShooter)
 
   unit.reset();
 }

src/battle_game/core/units/piercing_bullet_shooter.cpp

@@ -0,0 +1,166 @@
+#include "piercing_bullet_shooter.h"
+
+#include "battle_game/core/bullets/bullets.h"
+#include "battle_game/core/game_core.h"
+#include "battle_game/graphics/graphics.h"
+
+namespace battle_game::unit {
+
+namespace {
+uint32_t tank_body_model_index = 0xffffffffu;
+uint32_t tank_turret_model_index = 0xffffffffu;
+}  // namespace
+
+PiercingBulletShooter::PiercingBulletShooter(GameCore *game_core, uint32_t id, uint32_t player_id)
+    : Unit(game_core, id, player_id) {
+  if (!~tank_body_model_index) {
+    auto mgr = AssetsManager::GetInstance();
+    {
+      /* Tank Body */
+      tank_body_model_index = mgr->RegisterModel(
+          {
+              {{-0.8f, 0.8f}, {0.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f}},
+              {{-0.8f, -1.0f}, {0.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f}},
+              {{0.8f, 0.8f}, {0.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f}},
+              {{0.8f, -1.0f}, {0.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f}},
+              // distinguish front and back
+              {{0.6f, 1.0f}, {0.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f}},
+              {{-0.6f, 1.0f}, {0.0f, 0.0f}, {1.0f, 1.0f, 1.0f, 1.0f}},
+          },
+          {0, 1, 2, 1, 2, 3, 0, 2, 5, 2, 4, 5});
+    }
+
+    {
+      /* Tank Turret */
+      std::vector<ObjectVertex> turret_vertices;
+      std::vector<uint32_t> turret_indices;
+      const int precision = 60;
+      const float inv_precision = 1.0f / float(precision);
+      for (int i = 0; i < precision; i++) {
+        auto theta = (float(i) + 0.5f) * inv_precision;
+        theta *= glm::pi<float>() * 2.0f;
+        auto sin_theta = std::sin(theta);
+        auto cos_theta = std::cos(theta);
+        turret_vertices.push_back({{sin_theta * 0.5f, cos_theta * 0.5f},
+                                   {0.0f, 0.0f},
+                                   {0.7f, 0.7f, 0.7f, 1.0f}});
+        turret_indices.push_back(i);
+        turret_indices.push_back((i + 1) % precision);
+        turret_indices.push_back(precision);
+      }
+      turret_vertices.push_back(
+          {{0.0f, 0.0f}, {0.0f, 0.0f}, {0.7f, 0.7f, 0.7f, 1.0f}});
+      turret_vertices.push_back(
+          {{-0.1f, 0.0f}, {0.0f, 0.0f}, {0.7f, 0.7f, 0.7f, 1.0f}});
+      turret_vertices.push_back(
+          {{0.1f, 0.0f}, {0.0f, 0.0f}, {0.7f, 0.7f, 0.7f, 1.0f}});
+      turret_vertices.push_back(
+          {{-0.1f, 1.2f}, {0.0f, 0.0f}, {0.7f, 0.7f, 0.7f, 1.0f}});
+      turret_vertices.push_back(
+          {{0.1f, 1.2f}, {0.0f, 0.0f}, {0.7f, 0.7f, 0.7f, 1.0f}});
+      turret_indices.push_back(precision + 1 + 0);
+      turret_indices.push_back(precision + 1 + 1);
+      turret_indices.push_back(precision + 1 + 2);
+      turret_indices.push_back(precision + 1 + 1);
+      turret_indices.push_back(precision + 1 + 2);
+      turret_indices.push_back(precision + 1 + 3);
+      tank_turret_model_index =
+          mgr->RegisterModel(turret_vertices, turret_indices);
+    }
+  }
+}
+
+void PiercingBulletShooter::Render() {
+  battle_game::SetTransformation(position_, rotation_);
+  battle_game::SetTexture(0);
+  battle_game::SetColor(game_core_->GetPlayerColor(player_id_));
+  battle_game::DrawModel(tank_body_model_index);
+  battle_game::SetRotation(turret_rotation_);
+  battle_game::DrawModel(tank_turret_model_index);
+}
+
+void PiercingBulletShooter::Update() {
+  TankMove(3.0f, glm::radians(180.0f));
+  TurretRotate();
+  Fire();
+}
+
+void PiercingBulletShooter::TankMove(float move_speed, float rotate_angular_speed) {
+  auto player = game_core_->GetPlayer(player_id_);
+  if (player) {
+    auto &input_data = player->GetInputData();
+    glm::vec2 offset{0.0f};
+    if (input_data.key_down[GLFW_KEY_W]) {
+      offset.y += 1.0f;
+    }
+    if (input_data.key_down[GLFW_KEY_S]) {
+      offset.y -= 1.0f;
+    }
+    float speed = move_speed * GetSpeedScale();
+    offset *= kSecondPerTick * speed;
+    auto new_position =
+        position_ + glm::vec2{glm::rotate(glm::mat4{1.0f}, rotation_,
+                                          glm::vec3{0.0f, 0.0f, 1.0f}) *
+                              glm::vec4{offset, 0.0f, 0.0f}};
+    if (!game_core_->IsBlockedByObstacles(new_position)) {
+      game_core_->PushEventMoveUnit(id_, new_position);
+    }
+    float rotation_offset = 0.0f;
+    if (input_data.key_down[GLFW_KEY_A]) {
+      rotation_offset += 1.0f;
+    }
+    if (input_data.key_down[GLFW_KEY_D]) {
+      rotation_offset -= 1.0f;
+    }
+    rotation_offset *= kSecondPerTick * rotate_angular_speed * GetSpeedScale();
+    game_core_->PushEventRotateUnit(id_, rotation_ + rotation_offset);
+  }
+}
+
+void PiercingBulletShooter::TurretRotate() {
+  auto player = game_core_->GetPlayer(player_id_);
+  if (player) {
+    auto &input_data = player->GetInputData();
+    auto diff = input_data.mouse_cursor_position - position_;
+    if (glm::length(diff) < 1e-4) {
+      turret_rotation_ = rotation_;
+    } else {
+      turret_rotation_ = std::atan2(diff.y, diff.x) - glm::radians(90.0f);
+    }
+  }
+}
+
+void PiercingBulletShooter::Fire() {
+  if (fire_count_down_ == 0) {
+    auto player = game_core_->GetPlayer(player_id_);
+    if (player) {
+      auto &input_data = player->GetInputData();
+      if (input_data.mouse_button_down[GLFW_MOUSE_BUTTON_LEFT]) {
+        auto velocity = Rotate(glm::vec2{0.0f, 20.0f}, turret_rotation_);
+        GenerateBullet<bullet::PiercingBullet>(
+            position_ + Rotate({0.0f, 1.2f}, turret_rotation_),
+            turret_rotation_, GetDamageScale(), velocity);
+        fire_count_down_ = kTickPerSecond;  // Fire interval 1 second.
+      }
+    }
+  }
+  if (fire_count_down_) {
+    fire_count_down_--;
+  }
+}
+
+bool PiercingBulletShooter::IsHit(glm::vec2 position) const {
+  position = WorldToLocal(position);
+  return position.x > -0.8f && position.x < 0.8f && position.y > -1.0f &&
+         position.y < 1.0f && position.x + position.y < 1.6f &&
+         position.y - position.x < 1.6f;
+}
+
+const char *PiercingBulletShooter::UnitName() const {
+  return "Piercing Bullet Shooter";
+}
+
+const char *PiercingBulletShooter::Author() const {
+  return "Minus Modulo";
+}
+}  // namespace battle_game::unit

src/battle_game/core/units/piercing_bullet_shooter.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "battle_game/core/unit.h"
+
+namespace battle_game::unit {
+class PiercingBulletShooter : public Unit {
+ public:
+  PiercingBulletShooter(GameCore *game_core, uint32_t id, uint32_t player_id);
+  void Render() override;
+  void Update() override;
+  [[nodiscard]] bool IsHit(glm::vec2 position) const override;
+
+ protected:
+  void TankMove(float move_speed, float rotate_angular_speed);
+  void TurretRotate();
+  void Fire();
+  [[nodiscard]] const char *UnitName() const override;
+  [[nodiscard]] const char *Author() const override;
+
+  float turret_rotation_{0.0f};
+  uint32_t fire_count_down_{0};
+  uint32_t mine_count_down_{0};
+};
+}  // namespace battle_game::unit