Add Event_RemoveMessages

cockatrice/src/player.cpp

@@ -152,7 +152,7 @@ Player::Player(const ServerInfo_User &info, int _id, bool _local, bool _judge, T
 
     stack = new StackZone(this, (int)table->boundingRect().height(), this);
 
-    hand = new HandZone(this, _local || _judge || (_parent->getSpectator() && _parent->getSpectatorsSeeEverything()),
+    hand = new HandZone(this, _local || (_parent->getSpectator() && _parent->getSpectatorsSeeEverything()),
                         (int)table->boundingRect().height(), this);
     connect(hand, SIGNAL(cardCountChanged()), handCounter, SLOT(updateNumber()));
     connect(handCounter, SIGNAL(showContextMenu(const QPoint &)), hand, SLOT(showContextMenu(const QPoint &)));

common/server_cardzone.cpp

@@ -323,15 +323,11 @@ void Server_CardZone::getInfo(ServerInfo_Zone *info, Server_Player *playerWhosAs
     info->set_name(name.toStdString());
     info->set_type(type);
     info->set_with_coords(has_coords);
-    info->set_card_count(static_cast<int>(cards.size()));
+    info->set_card_count(cards.size());
     info->set_always_reveal_top_card(alwaysRevealTopCard);
     info->set_always_look_at_top_card(alwaysLookAtTopCard);
-
-    const auto selfPlayerAsking = playerWhosAsking == player || omniscient;
-    const auto zonesSelfCanSee = type != ServerInfo_Zone::HiddenZone;
-    const auto otherPlayerAsking = playerWhosAsking != player;
-    const auto zonesOthersCanSee = type == ServerInfo_Zone::PublicZone;
-    if ((selfPlayerAsking && zonesSelfCanSee) || (otherPlayerAsking && zonesOthersCanSee)) {
+    if ((((playerWhosAsking == player) || omniscient) && (type != ServerInfo_Zone::HiddenZone)) ||
+        ((playerWhosAsking != player) && (type == ServerInfo_Zone::PublicZone))) {
         QListIterator<Server_Card *> cardIterator(cards);
         while (cardIterator.hasNext())
             cardIterator.next()->getInfo(info->add_card_list());

common/server_game.cpp

@@ -276,7 +276,7 @@ void Server_Game::sendGameStateToPlayers()
 {
     // game state information for replay and omniscient spectators
     Event_GameStateChanged omniscientEvent;
-    createGameStateChangedEvent(&omniscientEvent, nullptr, true, false);
+    createGameStateChangedEvent(&omniscientEvent, 0, true, false);
 
     GameEventContainer *replayCont = prepareGameEvent(omniscientEvent, -1);
     replayCont->set_seconds_elapsed(secondsElapsed - startTimeOfThisGame);
@@ -287,19 +287,18 @@ void Server_Game::sendGameStateToPlayers()
     // If spectators are not omniscient, we need an additional createGameStateChangedEvent call, otherwise we can use
     // the data we used for the replay. All spectators are equal, so we don't need to make a createGameStateChangedEvent
     // call for each one.
-    Event_GameStateChanged spectatorNormalEvent;
-    createGameStateChangedEvent(&spectatorNormalEvent, nullptr, false, false);
+    Event_GameStateChanged spectatorEvent;
+    if (spectatorsSeeEverything)
+        spectatorEvent = omniscientEvent;
+    else
+        createGameStateChangedEvent(&spectatorEvent, 0, false, false);
 
     // send game state info to clients according to their role in the game
     for (Server_Player *player : players.values()) {
         GameEventContainer *gec;
-        if (player->getSpectator()) {
-            if (spectatorsSeeEverything || player->getJudge()) {
-                gec = prepareGameEvent(omniscientEvent, -1);
-            } else {
-                gec = prepareGameEvent(spectatorNormalEvent, -1);
-            }
-        } else {
+        if (player->getSpectator())
+            gec = prepareGameEvent(spectatorEvent, -1);
+        else {
             Event_GameStateChanged event;
             createGameStateChangedEvent(&event, player, false, false);
 
@@ -342,7 +341,7 @@ void Server_Game::doStartGameIfReady()
         gameInfo->set_started(false);
 
         Event_GameStateChanged omniscientEvent;
-        createGameStateChangedEvent(&omniscientEvent, nullptr, true, true);
+        createGameStateChangedEvent(&omniscientEvent, 0, true, true);
 
         GameEventContainer *replayCont = prepareGameEvent(omniscientEvent, -1);
         replayCont->set_seconds_elapsed(0);
@@ -712,8 +711,7 @@ void Server_Game::createGameJoinedEvent(Server_Player *player, ResponseContainer
     event2.set_active_phase(activePhase);
 
     for (auto *_player : players.values()) {
-        _player->getInfo(event2.add_player_list(), _player,
-                         (_player->getSpectator() && (spectatorsSeeEverything || _player->getJudge())), true);
+        _player->getInfo(event2.add_player_list(), _player, _player->getSpectator() && spectatorsSeeEverything, true);
     }
 
     rc.enqueuePostResponseItem(ServerMessage::GAME_EVENT_CONTAINER, prepareGameEvent(event2, -1));
@@ -727,8 +725,8 @@ void Server_Game::sendGameEventContainer(GameEventContainer *cont,
 
     cont->set_game_id(gameId);
     for (Server_Player *player : players.values()) {
-        const bool playerPrivate = (player->getPlayerId() == privatePlayerId) ||
-                                   (player->getSpectator() && (spectatorsSeeEverything || player->getJudge()));
+        const bool playerPrivate =
+            (player->getPlayerId() == privatePlayerId) || (player->getSpectator() && spectatorsSeeEverything);
         if ((recipients.testFlag(GameEventStorageItem::SendToPrivate) && playerPrivate) ||
             (recipients.testFlag(GameEventStorageItem::SendToOthers) && !playerPrivate))
             player->sendGameEvent(*cont);

common/server_player.cpp

@@ -2085,10 +2085,6 @@ Server_Player::cmdRevealCards(const Command_RevealCards &cmd, ResponseContainer
             zone->addWritePermission(cmd.player_id());
         }
 
-        if (getJudge()) {
-            ges.setOverwriteOwnership(true);
-        }
-
         ges.enqueueGameEvent(eventPrivate, playerId, GameEventStorageItem::SendToPrivate, cmd.player_id());
         ges.enqueueGameEvent(eventOthers, playerId, GameEventStorageItem::SendToOthers);
     } else {

common/server_response_containers.cpp

@@ -53,21 +53,17 @@ void GameEventStorage::sendToGame(Server_Game *game)
     if (gameEventList.isEmpty())
         return;
 
-    auto *contPrivate = new GameEventContainer;
-    auto *contOthers = new GameEventContainer;
+    GameEventContainer *contPrivate = new GameEventContainer;
+    GameEventContainer *contOthers = new GameEventContainer;
     int id = privatePlayerId;
     if (forcedByJudge != -1) {
         contPrivate->set_forced_by_judge(forcedByJudge);
         contOthers->set_forced_by_judge(forcedByJudge);
-        if (overwriteOwnership) {
-            id = forcedByJudge;
-            setOverwriteOwnership(false);
-        }
+        id = forcedByJudge;
     }
-
-    for (const auto &i : gameEventList) {
-        const GameEvent &event = i->getGameEvent();
-        const GameEventStorageItem::EventRecipients recipients = i->getRecipients();
+    for (int i = 0; i < gameEventList.size(); ++i) {
+        const GameEvent &event = gameEventList[i]->getGameEvent();
+        const GameEventStorageItem::EventRecipients recipients = gameEventList[i]->getRecipients();
         if (recipients.testFlag(GameEventStorageItem::SendToPrivate))
             contPrivate->add_event_list()->CopyFrom(event);
         if (recipients.testFlag(GameEventStorageItem::SendToOthers))

common/server_response_containers.h

@@ -50,7 +50,6 @@ private:
     QList<GameEventStorageItem *> gameEventList;
     int privatePlayerId;
     int forcedByJudge = -1;
-    bool overwriteOwnership = false;
 
 public:
     GameEventStorage();
@@ -73,10 +72,6 @@ public:
     {
         forcedByJudge = playerId;
     }
-    void setOverwriteOwnership(bool shouldOverwriteOwnership)
-    {
-        overwriteOwnership = shouldOverwriteOwnership;
-    }
 
     void enqueueGameEvent(const ::google::protobuf::Message &event,
                           int playerId,

webclient/src/websocket/events/room/RoomEvents.spec.ts

@@ -1,66 +0,0 @@
-import { Message } from 'types';
-
-import { RoomPersistence } from '../../persistence';
-
-import {
-  RoomEvent,
-  JoinRoomData,
-  LeaveRoomData,
-  ListGamesData,
-} from './interfaces';
-
-import { RoomEvents } from '.';
-
-describe.skip('RoomEvents', () => {
-  it('.Event_JoinRoom.ext should call RoomPersistence.userJoined', () => {
-    jest.spyOn(RoomPersistence, 'userJoined').mockImplementation(() => {});
-    const data: JoinRoomData = { userInfo: {} as any };
-    const event: RoomEvent = { roomEvent: { roomId: 1 } };
-
-    RoomEvents['.Event_JoinRoom.ext'](data, event);
-
-    expect(RoomPersistence.userJoined).toHaveBeenCalledWith(
-      event.roomEvent.roomId,
-      data.userInfo
-    );
-  });
-
-  it('.Event_LeaveRoom.ext should call RoomPersistence.userLeft', () => {
-    jest.spyOn(RoomPersistence, 'userLeft').mockImplementation(() => {});
-    const data: LeaveRoomData = { name: '' };
-    const event: RoomEvent = { roomEvent: { roomId: 1 } };
-
-    RoomEvents['.Event_LeaveRoom.ext'](data, event);
-
-    expect(RoomPersistence.userLeft).toHaveBeenCalledWith(
-      event.roomEvent.roomId,
-      data.name
-    );
-  });
-
-  it('.Event_ListGames.ext should call RoomPersistence.updateGames', () => {
-    jest.spyOn(RoomPersistence, 'updateGames').mockImplementation(() => {});
-    const data: ListGamesData = { gameList: [] };
-    const event: RoomEvent = { roomEvent: { roomId: 1 } };
-
-    RoomEvents['.Event_ListGames.ext'](data, event);
-
-    expect(RoomPersistence.updateGames).toHaveBeenCalledWith(
-      event.roomEvent.roomId,
-      data.gameList
-    );
-  });
-
-  it('.Event_RoomSay.ext should call RoomPersistence.addMessage', () => {
-    jest.spyOn(RoomPersistence, 'addMessage').mockImplementation(() => {});
-    const data: Message = {} as any;
-    const event: RoomEvent = { roomEvent: { roomId: 1 } };
-
-    RoomEvents['.Event_RoomSay.ext'](data, event);
-
-    expect(RoomPersistence.addMessage).toHaveBeenCalledWith(
-      event.roomEvent.roomId,
-      data
-    );
-  });
-});

webclient/src/websocket/events/room/index.ts

@@ -4,10 +4,12 @@ import { joinRoom } from './joinRoom';
 import { leaveRoom } from './leaveRoom';
 import { listGames } from './listGames';
 import { roomSay } from './roomSay';
+import { removeMessages } from './removeMessage';
 
 export const RoomEvents: ProtobufEvents = {
   '.Event_JoinRoom.ext': joinRoom,
   '.Event_LeaveRoom.ext': leaveRoom,
   '.Event_ListGames.ext': listGames,
   '.Event_RoomSay.ext': roomSay,
+  '.Event_RemoveMessages.ext': removeMessages,
 };

webclient/src/websocket/events/room/interfaces.ts

@@ -17,3 +17,8 @@ export interface LeaveRoomData {
 export interface ListGamesData {
   gameList: Game[];
 }
+
+export interface RemoveMessagesData {
+  amount: number;
+  name: string;
+}

webclient/src/websocket/events/room/removeMessage.ts

@@ -0,0 +1,7 @@
+import { RoomPersistence } from '../../persistence';
+import { RemoveMessagesData, RoomEvent } from './interfaces';
+
+export function removeMessages({ name }: RemoveMessagesData, { roomEvent }: RoomEvent) {
+  const { roomId } = roomEvent;
+  RoomPersistence.removeMessages(roomId, name);
+}

webclient/src/websocket/persistence/RoomPersistence.ts

@@ -48,4 +48,8 @@ export class RoomPersistence {
   static userLeft(roomId: number, name: string) {
     RoomsDispatch.userLeft(roomId, name);
   }
+
+  static removeMessages(roomId: number, name: string) {
+    console.log('removeMessages for ' + name + ' in room ' + roomId);
+  }
 }