서버의 많은 부분을 뜯어고침

게임룸 클래스화

GameServer.js

 var GameServer = GameServer || {};
 
 GameServer.Phase = {READY: 0, COUNT: -1, START: 1, MAIN: 2, MUSIC: 3};
-GameServer.startCount = 2;
 
 GameServer.currentPlayer = [];
 GameServer.playingRoom = [];
 
-GameServer.getPlayerNumber = function()
+GameServer.findRoom = function(roomId)
 {
-    do
+    for (let i = 0; i < GameServer.playingRoom.length; i++)
     {
-        var num = Math.floor(Math.random() * 1000 + 1);
-        if (!this.currentPlayer.includes(num)) return num;
-    } while (true)
+        if (GameServer.playingRoom[i].roomId === roomId) return GameServer.playingRoom[i];
+    }
+    console.log('[ERR] no room with num ' + roomId);
 }
-GameServer.findPlayer = function(playerId)
+GameServer.findPlayerSocket = function(playerId)
 {
     var idx = this.currentPlayer.findIndex(function(element)
     {
-        return element.id === playerId;
+        return element.playerData.id === playerId;
     });
     if (idx != -1) return this.currentPlayer[idx];
     else
@@ -27,192 +26,220 @@ GameServer.findPlayer = function(playerId)
         return null;
     }
 }
-GameServer.nextRoomNumber = 0;
-GameServer.makeRoom = function()
+GameServer.enterEmptyRoom = function(playerSocket)
 {
-    // 나중에 room 삭제시 생긴 null에 채워넣는식으로 만들것, 룸의 인덱스를 고정
-    var roomOption = 
-    {
-        roomNum: GameServer.nextRoomNumber++,
-        maxPlayer: 100,
-        nextRank: 100,
-        currentPlayer: [],
-        aliveCount: 0,
-        currentSocket: [],
-        currentPhase: GameServer.Phase.READY,
-        endTime: 0,
-
-        rateArrangePoint: 300,
-        maxTypingPlayer: null,
-        minTypingPlayer: null
-    }
-    this.playingRoom.push(roomOption);
-    console.log('[SERVER] new room #'+roomOption.roomNum+' made, roomCount: ' + this.playingRoom.length);
-    return this.playingRoom.length - 1;
+    let emptyRoomIndex = -1;
+    for (let i = 0; i < this.playingRoom.length; i++)
+    {
+        if ((this.playingRoom[i].currentPhase === this.Phase.READY || this.playingRoom[i].currentPhase === this.Phase.COUNT) && this.playingRoom[i].maxPlayer > this.playingRoom[i].currentPlayer.length)
+        {
+            emptyRoomIndex = i;
+            break;
+        }
+    }
+    if (emptyRoomIndex != -1)
+    {
+        this.playingRoom[emptyRoomIndex].enterRoom(playerSocket);
+    }
+    else
+    {
+        let newRoom = new GameRoom();
+        newRoom.enterRoom(playerSocket);
+    }
 }
-GameServer.findRoomIndex = function(roomNum)
+GameServer.getPlayerNumber = function()
 {
-    return GameServer.playingRoom.findIndex(function(element)
+    do
     {
-        return element.roomNum === roomNum;
-    });
+        var num = Math.floor(Math.random() * 1000 + 1);
+        if (this.currentPlayer.findIndex(function(element)
+        {
+            return element.id === num;
+        }) === -1) return num;
+    } while (true)
+}
+GameServer.getRoomNumber = function()
+{
+    do
+    {
+        var num = Math.floor(Math.random() * 1000 + 1);
+        if (this.playingRoom.findIndex(function(element)
+        {
+            return element.roomId === num;
+        }) === -1) return num;
+    } while (true)
 }
