merg

.gitignore

@@ -0,0 +1,74 @@
+2huwu
+
+### C ###
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+### CMake ###
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+
+### CMake Patch ###
+# External projects
+*-prefix/
+
+# End of https://www.toptal.com/developers/gitignore/api/c,cmake

src/draw.cpp

@@ -1,6 +1,5 @@
 
-
-#include <raylib.h>
+#include "raylib-cpp.hpp"
 #include "game.h"
 #include "draw.h"
 #include <raylib-cpp.hpp>
@@ -50,6 +49,13 @@ draw_scores(struct game_state &gs)
 
 }
 
+void
+draw_pattern(struct pattern& pat) {
+    for (auto& b : pat.bullets) {
+        DrawCircle(b.position.x, b.position.y, 5, BLACK);
+    }
+}
+
 void 
 draw(struct game_state &gs) 
 {
@@ -69,6 +75,10 @@ draw(struct game_state &gs)
 
         EndBlendMode();
         EndMode3D();
+        for (auto& pat : gs.patterns) {
+            draw_pattern(pat.second);
+        }
+
         EndDrawing();
 
 }

src/game.cpp

@@ -2,8 +2,45 @@
 #include "game.h"
 #include "Material.hpp"
 #include <raylib-cpp.hpp>
-#include <glm/glm.hpp>
 #include <raylib.h>
