Feat/render logic

include/game.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include "game/systems.h"

include/game/components.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "components/battle/battlestate.h"
+#include "components/bullethell/bullet.h"
+#include "components/bullethell/emitter.h"
+#include "components/bullethell/input.h"
+#include "components/bullethell/particle.h"
+#include "components/bullethell/pattern.h"
+#include "components/bullethell/pattern_bounce.h"
+#include "components/bullethell/pattern_homing.h"
+#include "components/bullethell/player.h"
+#include "components/bullethell/tag.h"
+#include "components/physics/acceleration.h"
+#include "components/physics/angular_velocity.h"
+#include "components/physics/circular_collider.h"
+#include "components/physics/position.h"
+#include "components/physics/rectangular_collider.h"
+#include "components/physics/rotation.h"
+#include "components/physics/scale.h"
+#include "components/physics/shaker.h"
+#include "components/physics/velocity.h"
+#include "components/render/animator.h"
+#include "components/render/camera.h"
+#include "components/render/intent_handle.h"
+#include "components/render/material.h"
+#include "components/render/rotation.h"
+#include "components/render/sprite.h"
+#include "components/render/text.h"
+#include "components/rhythm/holdactive.h"
+#include "components/rhythm/judgetext.h"
+#include "components/rhythm/keyinput.h"
+#include "components/rhythm/lane.h"
+#include "components/rhythm/notespeed.h"
+#include "components/rhythm/timing.h"
+#include "components/rhythm/timingend.h"
+
+#include "system/ecs.h"

include/game/components/battle/battlestate.h

@@ -0,0 +1,193 @@
+#pragma once
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace Game::Battle
+{
+
+    // intermediate structures
+    enum Instrument
+    {
+        NO_INSTRUMENT,
+    };
+
+    enum CurrentPhase
+    {
+        NO_PHASE,
+        BULLET_HELL,
+        RHYTHM
+    };
+
+    struct NoteData
+    {
+        bool is_hold;
+        int timing;
+        int timing_end;
+        NoteData() : is_hold(false), timing(0), timing_end(0)
+        {}
+        explicit NoteData(const bool is_hold, const int timing, const int timing_end) :
+            is_hold(is_hold), timing(timing), timing_end(timing_end)
+        {}
+    };
+
+    struct LaneInfo
+    {
+        std::vector<NoteData> notes;
+        int lane_number;
+        unsigned int current_note;
+        LaneInfo() : lane_number(0), current_note(0)
+        {}
+        explicit LaneInfo(const int lane_number) : lane_number(lane_number), current_note(0)
+        {}
+    };
+
+    struct Difficulty
+    {
+        Instrument instrument;
+        int difficulty;
+        Difficulty() : instrument(NO_INSTRUMENT), difficulty(0)
+        {}
+        explicit Difficulty(const Instrument instrument, const int difficulty) :
+            instrument(instrument), difficulty(difficulty)
+        {}
+    };
+
+    struct JudgementCount
+    {
+        int perfect_count;
+        int great_count;
+        int fine_count;
+        int miss_count;
+        JudgementCount() : perfect_count(0), great_count(0), fine_count(0), miss_count(0)
+        {}
+        explicit JudgementCount(
+                const int perfect_count, const int great_count, const int fine_count, const int miss_count) :
+            perfect_count(perfect_count), great_count(great_count), fine_count(fine_count), miss_count(miss_count)
+        {}
+    };
+
+    struct BpmInfo
+    {
+        struct InfoPair
+        {
+            int timing;
+            float bpm;
+        };
+        std::vector<InfoPair> bpm_list;
+        unsigned int idx;
+        BpmInfo() : idx(0)
+        {}
+        explicit BpmInfo(const unsigned int idx) : idx(idx)
+        {}
+    };
+
+    struct PhaseInfo
+    {
+        struct InfoPair
+        {
+            int timing;
+            CurrentPhase phase;
+        };
+        std::vector<InfoPair> phase_list;
+        unsigned int idx;
+        PhaseInfo() : idx(0)
+        {}
+        explicit PhaseInfo(const unsigned int idx) : idx(idx)
+        {}
+    };
+
+    // use these structures
+
+    struct BattleState
+    {
+        int max_hp;
+        int hp;
+        int score;
+        int clock_time;
+        int total_accept;
+        int current_accept;
+        int max_accept_gauge;
+        Difficulty difficulty;
+        JudgementCount judgement_count;
+        CurrentPhase current_phase;
+        BattleState() :
+            max_hp(0),
+            hp(0),
+            score(0),
+            clock_time(0),
+            total_accept(0),
+            current_accept(0),
+            max_accept_gauge(0),
+            current_phase(BULLET_HELL)
+        {}
+        explicit BattleState(const int max_hp, const int max_accept_gauge, const Difficulty difficulty) :
+            max_hp(max_hp),
+            hp(0),
+            score(0),
+            clock_time(0),
+            total_accept(0),
+            current_accept(0),
+            max_accept_gauge(max_accept_gauge),
+            difficulty(difficulty),
+            current_phase(BULLET_HELL)
+        {}
+    };
+
+    struct BulletHellState
+    {
+        int graze;
+        int iframe_time;
+        BulletHellState() : graze(0), iframe_time(0)
+        {}
+    };
+
+    struct RhythmState
+    {
+        int heal_hp;
+        int base_score;
+        int total_notes;
+        float note_speed;
+        RhythmState() : heal_hp(0), base_score(0), total_notes(0), note_speed(0)
+        {}
+        RhythmState(const int heal_hp, const int base_score, const int total_notes, const float note_speed) :
+            heal_hp(heal_hp), base_score(base_score), total_notes(total_notes), note_speed(note_speed)
+        {}
+    };
+
+    struct ChartData
+    {
+        LaneInfo lanes[4];
+    };
+
+    // TODO: Suchas's struct BulletPatternData
+
+    struct LevelData
+    {
+        std::string title;
+        std::string artist_name;
+        std::string genre_name;
+        float main_bpm;
+        BpmInfo bpm_info;
+        PhaseInfo phase_info;
+        std::vector<Difficulty> difficulties;
+        LevelData() : main_bpm(0)
+        {}
+        explicit LevelData(
+                std::string title,
+                std::string artist_name,
+                std::string genre_name,
+                const float main_bpm,
+                BpmInfo bpm_info,
+                PhaseInfo phase_info,
+                std::vector<Difficulty> difficulties) :
+            title(std::move(title)),
+            artist_name(std::move(artist_name)),
+            genre_name(std::move(genre_name)),
+            main_bpm(main_bpm),
+            bpm_info(std::move(bpm_info)),
+            phase_info(std::move(phase_info)),
+            difficulties(std::move(difficulties))
+        {}
+    };
+} // namespace Game::Battle

