Refactoring game process

src/main/java/com/alterdekim/hearthhack/component/GamePool.java

@@ -45,7 +45,7 @@ public class GamePool {
         roomService.clear();
     }
 
-    public GameRoom getGameRoomById(Long id) {
+    public Optional<GameRoom> getGameRoomById(Long id) {
-        return games.get(id);
+        return Optional.ofNullable(games.get(id));
     }
 }

src/main/java/com/alterdekim/hearthhack/component/GameRoom.java

@@ -1,29 +1,129 @@
 package com.alterdekim.hearthhack.component;
 
+import com.alterdekim.hearthhack.component.interfaces.GamePacketCallback;
+import com.alterdekim.hearthhack.component.interfaces.IGameRoom;
 import com.alterdekim.hearthhack.dto.RoomPlayerDTO;
+import com.alterdekim.hearthhack.game.GameState;
+import com.alterdekim.hearthhack.game.IncomeGamePacket;
+import com.alterdekim.hearthhack.game.OutcomeGamePacket;
 import com.alterdekim.hearthhack.service.UserService;
-import lombok.AllArgsConstructor;
 import lombok.Getter;
-import lombok.ToString;
 import lombok.extern.slf4j.Slf4j;
 
 import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.stream.Collectors;
 
-@ToString
 @Slf4j
-public class GameRoom {
+public class GameRoom extends Thread implements IGameRoom {
     @Getter
     private final List<RoomPlayerDTO> players;
 
+    private final ConcurrentHashMap<Long, GamePacketCallback> callbacks;
+
     private final UserService userService;
 
     @Getter
     private final String password;
 
+    private GameState globalState;
+
+    @Getter
+    private ConcurrentLinkedQueue<IncomeGamePacket> incomeQueue;
+    private ConcurrentLinkedQueue<OutcomeGamePacket> outcomeQueue;
+
     public GameRoom(List<RoomPlayerDTO> players, UserService userService, String password) {
         this.players = players;
         this.userService = userService;
         this.password = password;
-        log.info("New GameRoom!");
+        this.incomeQueue = new ConcurrentLinkedQueue<>();
+        this.outcomeQueue = new ConcurrentLinkedQueue<>();
+        this.callbacks = new ConcurrentHashMap<>();
+        this.globalState = GameState.CreateGame;
+        this.start();
+    }
+
+    private void processIncomePackets() {
+        if( this.incomeQueue.isEmpty() ) return;
+        IncomeGamePacket packet = this.incomeQueue.peek();
+        if( findPlayerById(packet.getPlayerId()).isEmpty() ) return;
+        processIncomePacket(packet);
+        this.incomeQueue.poll();
+    }
+
+    private void processOutcomePackets() {
+       /* if( this.outcomeQueue.isEmpty() ) return;
+        OutcomeGamePacket packet = this.outcomeQueue.peek();
+        this.outcomeQueue.poll();*/
+    }
+
+    private void processIncomePacket(IncomeGamePacket packet) {
+        if( packet.getPacket().getType() != 1) return;
+        List<OutcomeGamePacket> l = this.outcomeQueue.stream()
+                .filter(p -> p.getPlayerId().longValue() == packet.getPlayerId().longValue())
+                .collect(Collectors.toList());
+        GamePacketCallback callback = this.callbacks.get(packet.getPlayerId());
+        if (callback == null) return;
+        l.forEach(p -> callback.onMessage(p.getPacket()));
+    }
+
+    private void updateGameState() {
+        // giant switch
+        switch (this.globalState) {
+            case CreateGame -> createGameEntity();
+            case CreatePlayers -> createPlayerEntity();
+            case CreateDecks -> createDeckEntities();
+            case CreateHeroes -> createPlayerHeroEntity();
+            case CreateHeroPowers -> createPlayerHeroPowerEntity();
+        }
+    }
+
+    public void updateCallback(Long playerId, GamePacketCallback callback) {
+        this.callbacks.put(playerId, callback);
+    }
+
+    @Override
+    public void run() {
+        while(true) {
+            processIncomePackets();
+            updateGameState();
+            processOutcomePackets();
+        }
+    }
+
+    @Override
+    public void createGameEntity() {
+
+    }
+
+    @Override
+    public void createPlayerEntity() {
+
+    }
+
+    @Override
+    public void createDeckEntities() {
+
+    }
+
+    @Override
+    public void createCardEntity() {
+
+    }
+
+    @Override
+    public void createPlayerHeroEntity() {
+
+    }
+
+    @Override
+    public void createPlayerHeroPowerEntity() {
+
+    }
+
+    private Optional<RoomPlayerDTO> findPlayerById(Long id) {
+        return players.stream().filter(p -> p.getUserId().longValue() == id.longValue()).findFirst();
     }
 }

src/main/java/com/alterdekim/hearthhack/component/GameServer.java

@@ -39,7 +39,7 @@ public class GameServer {
             while(true) {
                 Socket client = this.serverSocket.accept();
                 log.info("New WOW Connection Established From {}", client.getInetAddress().toString());
-                GameConnection c = new GameConnection(client, this);
+                GameConnection c = new GameConnection(this, client);
                 this.connections.add(c);
                 c.start();
             }

src/main/java/com/alterdekim/hearthhack/component/interfaces/GamePacketCallback.java

@@ -0,0 +1,7 @@
+package com.alterdekim.hearthhack.component.interfaces;
+
+import com.alterdekim.hearthhack.util.PegasusPacket;
+
+public interface GamePacketCallback {
+    void onMessage(PegasusPacket packet);
+}

src/main/java/com/alterdekim/hearthhack/component/interfaces/IGameRoom.java

@@ -0,0 +1,10 @@
+package com.alterdekim.hearthhack.component.interfaces;
+
+public interface IGameRoom {
+    void createGameEntity();
+    void createPlayerEntity();
+    void createDeckEntities();
+    void createCardEntity();
+    void createPlayerHeroEntity();
+    void createPlayerHeroPowerEntity();
+}

src/main/java/com/alterdekim/hearthhack/game/GameState.java

@@ -0,0 +1,16 @@
+package com.alterdekim.hearthhack.game;
+
+public enum GameState {
+    CreateGame,
+    CreatePlayers,
+    CreateDecks,
+    CreateHeroes,
+    CreateHeroPowers,
+    Running;
+
+    public GameState next() {
+        GameState[] states = GameState.values();
+        int i = this.ordinal()+1 >= states.length ? 0 : this.ordinal()+1;
+        return states[i];
+    }
+}

src/main/java/com/alterdekim/hearthhack/game/IncomeGamePacket.java

@@ -0,0 +1,14 @@
+package com.alterdekim.hearthhack.game;
+
+import com.alterdekim.hearthhack.util.PegasusPacket;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+
+@RequiredArgsConstructor
+@Getter
+@ToString
+public class IncomeGamePacket {
+    private final Long playerId;
+    private final PegasusPacket packet;
+}

src/main/java/com/alterdekim/hearthhack/game/OutcomeGamePacket.java

@@ -0,0 +1,14 @@
+package com.alterdekim.hearthhack.game;
+
+import com.alterdekim.hearthhack.util.PegasusPacket;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+
+@RequiredArgsConstructor
+@Getter
+@ToString
+public class OutcomeGamePacket {
+    private final Long playerId;
+    private final PegasusPacket packet;
+}