Exploring ladder

src/main/java/com/alterdekim/hearthhack/GameDeck.java

@@ -0,0 +1,9 @@
+package com.alterdekim.hearthhack;
+
+import com.alterdekim.PegasusGame;
+
+import java.util.List;
+
+public class GameDeck {
+    private List<PegasusGame.PowerHistoryEntity.Builder> deck;
+}

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

@@ -1,5 +1,6 @@
 package com.alterdekim.hearthhack.component;
 
+import com.alterdekim.hearthhack.config.ObjectConfig;
 import com.alterdekim.hearthhack.dto.RoomPlayerDTO;
 import com.alterdekim.hearthhack.service.RoomService;
 import com.alterdekim.hearthhack.service.UserService;
@@ -23,6 +24,9 @@ public class GamePool {
     @Autowired
     private RoomService roomService;
 
+    @Autowired
+    private ObjectConfig config;
+
     private final ConcurrentHashMap<Long, GameRoom> games = new ConcurrentHashMap<>();
 
     private static final int PLAYERS_COUNT = 1; // TODO: MAKE 2 PLAYERS FOR PRODUCTION
@@ -35,7 +39,7 @@ public class GamePool {
                     log.info("Got room!");
                     List<RoomPlayerDTO> players = r.getPlayers();
                     log.info("Put room by id: {}", r.getId());
-                    games.put(r.getId(), new GameRoom(players, userService, r.getRoomPassword()));
+                    games.put(r.getId(), new GameRoom(players, userService, r.getRoomPassword(), config));
                     roomService.removeRoom(r.getId());
                 });
     }

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

@@ -1,26 +1,47 @@
 package com.alterdekim.hearthhack.component;
 
+import com.alterdekim.PegasusGame;
+import com.alterdekim.PegasusShared;
+import com.alterdekim.hearthhack.GameDeck;
 import com.alterdekim.hearthhack.component.interfaces.GamePacketCallback;
 import com.alterdekim.hearthhack.component.interfaces.IGameRoom;
+import com.alterdekim.hearthhack.config.ObjectConfig;
 import com.alterdekim.hearthhack.dto.RoomPlayerDTO;
-import com.alterdekim.hearthhack.game.GameState;
+import com.alterdekim.hearthhack.entity.Deck;
-import com.alterdekim.hearthhack.game.IncomeGamePacket;
+import com.alterdekim.hearthhack.entity.DeckContent;
-import com.alterdekim.hearthhack.game.OutcomeGamePacket;
+import com.alterdekim.hearthhack.game.*;
 import com.alterdekim.hearthhack.service.UserService;
+import com.alterdekim.hearthhack.util.PegasusPacket;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.stream.Collectors;
 