-GameServer.enterRoom = function(roomIdx, playerData)
+
+
+class GameRoom
 {
-    let room = this.playingRoom[roomIdx];
-    let nextIdx = -1;
-    for (let i = 0; i < room.currentPlayer.length; i++)
+    constructor()
     {
-        if (room.currentPlayer[i] === null)
+        this.roomId = GameServer.getRoomNumber();
+        this.roomIndex = -1;
+        this.startCount = 2;
+        this.maxPlayer = 100;
+        this.nextRank = 100;
+
+        this.currentPlayer = [];
+        this.aliveCount = 0;
+        this.currentSocket = [];
+        this.currentPhase = GameServer.Phase.READY;
+        
+        this.countEndTime = 0;
+        this.rateArrangePoint = 300;
+        this.maxTypingPlayer = null;
+        this.minTypingPlayer = null;
+
+        for (let i = 0; i < GameServer.playingRoom.length; i++)
+        {
+            if (GameServer.playingRoom[i] === null)
             {
-            nextIdx = i;
-            break
+                this.roomIndex = i;
+                break;
             }
         }
-    let player = new Player((nextIdx != -1 ? nextIdx : room.currentPlayer.length), playerData);
-
-    if (nextIdx != -1)
+        if (this.roomIndex === -1)
         {
-        room.currentPlayer[nextIdx] = player;
-        room.currentSocket[nextIdx] = playerData;
+            this.roomIndex = GameServer.playingRoom.length;
+            GameServer.playingRoom.push(this);
         }
         else
         {
-        room.currentPlayer.push(player);
-        room.currentSocket.push(playerData);
+            GameServer.playingRoom[this.roomIndex] = this;
+        }
+        console.log('[LOG] new room #'+this.roomId+' made, roomCount: ' + GameServer.playingRoom.length);
     }
-    playerData.playingData = player;
-    playerData.currentRoom = room;
-    room.aliveCount++;
 
-    console.log('[' + playerData.id + '] entered to room #' + room.roomNum);
-    playerData.socketId.emit('enterRoom');
-    if (room.currentPlayer.length >= this.startCount)
+    enterRoom(playerSocket)
     {
-        if (room.currentPhase === this.Phase.READY) // start count
+        let playerInst = new Player(this, playerSocket.playerData);
+        this.currentPlayer.push(playerInst);
+        this.currentSocket.push(playerSocket);
+
+        playerSocket.playerData.playingData = playerInst;
+        playerSocket.playerData.currentRoom = this;
+
+        console.log('[' + playerInst.id + '] entered to room #' + this.roomId);
+        playerSocket.emit('enterRoom');
+
+        this.aliveCount++;
+        if (this.currentPlayer.length >= this.startCount)
         {
-            room.endTime = Date.now() + 15000; // 테스트로 15초로 남겨둠
-            this.announceToRoom(room.roomNum, 'setCount', {isEnable: true, endTime: room.endTime});
-            room.currentPhase = this.Phase.COUNT;
+            if (this.currentPhase === GameServer.Phase.READY)
+            {
+                this.endTime = Date.now() + 1000; // 테스트용 10초
+                this.announceToRoom('setCount', {isEnable: true, endTime: this.endTime, playerCount: this.currentPlayer.length});
+                this.currentPhase = GameServer.Phase.COUNT;
             }
-        else if (room.currentPhase === this.Phase.COUNT) // countinue count
+            else if (this.currentPhase === GameServer.Phase.COUNT)
             {
-            playerData.socketId.emit('setCount', {isEnable: true, endTime: room.endTime});
+                this.announceToRoom('setCount', {isEnable: true, endTime: this.endTime, playerCount: this.currentPlayer.length});
             }
         }
-    else // stop count
+        else
         {
-        this.announceToRoom(room.roomNum, 'setCount', {isEnable: false, endTime: 0});
-        room.currentPhase = this.Phase.READY;
+            this.announceToRoom('setCount', {isEnable: false, endTime: 0, playerCount: this.currentPlayer.length});
+            this.currentPhase = GameServer.Phase.READY;
         }
-    return room;
-}
-GameServer.enterEmptyRoom = function(playerData)
-{
-    var toEnter = -1;
-    for (let i = 0; i < this.playingRoom.length; i++)
+    }
+
+    exitRoom(playerId)
     {
-        if (this.playingRoom[i].currentPlayer.length < this.playingRoom[i].maxPlayer && (this.playingRoom[i].currentPhase == this.Phase.READY || this.playingRoom[i].currentPhase == this.Phase.COUNT))
+        for (let i = 0; i < this.currentPlayer.length; i++)
         {
-            toEnter = i;
-            break;
+            if (this.currentPlayer[i].id === playerId)
+            {
+                for (let j = i+1; j < this.currentPlayer.length; j++)
+                {
+                    this.currentPlayer[i].index--;
                 }
+                this.currentPlayer.splice(i, 1);
+                this.currentSocket.splice(i, 1);
+                this.aliveCount--;
+                return;
             }
-    if (toEnter === -1)
-    {
-        toEnter = this.makeRoom();
         }
-    return this.enterRoom(toEnter, playerData);
-}
-GameServer.startRoom = function(roomIdx)
-{
-    let room = this.playingRoom[roomIdx];
-    room.currentPhase = this.Phase.START;
-    room.maxTypingPlayer = room.currentPlayer[0];
-    room.minTypingPlayer = room.currentPlayer[0];
-    room.currentSocket.forEach(function(element)
+        console.log('[ERR] No player who have ' + playerId);
+        return;
+    }
+    
+    startRoom()
     {
-        if (element != null) element.isReceivable = true;
-    });
-    let syncPlayers = [];
-    room.currentPlayer.forEach(function(element)
+        this.currentPhase = GameServer.Phase.START;
+        this.maxTypingPlayer = this.currentPlayer[0];
+        this.minTypingPlayer = this.currentPlayer[0];
+        this.nextRank = this.currentPlayer.length;
+        this.aliveCount = this.currentPlayer.length;
+        this.currentSocket.forEach(function(element)
         {
-        if (element != null) syncPlayers.push(element);
+            element.playerData.isReceivable = true;
         });
-    room.nextRank = syncPlayers.length;
-    room.aliveCount = syncPlayers.length;
 
-    // sync roomData
         let toSync =
         {
-        roomNum: room.roomNum,
-        players: syncPlayers
+            roomId: this.roomId,
+            players: this.currentPlayer
         };
-    //console.log(toSync);
-    this.announceToRoom(roomIdx, 'syncRoomData', toSync);
+        this.announceToRoom('syncRoomData', toSync);
 
-    console.log('[ROOM#'+room.roomNum+'] Game Start with ' + syncPlayers.length + ' players');
-    this.announceToRoom(roomIdx, 'changePhase', this.Phase.START);
-    this.announceToRoom(roomIdx, 'startGame');
-}
-GameServer.playerDefeat = function(playerData)
-{
-    playerData.playingData.isAlive = false;
-    playerData.playingData.rank = playerData.currentRoom.nextRank--;
-    playerData.isReceivable = false;
-    playerData.currentRoom.aliveCount--;
-    if (playerData.playingData.lastAttacks.length > 0)
-    {
-        playerData.playingData.lastAttack = playerData.playingData.lastAttacks[playerData.playingData.lastAttacks.length - 1];
-        if (Date.now() - playerData.playingData.lastAttack.time > 40000) playerData.playingData.lastAttack = null;
+        console.log('[ROOM#'+this.roomId+'] Game Start with ' + this.currentPlayer.length + ' players');
+        this.announceToRoom('changePhase', GameServer.Phase.START);
+        this.announceToRoom('startGame');
+    }
+
+    endRoom()
+    {
+
+    }
+
+    destroyRoom()
+    {
+        if (this.aliveCount > 0)
+        {
+            console.log('[ERR] can not destroy room#' + this.roomId + ', cause player left');
+        }
         else
         {
-            playerData.playingData.lastAttacks.forEach(function(element)
+            let idx = GameServer.playingRoom.findIndex(function(element)
             {
-                if (Date.now() - element.time < 40000 && element.wordGrade > playerData.playingData.lastAttack.wordGrade) playerData.playingData.lastAttack = element;
+                return element.roomId === this.roomId;
             });
+            if (idx != -1)
+            {
+                GameServer.playingRoom[idx] = null;
+            }
         }
     }
 
-    GameServer.announceToRoom(this.findRoomIndex(playerData.currentRoom.roomNum), 'defeat', playerData.playingData);
-    console.log('['+playerData.id+']'+ ' defeated, rank: ' + playerData.playingData.rank);
-
-    if (playerData.currentRoom.aliveCount === 1)
+    announceToRoom(_message, _data = null)
     {
-        let winner = playerData.currentRoom.currentPlayer.find(function(element)
+        this.currentSocket.forEach(function(element)
         {
-            return element != null && element.isAlive;
+            element.emit(_message, _data);
         });
-        GameServer.announceToRoom(this.findRoomIndex(playerData.currentRoom.roomNum), 'gameEnd', winner);
-        GameServer.announceToTarget(this.findRoomIndex(playerData.currentRoom.roomNum), winner.id, 'alert', 'gameWin');
-        console.log('['+winner.id+']' + ' winner! ' + winner.nickname);
     }
-}
-GameServer.announceToRoom = function(roomIdx, _message, _data = null)
-{
-    this.playingRoom[roomIdx].currentSocket.forEach(function(element) 
+
+    announceToTarget(targetId, _message, _data = null)
     {
-        if (element != null) element.socketId.emit(_message, _data);
-    });
-}
-GameServer.announceToTarget = function(roomIdx, targetNum, _message, _data = null)
-{
-    let targetSocket = this.playingRoom[roomIdx].currentSocket.find(function(element)
+        let targetSocketIndex = this.currentSocket.findIndex(function(element)
         {
-        return (element != null && element.id === targetNum);
+            return element.playerData.id === targetId;
         });
-    if (targetSocket != undefined && targetSocket.isReceivable) targetSocket.socketId.emit(_message, _data);
+        //console.log('send to ' + targetSocketIndex + ', receivable? ' + this.currentSocket[targetSocketIndex].playerData.isReceivable);
+        if (this.currentSocket[targetSocketIndex].playerData.isReceivable) this.currentSocket[targetSocketIndex].emit(_message, _data);
+    }
 }
-// 데이터 동기화 함수 만들기
-// 동기화할것: 유저리스트(id - nickname 쌍)
 
 class Player
 {
-    constructor(index, playerData)
+    constructor(gameRoom, playerData)
     {
-        this.index = index;
         this.id = playerData.id;
+        this.gameRoomId = gameRoom.roomId;
+        this.index = gameRoom.currentPlayer.length;
         this.nickname = playerData.nickname;
+
         this.isAlive = true;
         this.rank = -1;
 
@@ -220,6 +247,45 @@ class Player
         this.lastAttacks = []; // { attackerId, word, wordGrade, time }
         this.lastAttack = null;
     }
+
+    defeat()
+    {
+        let player = this;
+        let room = GameServer.findRoom(this.gameRoomId);
+        let socket = GameServer.findPlayerSocket(this.id);
+
+        this.isAlive = false;
+        this.rank = room.nextRank--;
+        socket.playerData.isReceivable = false;
+        room.aliveCount--;
+
+        if (this.lastAttacks.length > 0)
+        {
+            this.lastAttack = this.lastAttacks[this.lastAttacks.length - 1];
+            if (Date.now() - this.lastAttack.time > 40000) this.lastAttack = null;
+            else
+            {
+                this.lastAttacks.forEach(function(element)
+                {
+                    if (Date.now() - element.time < 40000 && element.wordGrade > player.lastAttack.wordGrade) player.lastAttack = element;
+                });
+            }
+        }
+
+        room.announceToRoom('defeat', this);
+        console.log('[' + this.id + '] defeated, rank: ' + this.rank);
+
+        if (socket.playerData.currentRoom.aliveCount === 1)
+        {
+            let winner = room.currentPlayer.find(function(element)
+            {
+                return element.isAlive;
+            });
+            room.announceToRoom('gameEnd', winner);
+            room.announceToTarget(winner.id, 'alert', 'gameWin');
+            console.log('['+winner.id+']' + ' winner! ' + winner.nickname);
+        }
+    }
 }
 
 module.exports = GameServer;
\ No newline at end of file

js/Client.js

@@ -14,7 +14,7 @@ socket.on('alert', function(msg) // string errorcode
 socket.on('setId', function(msg) // {str, num playerNum}
 {
     console.log(msg.str);
-    PlayerData.idNum = msg.num;
+    PlayerData.id = msg.num;
 });
 socket.on('enterRoom', function()
 {
@@ -26,15 +26,24 @@ socket.on('setCount', function(msg)
 {
     ScenesData.roomScene.isCounting = msg.isEnable;
     ScenesData.roomScene.endTime = msg.endTime;
+    ScenesData.roomScene.peopleCount = msg.playerCount;
 });
 
 // init game
 socket.on('syncRoomData', function(msg) // {num roomNum, [] players}
 {
-    console.log(msg);
-    RoomData.roomNum = msg.roomNum;
+    //console.log(msg);
+    RoomData.roomId = msg.roomId;
     RoomData.players = msg.players;
     RoomData.aliveCount = msg.players.length;
+    RoomData.players.forEach(function(element)
+    {
+        if(element.id === PlayerData.id)
+        {
+            RoomData.myself = element;
+            return;
+        }
+    });
 });
 socket.on('startGame', function()
 {
@@ -55,6 +64,7 @@ socket.on('setPlayerTypingRate', function(msg) // number playerTypingRate
 });
 socket.on('attacked', function(msg) // object attackData
 {
+    //console.log('attacked by ' + msg.attacker.nickname);
     setTimeout(function()
     {
         WordSpace.generateWord.Attack(ScenesData.gameScene, msg.text, msg.grade, msg.attacker, msg.isStrong);

js/ScenesData.js

@@ -61,6 +61,7 @@ var roomScene = new Phaser.Class(
             this.countText.setText(((this.endTime - Date.now()) / 1000).toFixed(1));
             if (this.endTime - Date.now() < 0) 
             {
+                //console.log('end Count');
                 socket.emit('endCount');
                 this.isCounting = false;
             }
@@ -119,14 +120,8 @@ var gameScene = new Phaser.Class(
 
         WordSpace.nameWordTextForTest = ScenesData.gameScene.add.text(50,400,'현재 가진 호패들 : 없음').setDepth(10).setColor('#000000');
         WordSpace.nameQueue.initiate();
-        RoomData.players.forEach(function(element)
-        {
-            if(element.nickname == PlayerData.nickname)
-            {
-                RoomData.myself = element;
-                return;
-            }
-        });
+
+        // for test
         WordSpace.attackGauge.add(11);
     },
 

js/WordSpace.js

@@ -394,7 +394,7 @@ WordSpace.findWord = function(wordText)
                 console.log('Attack word : ' + element.wordText + ' of ' + element.attacker.nickname + ' 오타임');
                 let victimData = 
                 {
-                    roomNum: RoomData.roomNum,
+                    roomNum: RoomData.roomId,
                     victim: RoomData.myself, 
                     target: element.attacker.id
                 }
@@ -431,9 +431,10 @@ WordSpace.attack = function(wordText, grade)
         console.log('attack ' + wordText + ', grade: ' + grade);
         WordSpace.nameGroup.forEach(function(element)
         {
+            //console.log(RoomData.myself);
             let attackData = 
             {
-                roomNum: RoomData.roomNum,
+                roomNum: RoomData.roomId,
                 attacker: RoomData.myself, 
                 target: element.ownerId,
                 text: wordText, 
@@ -474,7 +475,7 @@ WordSpace.nameQueue =
         }
         tempQueue.forEach(function(element)
         {
-            if(element.id != PlayerData.idNum && element.isAlive)
+            if(element.id != PlayerData.id && element.isAlive)
                 WordSpace.nameQueue.queue.push(element);
         });
     },

js/main.js

@@ -23,13 +23,13 @@ var game = new Phaser.Game(config)
 //테스트용이므로 차후 수정 요망
 var PlayerData = PlayerData || {};
 
-PlayerData.idNum = -1; //플레이어 아이디, 고유 번호
+PlayerData.id = -1; //플레이어 아이디, 고유 번호
 PlayerData.nickname = '홍길동'; //플레이어 닉네임
 
 // 현재 들어가있는 Game Room의 정보
 var RoomData = RoomData || {};
 
-RoomData.roomNum = -1;
+RoomData.roomId = -1;
 RoomData.myself = null;
 RoomData.players = null;
 RoomData.aliveCount = -1;
\ No newline at end of file

server.js

@@ -25,12 +25,11 @@ io.on('connection', function(socket)
         {
             id: GameServer.getPlayerNumber(),
             nickname: '게스트',
-            socketId: socket,
             currentRoom: null,
             playingData: null,
             isReceivable: false
         };
-        GameServer.currentPlayer.push(socket.playerData);
+        GameServer.currentPlayer.push(socket);
         console.log('['+socket.playerData.id+'] client request');
         socket.emit('setId', 
         {
@@ -44,14 +43,14 @@ io.on('connection', function(socket)
         let isAlreadyHave = false;
         GameServer.currentPlayer.forEach(function(element)
         {
-            if (element.nickname === msg) isAlreadyHave = true;
+            if (element.playerData.nickname === msg) isAlreadyHave = true;
         });
         if (isAlreadyHave) socket.emit('alert' ,'errNicknameOverlaped');
         else
         {
             socket.playerData.nickname = msg;
             console.log('['+socket.playerData.id+'] nickname set to ' + msg);
-            GameServer.enterEmptyRoom(socket.playerData);
+            GameServer.enterEmptyRoom(socket);
         }
     });
 
@@ -76,15 +75,15 @@ io.on('connection', function(socket)
         socket.playerData.currentRoom.aliveCount--;
         if (socket.playerData.currentRoom.aliveCount === 0)
         {
-            GameServer.startRoom(GameServer.findRoomIndex(socket.playerData.currentRoom.roomNum));
+            socket.playerData.currentRoom.startRoom();
         }
     });
 
     socket.on('attack', function(msg)
     {
-        GameServer.announceToTarget(GameServer.findRoomIndex(msg.roomNum), msg.target, 'attacked', msg);
-        //console.log('find ' + msg.target + ' by ' + msg.attacker.idNum + ' with ' + msg.text);
-        let target = GameServer.findPlayer(msg.target);
+        socket.playerData.currentRoom.announceToTarget(msg.target, 'attacked', msg);
+        //console.log('attack ' + msg.target + ' by ' + msg.attacker.id + ' with ' + msg.text);
+        let target = GameServer.findPlayerSocket(msg.target);
         if (target != null)
         {
             let dataToPush = 
@@ -96,23 +95,23 @@ io.on('connection', function(socket)
                 time: Date.now()
             }
 
-            if (target.playingData.lastAttacks.length < 5) target.playingData.lastAttacks.push(dataToPush);
+            if (target.playerData.playingData.lastAttacks.length < 5) target.playerData.playingData.lastAttacks.push(dataToPush);
             else
             {
-                target.playingData.lastAttacks.splice(0, 1);
-                target.playingData.lastAttacks.push(dataToPush);
+                target.playerData.playingData.lastAttacks.splice(0, 1);
+                target.playerData.playingData.lastAttacks.push(dataToPush);
             }
         }
     });
 
     socket.on('defeated', function()
     {
-        GameServer.playerDefeat(socket.playerData);
+        socket.playerData.playingData.defeat();
     });
 
     socket.on('defenseFailed', function(msg)
     {
-        GameServer.announceToTarget(GameServer.findRoomIndex(msg.roomNum), msg.target, 'attackSucceed', msg);
+        socket.playerData.currentRoom.announceToTarget(msg.target, 'attackSucceed', msg);
     });
 
     socket.on('disconnect', function(reason)
@@ -128,31 +127,30 @@ io.on('connection', function(socket)
             console.log('['+ data.id +'] client disconnected, reason: ' + reason);
             let idxToDel = GameServer.currentPlayer.findIndex(function(element)
             {
-                return element.id === data.id;
+                return element.playerData.id === data.id;
             });
             if (idxToDel != -1) 
             {
-                GameServer.currentPlayer.splice(idxToDel, 1);
                 // 룸에서도 제거
                 if (data.currentRoom != null)
                 {
                     if (data.currentRoom.currentPhase === GameServer.Phase.READY || data.currentRoom.currentPhase === GameServer.Phase.COUNT)
                     {
-                        data.currentRoom.currentPlayer[data.playingData.index] = null;
-                        data.currentRoom.currentSocket[data.playingData.index] = null;
-                        data.currentRoom.aliveCount--;
+                        data.currentRoom.exitRoom(data.id);
                         if (data.currentRoom.aliveCount < GameServer.startCount)
                         {
-                            GameServer.announceToRoom(GameServer.findRoomIndex(data.currentRoom.roomNum), 'setCount', {isEnable: false, endTime: 0});
+                            data.currentRoom.announceToRoom('setCount', {isEnable: false, endTime: 0, playerCount: data.currentRoom.currentPlayer.length});
                             data.currentRoom.currentPhase = GameServer.Phase.READY;
                         }
+                        else data.currentRoom.announceToRoom('setCount', {isEnable: true, endTime: data.currentRoom.endTime, playerCount: data.currentRoom.currentPlayer.length});
                     }
                     else if (data.playingData.isAlive)
                     {
-                        GameServer.playerDefeat(socket.playerData);
-                        GameServer.announceToRoom(GameServer.findRoomIndex(data.currentRoom.roomNum), 'userDisconnect', data.playingData);
+                        data.playingData.defeat();
+                        data.currentRoom.announceToRoom('userDisconnect', data.playingData);
                     }
                 }
+                GameServer.currentPlayer.splice(idxToDel, 1);
             }
             console.log('['+ data.id +'] disconnect complete');
         }