+#include <assert.h>
+
+
+
+void fire_pattern(struct game_state &gs, pattern_type type, int player) {
+    std::vector<bullet> bs {};
+    std::vector<raylib::Vector3> datas {};
+    switch (type) {
+        case RAY:
+            int rays = 8;
+
+            for (int i = 0; i < rays; i++) {
+                raylib::Vector2 dir = (Vector2) {1.0f, 0.0f};
+                dir = dir.Rotate(i * 360.0 / rays);
+
+                struct player& p = gs.players.at(player);
+                bs.push_back({true, player, p.pos});
+
+                raylib::Vector3 data = (Vector3) {dir.x, dir.y, 0.0f};
+                datas.push_back(data);
+            }
+            break;
+    }
+
+    int id = gs.nextPattern ++;
+    pattern pat = {0, bs, datas, type};
+    gs.patterns[id] = pat;
+}
+
+
+Vector3 step_bullet(pattern_type type, bullet bullet, raylib::Vector3 data) {
+    switch (type) {
+        case RAY:
+            return bullet.position + data * 3.0f;
+    }
+    assert(false);
+}
+
 
 void load_assets (struct game_state &gs) {
 
@@ -35,8 +72,52 @@ void update_camera(struct game_state &gs) {
 void step(struct game_state &gs) {
 
     update_camera(gs);
-    //process_events(gs);
+    while (!gs.events.empty()) {
+        auto e = gs.events.front();
+        gs.events.pop_front();
 
+        int t = e.type;
+        if (t < 1000) { // keyboard event
+            struct player& p = gs.players.at(e.player);
+
+            switch (t) {
+                case KEY_RIGHT: p.vel.x += p.accel.x; break;
+                case KEY_LEFT: p.vel.x -= p.accel.x; break;
+                case KEY_DOWN: p.vel.y -= p.accel.y; break;
+                case KEY_UP: p.vel.y += p.accel.y; break;
+            }
+        } else if (1000 <=  t && t < 1100)  { // fire pattern
+            assert(t == 1000);
+
+            fire_pattern(gs, (pattern_type)(t-1000), e.player);
+
+        }
+
+
+    }
+
+    for (auto& p : gs.players) {
+        p.vel *= DECELERATION;
+        p.pos += p.vel;
+    }
+
+    for (auto it = gs.patterns.begin(); it != gs.patterns.end();) { 
+
+        auto& pat = (*it).second;
+        for (int i = 0; i < pat.bullets.size(); i++) {
+            auto& b = pat.bullets.at(i);
+            auto& d = pat.datas.at(i);
+            b.position = step_bullet(pat.type, b, d);
+        }
+
+        pat.age++;
+
+        if (pat.age >= MAX_PATTERN_AGE) {
+            it = gs.patterns.erase(it);
+        } else {
+            it++;
+        }
+    }
 
 }
 

src/game.h

@@ -1,15 +1,24 @@
-
 #pragma once
 
 #include <string>
 #include <unordered_map>
 #include <raylib.h>
+#include "raylib-cpp.hpp"
 #include <vector> 
 #include <deque>
+#include <unordered_map>
 
+const int SCREEN_WIDTH = 800;
+const int SCREEN_HEIGHT = 450;
+// decel as a scalar multiple applied on each tick.
+const float DECELERATION = 0.99f;
+
+const int MAX_PATTERN_AGE = 120;
+    
 enum IOEV_Type { /* KeyboardKey */
-        /* everything must be > 1000 so as to not conflict with key.  */
-        KEY = 1000,
+    /* everything must be > 1000 so as to not conflict with key.  */
+    FIRE_PATTERN = 1000, // 1000 to 1099 (inclusive)
+
 };
 
 struct IOEVENT {
@@ -18,17 +27,26 @@ struct IOEVENT {
 };
 
 struct player {
-    Vector3 pos;
+    raylib::Vector3 pos;
+    raylib::Vector3 vel;
+    raylib::Vector3 accel;
+
+    player() {
+        pos = (raylib::Vector3) {SCREEN_WIDTH/2.0f,SCREEN_HEIGHT/2.0f,0.0f};
+        vel =(raylib::Vector3) {0.0f, 0.0f, 0.0f};
+        accel =(raylib::Vector3) {1.0f, 1.0f, 1.0f};
+        accel *= 1.7f;
+    }
 };
 
 enum pattern_type {
-    NONE
+    RAY
 };
 
 struct bullet {
-    unsigned int tick;
-    unsigned int tick_started;
-    enum pattern_type pattern;
+    bool active;
+    int player;
+    raylib::Vector3 position;
 };
 
 enum camera_target {
@@ -50,9 +68,20 @@ struct map {
     Vector2 map_size;
 };
 
+// a pattern is a manager for bullets following the same pattern.
+struct pattern {
+    int age;
+    std::vector<bullet> bullets;
+    std::vector<raylib::Vector3> datas;
+
+    pattern_type type;
+};
+
+
 struct game_state {
+    int nextPattern;
     std::vector<player> players;
-    std::vector<bullet> bullets;
+    std::unordered_map<int, pattern> patterns;
     std::deque<IOEVENT> events;
 
     Camera3D camera = {0};
@@ -81,3 +110,5 @@ struct game_state {
 void step(struct game_state &gs);
 void load_assets (struct game_state &gs);
 
+
+Vector3 step_bullet(pattern_type type, bullet bullet, raylib::Vector3 data);

src/main.cpp

@@ -6,36 +6,29 @@
 
 int main(void)
 {
-
     struct game_state gs {};
-    gs.players.push_back({});
+    gs.players.push_back(player());
+    gs.players.push_back(player());
 
-    const int screenWidth = 800;
-    const int screenHeight = 450;
-    InitWindow(screenWidth, screenHeight, "2huwu");
+    InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "2huwu");
     load_assets(gs);
 
-    raylib::Vector3 ballPosition = { 0,0,200 };
-    raylib::Vector3 vel = { 0.0f, 0.0f, 0.0f };
-    raylib::Vector2 accel = { 1.0f, 1.0f };
-    accel *= 1.5f;
-    float decel = 0.85f;
-
     SetTargetFPS(60);
 
     while (!WindowShouldClose())
     {
-        if (IsKeyDown(KEY_RIGHT)) vel.x += accel.x;
-        if (IsKeyDown(KEY_LEFT))  vel.x -= accel.x;
-        if (IsKeyDown(KEY_UP))    vel.y -= accel.y;
-        if (IsKeyDown(KEY_DOWN))  vel.y += accel.y;
-
-	vel *= decel;
-
-	ballPosition += vel;
-
-        gs.players[0].pos.x = ballPosition.x;
-        gs.players[0].pos.y = ballPosition.y;
+        int player = 0;
+        if (IsKeyDown(KEY_RIGHT)) gs.events.push_back({player, (IOEV_Type)KEY_RIGHT});
+        if (IsKeyDown(KEY_LEFT))  gs.events.push_back({player, (IOEV_Type)KEY_LEFT});
+        if (IsKeyDown(KEY_UP))    gs.events.push_back({player, (IOEV_Type)KEY_UP});
+        if (IsKeyDown(KEY_DOWN))  gs.events.push_back({player, (IOEV_Type)KEY_DOWN});
+        if (IsKeyDown(KEY_SPACE))  gs.events.push_back({player, FIRE_PATTERN});
+
+        player = 1;
+        if (IsKeyDown(KEY_D))  gs.events.push_back({player, (IOEV_Type)KEY_RIGHT});
+        if (IsKeyDown(KEY_A))  gs.events.push_back({player, (IOEV_Type)KEY_LEFT});
+        if (IsKeyDown(KEY_W))  gs.events.push_back({player, (IOEV_Type)KEY_UP});
+        if (IsKeyDown(KEY_S))  gs.events.push_back({player, (IOEV_Type)KEY_DOWN});
 
         step(gs);
         draw(gs);