+import static com.alterdekim.PegasusGame.Option.Type.END_TURN;
+
+
 @Slf4j
 public class GameRoom extends Thread implements IGameRoom {
+
+    private static final List<PegasusShared.BnetId> bnets = List.of(PegasusShared.BnetId.newBuilder()
+            .setHi(144115198130930503L)
+            .setLo(78330215).build(), PegasusShared.BnetId.newBuilder()
+            .setHi(144115198130930503L)
+            .setLo(77500085).build());
+
+    private final ObjectConfig objectConfig;
+
     @Getter
     private final List<RoomPlayerDTO> players;
 
+    private final ConcurrentHashMap<Long, GameDeck> decks;
+
     private final ConcurrentHashMap<Long, GamePacketCallback> callbacks;
 
     private final UserService userService;
@@ -34,17 +55,26 @@ public class GameRoom extends Thread implements IGameRoom {
     private ConcurrentLinkedQueue<IncomeGamePacket> incomeQueue;
     private ConcurrentLinkedQueue<OutcomeGamePacket> outcomeQueue;
 
-    public GameRoom(List<RoomPlayerDTO> players, UserService userService, String password) {
+    // TODO: abolish that later. It's a temporary solution
+    private int entity_id = 4;
+
+    public GameRoom(List<RoomPlayerDTO> players, UserService userService, String password, ObjectConfig objectConfig) {
         this.players = players;
         this.userService = userService;
         this.password = password;
         this.incomeQueue = new ConcurrentLinkedQueue<>();
         this.outcomeQueue = new ConcurrentLinkedQueue<>();
+        this.decks = new ConcurrentHashMap<>();
         this.callbacks = new ConcurrentHashMap<>();
         this.globalState = GameState.CreateGame;
-        this.start();
+        this.objectConfig = objectConfig;
+        log.info("GameRoom players: {}", this.players);
+        this.start(); // TODO: debug mode should stop that
     }
 
+    private int hero_p1 = 0;
+    private int hero_p2 = 0;
+
     private void processIncomePackets() {
         if( this.incomeQueue.isEmpty() ) return;
         IncomeGamePacket packet = this.incomeQueue.peek();
@@ -54,26 +84,29 @@ public class GameRoom extends Thread implements IGameRoom {
     }
 
     private void processOutcomePackets() {
-       /* if( this.outcomeQueue.isEmpty() ) return;
+        if( this.outcomeQueue.isEmpty() ) return;
         OutcomeGamePacket packet = this.outcomeQueue.peek();
-        this.outcomeQueue.poll();*/
+        GamePacketCallback callback = this.callbacks.get(packet.getPlayerId());
+        if (callback == null) return;
+        callback.onMessage(packet.getPacket());
+        this.outcomeQueue.poll();
     }
 
     private void processIncomePacket(IncomeGamePacket packet) {
-        if( packet.getPacket().getType() != 1) return;
+        log.info("processIncomePacket: {}", packet.getPacket());
+       /* 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()));
+        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();
@@ -95,17 +128,323 @@ public class GameRoom extends Thread implements IGameRoom {
 
     @Override
     public void createGameEntity() {
+        log.info("create Game Entity");
+        PegasusGame.PowerHistory powerHistory = PegasusGame.PowerHistory.newBuilder()
+                .addList(PegasusGame.PowerHistoryData.newBuilder()
+                        .setCreateGame(PegasusGame.PowerHistoryCreateGame.newBuilder()
+                                .setGameEntity(PegasusGame.Entity.newBuilder()
+                                        .setId(1)
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(10)
+                                                .setValue(85)
+                                        )
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(GameTag.CARDTYPE.getValue())
+                                                .setValue(TagCardType.GAME.ordinal())
+                                        )
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(GameTag.TURN.getValue())
+                                                .setValue(1)
+                                        )
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(GameTag.STATE.getValue())
+                                                .setValue(TagState.RUNNING.ordinal())
+                                        )
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(GameTag.ZONE.getValue())
+                                                .setValue(TagZone.PLAY.ordinal())
+                                        )
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(GameTag.ENTITY_ID.getValue())
+                                                .setValue(1)
+                                        )
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(GameTag.STEP.getValue())
+                                                .setValue(TagStep.BEGIN_MULLIGAN.ordinal()) // 10
+                                        )
+                                        .addTags(PegasusGame.Tag.newBuilder()
+                                                .setName(GameTag.NEXT_STEP.getValue())
+                                                .setValue(TagStep.BEGIN_MULLIGAN.ordinal()) // 12
+                                        )
+                                )
+                                .addAllPlayers(createPlayersEntity())
+                        )
+                ).build();
 
+        this.broadcast(new PegasusPacket(19, 0, powerHistory.toByteArray()));
+        this.nextGlobalState();
     }
 
-    @Override
+    public List<PegasusGame.Player> createPlayersEntity() {
-    public void createPlayerEntity() {
+        log.info("create Players entities");
+        List<PegasusGame.Player> pls = new ArrayList<>();
+        for( int i = 2, pi = 0; i < 4; i++, pi++ ) {
+            final PegasusGame.Entity.Builder entity = PegasusGame.Entity.newBuilder().setId(i == 2 ? 3 : 2);
 
+            if( pi < this.players.size() ) players.get(pi).setController(i == 2 ? 2 : 1);
+
+            if( i == 2 ) {
+                entity.addTags(PegasusGame.Tag.newBuilder()
+                        .setName(GameTag.FIRST_PLAYER.getValue())
+                        .setValue(1)
+                );
+                entity.addTags(PegasusGame.Tag.newBuilder()
+                        .setName(GameTag.CURRENT_PLAYER.getValue())
+                        .setValue(1)
+                );
+                entity.addTags(PegasusGame.Tag.newBuilder()
+                        .setName(GameTag.RESOURCES.getValue())
+                        .setValue(1)
+                );
+            }
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.HERO_ENTITY.getValue())
+                    .setValue(i == 2 ? 66 : 64)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.PLAYSTATE.getValue())
+                    .setValue(TagPlayState.PLAYING.ordinal())
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.TEAM_ID.getValue())
+                    .setValue(i == 2 ? 2 : 1)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.PLAYER_ID.getValue())
+                    .setValue(i == 2 ? 2 : 1)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.MAXHANDSIZE.getValue())
+                    .setValue(10)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.STARTHANDSIZE.getValue())
+                    .setValue(4)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.NUM_TURNS_LEFT.getValue())
+                    .setValue(1)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.CARDTYPE.getValue())
+                    .setValue(TagCardType.PLAYER.ordinal())
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.ZONE.getValue())
+                    .setValue(TagZone.PLAY.ordinal())
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.TIMEOUT.getValue())
+                    .setValue(75)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.MAXRESOURCES.getValue())
+                    .setValue(10)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.ENTITY_ID.getValue())
+                    .setValue(i == 2 ? 3 : 2)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.CONTROLLER.getValue())
+                    .setValue(i == 2 ? 2 : 1)
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.MULLIGAN_STATE.getValue())
+                    .setValue(TagMulligan.DONE.ordinal())
+            );
+
+            entity.addTags(PegasusGame.Tag.newBuilder()
+                    .setName(GameTag.NUM_CARDS_DRAWN_THIS_TURN.getValue())
+                    .setValue(i == 2 ? 1 : 4)
+            );
+
+            // TODO: make custom cardback selection
+            pls.add(
+                    PegasusGame.Player.newBuilder()
+                        .setId(i)
+                        .setGameAccountId(bnets.get(i-2))
+                        .setCardBack(pi < this.players.size() ? userService.getCardBackById(players.get(pi).getUserId()).getBackId() : 0)
+                        .setEntity(entity)
+                        .build()
+            );
+        }
+        return pls;
     }
 
     @Override
     public void createDeckEntities() {
+        log.info("create Deck Entities");
+        // sugar for debug with 1 player. Must be erased after debug.
+        PegasusGame.PowerHistory.Builder pw = PegasusGame.PowerHistory.newBuilder();
 
+        for(int i = 0; i < 26; i++, this.entity_id++) {
+            pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                    .setFullEntity(PegasusGame.PowerHistoryEntity.newBuilder()
+                            .setEntity(this.entity_id)
+                            .setName("")
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ENTITY_ID.getValue())
+                                    .setValue(this.entity_id)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.CONTROLLER.getValue())
+                                    .setValue(1)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ZONE.getValue())
+                                    .setValue(TagZone.DECK.ordinal())
+                            )
+                    )
+            );
+        }
+
+        for(int i = 1; i <= 5; i++, this.entity_id++) {
+            pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                    .setFullEntity(PegasusGame.PowerHistoryEntity.newBuilder()
+                            .setEntity(this.entity_id)
+                            .setName("")
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ENTITY_ID.getValue())
+                                    .setValue(this.entity_id)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.CONTROLLER.getValue())
+                                    .setValue(1)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ZONE_POSITION.getValue())
+                                    .setValue(i)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ZONE.getValue())
+                                    .setValue(TagZone.HAND.ordinal())
+                            )
+                    )
+            );
+        }
+
+        List<PegasusGame.PowerHistoryEntity.Builder> ens = List.of(
+                card2Entity("TB_SPT_Boss").get(),
+                card2Entity("CS1h_001").get()
+        );
+        this.hero_p1 = this.entity_id;
+        for(int i = 0; i < 2; i++, this.entity_id++) {
+            pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                    .setFullEntity(ens.get(i)
+                            .setEntity(this.entity_id)
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ENTITY_ID.getValue())
+                                    .setValue(this.entity_id)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.CONTROLLER.getValue())
+                                    .setValue(1)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ZONE.getValue())
+                                    .setValue(TagZone.PLAY.ordinal())
+                            )
+                    )
+            );
+        }
+
+        // other player
+
+        List<DeckContent> dc = userService.getDeckContentForDeckId(this.players.get(0).getUserId(), this.players.get(0).getDeckId());
+
+        for(int i = 0; i < 26; i++, this.entity_id++) {
+            pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                    .setFullEntity(PegasusGame.PowerHistoryEntity.newBuilder()
+                            .setEntity(this.entity_id)
+                            .setName("")
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ENTITY_ID.getValue())
+                                    .setValue(this.entity_id)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.CONTROLLER.getValue())
+                                    .setValue(2)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ZONE.getValue())
+                                    .setValue(TagZone.DECK.ordinal())
+                            )
+                    )
+            );
+        }
+
+        ens = dc.subList(0, 3).stream()
+                .map(d -> card2Entity(d.getAssetId()).get())
+                .collect(Collectors.toList());
+
+        for(int i = 1; i <= 3; i++, this.entity_id++) {
+            pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                    .setFullEntity(ens.get(i-1)
+                            .setEntity(this.entity_id)
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ENTITY_ID.getValue())
+                                    .setValue(this.entity_id)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.CONTROLLER.getValue())
+                                    .setValue(2)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ZONE_POSITION.getValue())
+                                    .setValue(i)
+                            )
+                            .addTags(PegasusGame.Tag.newBuilder()
+                                    .setName(GameTag.ZONE.getValue())
+                                    .setValue(TagZone.HAND.ordinal())
+                            )
+                    )
+            );
+        }
+
+        // there was a place for hero & hero_power
+
+        pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                .setFullEntity(card2Entity("CS2_103e2").get()
+                        .setEntity(this.entity_id)
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.ENTITY_ID.getValue())
+                                .setValue(this.entity_id)
+                        )
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.CONTROLLER.getValue())
+                                .setValue(2)
+                        )
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.ZONE.getValue())
+                                .setValue(TagZone.SETASIDE.ordinal())
+                        )
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.ZONE_POSITION.getValue())
+                                .setValue(0)
+                        )
+                )
+        );
+
+        this.entity_id++;
+
+        this.broadcast(new PegasusPacket(19, 0, pw.build().toByteArray()));
+
+        this.nextGlobalState();
     }
 
     @Override
@@ -115,15 +454,146 @@ public class GameRoom extends Thread implements IGameRoom {
 
     @Override
     public void createPlayerHeroEntity() {
+        log.info("Player hero entity");
 
+        PegasusGame.PowerHistory.Builder pw = PegasusGame.PowerHistory.newBuilder();
+
+        Optional<Deck> deck = userService.getDecksForUser(this.players.get(0).getUserId())
+                .stream()
+                .filter(d -> d.getId().longValue() == this.players.get(0).getDeckId().longValue())
+                .findFirst();
+
+        pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                .setFullEntity(card2Entity(deck.get().getHero().longValue()).get()
+                        .setEntity(this.entity_id)
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.ENTITY_ID.getValue())
+                                .setValue(this.entity_id)
+                        )
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.CONTROLLER.getValue())
+                                .setValue(2)
+                        )
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.ZONE.getValue())
+                                .setValue(TagZone.PLAY.ordinal())
+                        )
+                )
+        );
+        this.hero_p2 = this.entity_id;
+        this.entity_id++;
+
+        pw.addList(PegasusGame.PowerHistoryData.newBuilder()
+                .setFullEntity(getHeroPowerFromHeroId(deck.get().getHero().longValue()).get()
+                        .setEntity(this.entity_id)
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.ENTITY_ID.getValue())
+                                .setValue(this.entity_id)
+                        )
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.CONTROLLER.getValue())
+                                .setValue(2)
+                        )
+                        .addTags(PegasusGame.Tag.newBuilder()
+                                .setName(GameTag.ZONE.getValue())
+                                .setValue(TagZone.PLAY.ordinal())
+                        )
+                )
+        );
+
+        this.broadcast(new PegasusPacket(19, 0, pw.build().toByteArray()));
+
+        this.entity_id++;
+
+        PegasusGame.AllOptions allOptions = PegasusGame.AllOptions.newBuilder()
+                .setId(1)
+                .addOptions(PegasusGame.Option.newBuilder()
+                        .setType(END_TURN)
+                )
+                .addOptions(PegasusGame.Option.newBuilder()
+                        .setType(PegasusGame.Option.Type.POWER)
+                        .setMainOption(PegasusGame.SubOption.newBuilder()
+                                .setId(this.hero_p2)
+                                .addTargets(this.hero_p1)
+                        )
+                )
+                .build();
+
+        this.broadcast(new PegasusPacket( 14, 0, allOptions.toByteArray()));
+
+        this.nextGlobalState();
     }
 
     @Override
     public void createPlayerHeroPowerEntity() {
-
+        log.info("hero power entity");
+        this.nextGlobalState();
     }
 
     private Optional<RoomPlayerDTO> findPlayerById(Long id) {
         return players.stream().filter(p -> p.getUserId().longValue() == id.longValue()).findFirst();
     }
+
+    private void broadcast(PegasusPacket packet) {
+        this.players.forEach(p -> this.outcomeQueue.add(new OutcomeGamePacket(p.getUserId(), packet)));
+    }
+
+    private void nextGlobalState() {
+        this.globalState = GameState.next(this.globalState);
+    }
+
+    private Optional<PegasusGame.PowerHistoryEntity.Builder> card2Entity(String cardId) {
+        return this.objectConfig.getFormattedCards()
+                .getObjects()
+                .stream()
+                .filter(c -> c.getEntity().getCardId().equals(cardId))
+                .map(c ->
+                    PegasusGame.PowerHistoryEntity.newBuilder()
+                            .setName(c.getEntity().getCardId())
+                            .addAllTags(c.getEntity().getTags().stream()
+                                    .filter(t -> !t.getType().equals("String"))
+                                    .map(t ->
+                                            PegasusGame.Tag.newBuilder()
+                                                    .setName(t.getEnumID())
+                                                    .setValue(t.getValue())
+                                                    .build()
+                                    )
+                                    .collect(Collectors.toList()))
+                )
+                .findFirst();
+    }
+
+    private Optional<PegasusGame.PowerHistoryEntity.Builder> card2Entity(Long cardId) {
+        return this.objectConfig.getFormattedCards()
+                .getObjects()
+                .stream()
+                .filter(o -> o.getDbfCard().findField("ID").isPresent() && Long.parseLong(o.getDbfCard().findField("ID").get().getVal()) == cardId)
+                .map(c ->
+                        PegasusGame.PowerHistoryEntity.newBuilder()
+                                .setName(c.getEntity().getCardId())
+                                .addAllTags(c.getEntity().getTags().stream()
+                                        .filter(t -> !t.getType().equals("String"))
+                                        .map(t ->
+                                                PegasusGame.Tag.newBuilder()
+                                                        .setName(t.getEnumID())
+                                                        .setValue(t.getValue())
+                                                        .build()
+                                        )
+                                        .collect(Collectors.toList()))
+                )
+                .findFirst();
+    }
+
+    private Optional<PegasusGame.PowerHistoryEntity.Builder> getHeroPowerFromHeroId(Long cardId) {
+        return card2Entity(Long.parseLong(this.objectConfig.getFormattedCards()
+                .getObjects()
+                .stream()
+                .filter(o -> o.getDbfCard().findField("ID").isPresent() && Long.parseLong(o.getDbfCard().findField("ID").get().getVal()) == cardId)
+                .findFirst()
+                .get()
+                .getDbfCard()
+                .findField("HERO_POWER_ID")
+                .get()
+                .getVal()));
+    }
 }

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

@@ -2,7 +2,6 @@ package com.alterdekim.hearthhack.component.interfaces;
 
 public interface IGameRoom {
     void createGameEntity();
-    void createPlayerEntity();
     void createDeckEntities();
     void createCardEntity();
     void createPlayerHeroEntity();

src/main/java/com/alterdekim/hearthhack/component/processor/GameMasterProcessor.java

@@ -21,7 +21,7 @@ public class GameMasterProcessor extends Processor {
         // FindGameRequest FindGameResponse game_master
         // GameType
         Protocol.FindGameRequest gameRequest = Protocol.FindGameRequest.parseFrom(packet.getBody());
-
+        log.info("FindGameRequest: {}", gameRequest);
         Protocol.Attribute a = gameRequest.getProperties().getCreationAttributesList().stream()
                 .filter(p -> p.hasName() && p.getName().equals("type"))
                 .findFirst()
@@ -62,29 +62,18 @@ public class GameMasterProcessor extends Processor {
         conn.send(new BattleNetPacket(header, notification.toByteArray()));
 
 
-   /*     byte[] ip = "localhost".getBytes(StandardCharsets.US_ASCII);
-        log.info("ip: {} lenhex: {}, len: {}", Util.bytesToHex(ip), Util.intToHex(ip.length), ip.length);
-        byte[] bb = Util.hexStringToByteArray("0A120900000000000000021100000000000000001212094743545702000002116739AB04000000001A08475F524553554C54221E0A0F67616D655F726571756573745F6964120B48B6D2A3C7A4FCA2E1B901220B0A056572726F7212024800222E0A0B67616D655F68616E646C65121F3A1D09F64263F5D33456C7121209EEA60D5703000006118C270B000A62A3AB22B3010A0F636F6E6E656374696F6E5F696E666F129F013A9C010A12094743545702000002116739AB040000000012"+Util.intToHex(ip.length)+Util.bytesToHex(ip)+"188C1D2206456A634465492A130A0776657273696F6E12082A0665694B3271762A0D0A0467616D65120518AA80C4062A0C0A06706C61796572120218012A0B0A026964120518B2B0AA1C2A0F0A09726573756D61626C65120210012A1E0A12737065637461746F725F70617373776F726412082A066F44697049664A0A0895A56710E9E6ACB90552150A050D93710E1A120C0D6739AB0415474354571802");
-
-        header = Protocol.Header.newBuilder()
-                .setServiceId(4)
-                .setMethodId(1)
-                .setSize(bb.length)
-                .setToken(conn.nextToken())
-                .setObjectId(0)
-                .setStatus(0)
-                .build();
-
-        conn.send(new BattleNetPacket(header, bb));
-
-        Protocol.Notification n = Protocol.Notification.parseFrom(bb);
-        Protocol.ConnectInfo ci = Protocol.ConnectInfo.parseFrom(
-                n.getAttributeList().stream().filter(p -> p.hasName() && p.getName().equals("connection_info")).findFirst().get().getValue().getMessageValue()
-        );
-        log.info("GGGG: {}", ci);*/
         String pwd = UUID.randomUUID().toString();
         Long roomId = conn.getRoomService().createRoom(new RoomDTO(pwd)); // TODO: make 1 player rooms check.
-        conn.getRoomService().joinRoom(roomId, conn.getUserId()); // TODO: make 1 player rooms check.
+        conn.getRoomService().joinRoom(roomId, conn.getUserId(),
+                gameRequest.getPlayerList().get(0)
+                        .getAttributeList()
+                        .stream()
+                        .filter(p -> p.hasName() && p.getName().equals("deck"))
+                        .findFirst()
+                        .get()
+                        .getValue()
+                        .getIntValue()
+        ); // TODO: make 1 player rooms check.
 
         Thread.sleep(1000L);
 
@@ -128,7 +117,7 @@ public class GameMasterProcessor extends Processor {
                                                             .setHigh(144115198130930503L)
                                                             .setLow(78330215L)
                                                     )
-                                                    .setHost("192.168.0.9")
+                                                    .setHost("192.168.0.10")
                                                     .setPort(3724)
                                                     .setToken(ByteString.copyFromUtf8(pwd)) // password
                                                     .addAttribute(Protocol.Attribute

src/main/java/com/alterdekim/hearthhack/dto/RoomPlayerDTO.java

@@ -1,14 +1,13 @@
 package com.alterdekim.hearthhack.dto;
 
-import lombok.AllArgsConstructor;
+import lombok.*;
-import lombok.Getter;
-import lombok.Setter;
-import lombok.ToString;
 
-@AllArgsConstructor
+@RequiredArgsConstructor
 @Getter
 @Setter
 @ToString
 public class RoomPlayerDTO {
-    private Long userId;
+    private final Long userId;
+    private final Long deckId;
+    private Integer controller;
 }

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

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

src/main/java/com/alterdekim/hearthhack/service/RoomService.java

@@ -51,9 +51,9 @@ public class RoomService implements IService {
         map = new ConcurrentHashMap<>();
     }
 
-    public void joinRoom(Long roomId, Long userId) {
+    public void joinRoom(Long roomId, Long userId, Long deckId) {
         RoomDTO r = map.get(roomId);
-        r.getPlayers().add(new RoomPlayerDTO(userId));
+        r.getPlayers().add(new RoomPlayerDTO(userId, deckId));
         map.put(roomId, r);
     }
 }

src/main/java/com/alterdekim/hearthhack/util/FormattedCards.java

@@ -5,6 +5,7 @@ import com.alterdekim.hearthhack.game.GameTag;
 import lombok.*;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 @ToString
@@ -28,7 +29,7 @@ public class FormattedCards {
         return this.objects.stream()
                 .filter(o -> o.getEntity().getTags()
                         .stream()
-                        .anyMatch(f -> f.getEnumID().intValue() == tag.getValue().intValue() && val.equals(f.getVal()))
+                        .anyMatch(f -> f.getEnumID().intValue() == tag.getValue().intValue() && val.equals(f.getRawValue()))
                 )
                 .collect(Collectors.toList());
     }

src/main/java/com/alterdekim/hearthhack/util/PegasusPacket.java

@@ -3,10 +3,12 @@ package com.alterdekim.hearthhack.util;
 import com.google.protobuf.GeneratedMessageV3;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.ToString;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
+@ToString
 @NoArgsConstructor
 public class PegasusPacket {