include/game/components/bullethell/bullet.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace Game::BulletHell
+{
+    struct Bullet
+    {
+        int telegraph_time;
+        bool is_active;
+        bool is_damageable;
+        int damage;
+        Bullet() : telegraph_time(0), is_active(true), is_damageable(false), damage(0)
+        {}
+        explicit Bullet(const int telegraph_time, const int damage) :
+            telegraph_time(telegraph_time), is_active(true), is_damageable(false), damage(damage)
+        {}
+    };
+} // namespace Game::BulletHell

include/game/components/bullethell/emitter.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include "particle.h"
+
+// TODO : Each of them should be inputted with prototype entity (prefab) + Single Bullet spawning is currently being
+// considered
+namespace Game::BulletHell
+{
+    struct BoomEmitter
+    {
+        Bullet particle;
+        float delay;
+        float scale;
+        float sustain_time;
+        explicit BoomEmitter(const Bullet particle, const float delay, const float scale, const float sustain_time) :
+            particle(particle), delay(delay), scale(scale), sustain_time(sustain_time)
+        {}
+    };
+
+    struct LaserEmitter
+    {
+        Bullet particle;
+        float delay;
+        float rotation;
+        float width;
+        float length;
+        float sustain_time;
+        float speed;
+        explicit LaserEmitter(
+                const Bullet particle,
+                const float delay,
+                const float rotation,
+                const float width,
+                const float length,
+                const float sustain_time,
+                const float speed) :
+            particle(particle),
+            delay(delay),
+            rotation(rotation),
+            width(width),
+            length(length),
+            sustain_time(sustain_time),
+            speed(speed)
+        {}
+    };
+
+    struct RingEmitter
+    {
+        Particle particle;
+        float delay;
+        float rotation;
+        float width;
+        float length;
+        float fire_delay;
+        int bullet_quantity;
+
+        int bullet_fired = 0;
+        explicit RingEmitter(
+                const Particle particle,
+                const float delay,
+                const float rotation,
+                const float width,
+                const float length,
+                const float fire_delay,
+                const int bullet_quantity) :
+            particle(particle),
+            delay(delay),
+            rotation(rotation),
+            width(width),
+            length(length),
+            fire_delay(fire_delay),
+            bullet_quantity(bullet_quantity)
+        {}
+    };
+
+    struct RandomEmitter
+    {
+        Particle particle;
+        float delay;
+        float angle_range;
+        float center_rotation;
+        float width;
+        float length;
+        float fire_delay;
+        int bullet_quantity;
+        explicit RandomEmitter(
+                const Particle particle,
+                const float delay,
+                const float angle_range,
+                const float center_rotation,
+                const float width,
+                const float length,
+                const float fire_delay,
+                const int bullet_quantity) :
+            particle(particle),
+            delay(delay),
+            angle_range(angle_range),
+            center_rotation(center_rotation),
+            width(width),
+            length(length),
+            fire_delay(fire_delay),
+            bullet_quantity(bullet_quantity)
+        {}
+    };
+
+    struct SpreadEmitter
+    {
+        Particle particle;
+        float delay;
+        float angle_range;
+        float center_rotation;
+        float width;
+        float length;
+        float fire_delay;
+        int bullet_quantity;
+
+        int bullet_fired = 0;
+        explicit SpreadEmitter(
+                const Particle particle,
+                const float delay,
+                const float angle_range,
+                const float center_rotation,
+                const float width,
+                const float length,
+                const float fire_delay,
+                const int bullet_quantity) :
+            particle(particle),
+            delay(delay),
+            angle_range(angle_range),
+            center_rotation(center_rotation),
+            width(width),
+            length(length),
+            fire_delay(fire_delay),
+            bullet_quantity(bullet_quantity)
+        {}
+    };
+} // namespace Game::BulletHell