spec added; card function 1, 2, 3, 4 modified

card.py

@@ -1,5 +1,7 @@
 import random
 import game
+from room import Room
+from json import dumps
 
 cards = dict()
 card_name = ["1.攻擊","2.防禦","3.治癒","4.補給","5.強奪","6.奇襲","7.交易","8.洞悉","9.妙策","10.掃射","11.加護","12.劇毒","13.詛咒","14.反制","15.狂亂","16.逆轉"]
@@ -9,20 +11,37 @@ for i in range(len(card_name)):
     cards[str(i+1)] = card_name[i] # initialize cards
 # create default deck
 # 攻擊*15 防禦*15 治癒*15 補給*10 強奪*10 奇襲*10 交易*10 洞悉*5 妙策*5 掃射*5 加護*5 劇毒*2 詛咒*2 反制*2 狂亂*2 逆轉*2
-default_deck = ['1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4', '4', '4', '4', '4', '4', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '8', '8', '8', '8', '8', '9', '9', '9', '9', '9', '10', '10', '10', '10', '10', '11', '11', '11', '11', '11', '12', '12', '13', '13', '14', '14', '15', '15', '16', '16']
+#default_deck = ['1', '2', '3'] * 5 + ['4', '5', '6', '7'] * 3 + ['8', '9', '10', '11'] * 2 + ['12', '13', '14', '15', '16']
+default_deck = ['3', '4', '2', '1']*15
 random.shuffle(default_deck) # wash
 
 # card functions
 # cur:current player
 # ene:enemy
-def attack(cur,ene):
+
+def attack(wscur, wsene):
+    cur, ene = wscur.player, wsene.player
     cur.attacking = True
+
+    r = []
+    
     cur.damage = 2 # 給反制判斷的
-    print("{} 攻擊 {}".format(cur.name,ene.name))
+    r.append(( (wscur, ), dumps({"msg": "attack", "data": [cur.name, ene.name]})))
     if ene.defence():
-        game.display(ene) # 顯示手牌
+        r.append(( (wsene, ),
-        while True:
+            dumps({"msg": "attack", "data": [cur.name, ene.name], 
-            choice = input("請問要防禦嗎? 不使用請輸入0 ")
+		    "action": "toDefend", "value": {"damage": cur.damage}})
+        ))
+        cur.status = Room.NOTHING
+        ene.status = Room.DEFENCE
+    else:
+        r.append(( (wsene, wscur),
+            dumps({"msg": "damaged", "data": [ene.name, cur.damage]})
+        ))
+        ene.life -= cur.damage
+        cur.attacking = False
+        cur.damage = 0 # reset
+        """
             if choice in ene.hand:
                 if choice in unattackable:
                     skills[choice](cur,ene)
@@ -36,25 +55,41 @@ def attack(cur,ene):
         print("{} 受到{}點傷害".format(ene.name,cur.damage))
         ene.life -= cur.damage
     cur.attacking = False
-    cur.damage = 0 # reset
+    cur.damage = 0 # reset"""
+    return r
 
-def defend(cur,ene):
+def defend(wscur,wsene): # cur是用卡方
-    if cur.attacking or cur.surprise:
+    cur, ene = wscur.player, wsene.player
-        print("{} 防禦成功".format(ene.name))
+    r = []
+    if ene.attacking or ene.surprise:
+        r.append(( (wsene,wscur), "{} 防禦成功".format(cur.name)))
+        
     else:
-        print("{} 沒什麼可以防禦的，回復一點生命".format(cur.name))
+        r.append(( (wsene,wscur), "{} 沒什麼可以防禦的，回復一點生命".format(cur.name)))
+
         cur.life += 1
+    return r
 
-def heal(cur,ene):
+def heal(wscur,wsene):
-    print("{} 回復兩點生命".format(cur.name))
+    cur, ene = wscur.player, wsene.player
+    r = []
+    r.append(( (wsene,wscur), dumps({"msg": "heal", "data": [cur.name]})))
     cur.life += 2
+    return r
+
+def supply(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    r = []
+    r.append(( (wsene,wscur), dumps({"msg": "supply", "data": [cur.name]})))
 
-def supply(cur,ene):
-    print("{} 增加兩張手牌".format(cur.name))
     for _ in range(2):
         game.draw(cur)
 
-def rob(cur,ene):
+    return r
+
+def rob(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     cur.robbing = True
     print("{} 正在對 {} 行搶".format(cur.name,ene.name))
     if ene.keep():
@@ -74,14 +109,16 @@ def rob(cur,ene):
         else:
             game.display(ene)
             while True:
-                swag = input("{} 要搶哪張? ".format(cur.name))
+                swag = input("{} 要搶哪張?".format(cur.name))
                 if swag in ene.hand:
                     ene.robbed(swag)
                     cur.add_card(swag)
                     break
     cur.robbing = False
 
-def surprise(cur,ene):
+def surprise(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     cur.surprise = True
     cur.damage = 1 # 給反制判斷
     print("{} 發動奇襲".format(cur.name))
@@ -108,7 +145,9 @@ def surprise(cur,ene):
     cur.surprise = False
     cur.damage = 0 # reset
 
-def trade(cur,ene):
+def trade(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     print("{} 想與 {} 進行交易".format(cur.name,ene.name))
     cur.remove_card("7") # you can't trade the using card "trade"
     game.display(cur) # 顯示手牌
@@ -138,7 +177,9 @@ def trade(cur,ene):
 
     cur.add_card("7") # add back the card. game system will remove this card right away
 
-def aware(cur,ene):
+def aware(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     if cur.attacking:
         print("{} 洞悉了 {} 的攻擊，並抽取了一張手牌".format(ene.name,cur.name))
         game.draw(ene)
@@ -153,7 +194,9 @@ def aware(cur,ene):
             print("{} 增加三張手牌".format(cur.name))
             game.draw(cur)
 
-def plan(cur,ene):
+def plan(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     print("{} 有個妙策".format(cur.name))
     options = random.sample(cur.deck,3)
     o_name = [] # names of cards in options
@@ -166,7 +209,9 @@ def plan(cur,ene):
             cur.add_card(choice)
             break
 
-def sweep(cur,ene):
+def sweep(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     cur.attacking = True
     cur.damage = random.randint(0,5)
     print("{} 對 {} 進行掃射，威力是 {}".format(cur.name,ene.name,cur.damage))
@@ -189,14 +234,20 @@ def sweep(cur,ene):
     cur.attacking = False
     cur.damage = 0 # reset
 
-def bless(cur,ene):
+
+def bless(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     print("{} 獲得加護，身上的毒素一掃而空，並回復三點生命，還抽取了兩張手牌".format(cur.name))
     cur.poison = 0 # 解毒
     cur.life += 3
     for _ in range(2):
         game.draw(cur)
 
-def poison(cur,ene):
+
+def poison(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     if ene.poison != 0:
         s = "又"
     else:
@@ -204,13 +255,17 @@ def poison(cur,ene):
     print("{} 在食物下毒，{} {}中毒了".format(cur.name,ene.name, s))
     ene.poison += 1
 
-def curse(cur,ene):
+def curse(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     print("{} 詛咒了 {}，使其損失四點生命，並掉了一張手牌".format(cur.name,ene.name))
     ene.life -= 4
     drop = random.choice(ene.hand)
     ene.remove_card(drop)
 
-def counter(cur,ene):
+def counter(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     if cur.attacking:
         print("{} 反制了 {} 的攻擊，反彈了{}點傷害".format(ene.name,cur.name,cur.damage))
         cur.life -= cur.damage
@@ -223,12 +278,16 @@ def counter(cur,ene):
         print("{} 反制了敵手，使 {} 生命值減半了!".format(cur.name,ene.name))
         ene.life = ene.life//2
 
-def chaos(cur,ene):
+def chaos(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     print("{} 進入狂亂模式，回復三點生命，並對 {} 造成三點傷害".format(cur.name,ene.name))
     cur.life += 3
     ene.life -= 3
-
+    
-def reverse(cur,ene):
+def reverse(wscur,wsene):
+    cur, ene = wscur.player, wsene.player
+    
     print("{} 一口氣逆轉了情勢".format(cur.name))
     cur.life,ene.life = ene.life,cur.life
 

game.py

@@ -1,5 +1,7 @@
 import random
 import card
+from room import sendTo
+from json import dumps
 
 class Player:
     def __init__(self,name,deck):
@@ -52,56 +54,56 @@ class Player:
         self.life = 0
 
 # game functions
+
+
 def health(p1,p2):
-    print("{} 的生命: {}".format(p1.name,p1.life))
+    return "{} 的生命: {}\n{} 的生命: {}".format(p1.name,p1.life, p2.name, p2.life)
-    print("{} 的生命: {}".format(p2.name,p2.life))
 
 def display(player):
-    print("這是 {} 的手牌".format(player.name))
+    return "這是 {} 的手牌\n{}".format(player.name, player.display)
-    print(player.display)
 
 def draw(player): # 抽卡
     if len(player.deck) == 0:
         player.life = -99999999 # 牌抽乾了就讓他死
-        print("你抽到了死神")
+        return dumps({"msg": "noCard", "data": [player.name]})
-        return None
+    new = random.choice(player.deck) 
-    new = random.choice(player.deck)
-    print("{} 抽到了 {}".format(player.name,card.cards[new]))
     player.add_card(new)
-    print("牌組剩餘: {} 張".format(len(player.deck)))
+    
-
+    return dumps({"msg": "draw", "data": [player.name, new]})
 # turn control
 # cur:current player
 # ene:enemy
-def turn(p1,p2):
+async def turn(wsp1,wsp2):
-    if p1.playing == True:
+    p1, p2 = wsp1.player, wsp2.player
-        cur = p1
+    wscur, wsene = (wsp1, wsp2) if p1.playing == True else (wsp2, wsp1)
-        ene = p2
+
-    elif p2.playing == True:
+    cur, ene = wscur.player, wsene.player
-        cur = p2
+    
-        ene = p1
     cur.turn += 1
-    print("") # change line
+    
-    print("{} 的第{}回合".format(cur.name,cur.turn))
+    await wscur.send("{} 的第{}回合".format(cur.name,cur.turn))
     if cur.poison_check():
-        print("{} 受到了劇毒的侵蝕".format(cur.name))
+        await wscur.send("{} 受到了劇毒的侵蝕".format(cur.name))
-        print("{} 損失{}點生命".format(cur.name,cur.poison))
+        await wscur.send("{} 損失{}點生命".format(cur.name,cur.poison))
     if cur.life <= 0:
         return
-    health(p1,p2)
+    await sendTo(health(p1,p2), wsp1, wsp2)
-    draw(cur) # 抽卡
+    await sendTo(draw(cur), wsp1, wsp2) # 抽卡
-    display(cur) # 顯示手牌
+    await sendTo(display(cur), wscur) # 顯示手牌
     while True:
-        choice = input("請問要使用手牌嗎? 若不使用請輸入0 ")
+        await sendTo("請問要使用手牌嗎? 若不使用請輸入0", wscur)
+        print("Wait receive")
+        choice = await wscur.recv()
+        print("Received")
         if choice in cur.hand:
-            card.skills[choice](cur,ene)
+            card.skills[choice](wscur, wsene)
             cur.remove_card(choice)
             break
         elif choice == "0":
             break
         elif choice == "-1":
             cur.surrender()
-            print("{}投降".format(cur.name))
+            await sendTo("{}投降".format(cur.name), wsp1, wsp2)
             break
         del choice # prevent reading old data
     p1.playing,p2.playing = p2.playing,p1.playing # switch!

pyws.py

@@ -6,73 +6,157 @@ import asyncio
 import datetime
 import random
 import websockets
-       
+from json import dumps, loads 
 
 connected = {-1: []}
 character = dict()
 name=["安","圭月","梅","小兔","銀","正作","W","桑德","海爾","雪村"]
 
 for i in range(len(name)):
-	character[str(i+1)] = name[i] 
+    character[str(i+1)] = name[i] 
 
+
+sad = None
+fut = None
+async def wait(websocket, *cors, timeout=45, futs=None):
+    if futs != None:
+        fut_cor = futs
+    else:
+        fut_cor = [cor() for cor in cors]
+    done, pending = await asyncio.wait(fut_cor,
+                                       return_when=asyncio.FIRST_EXCEPTION, timeout=timeout)
+    #print(done, pending)
+    if pending:
+        #print("coroutine doesn't finish its work")
+        pass
+    if len(done):
+        return list(done)[0].result()
+    else:
+        #print("SADDDDD")
+        return
+def random_room():
+    global connected, rooms
+    try:
+        print(rooms)
+    except:
+        rooms = list(connected)
+        rooms.remove(-1)
+    print(rooms)
+    while len(rooms)>=1:
+            enter = random.choice(rooms)
+            print("rooms", enter, rooms)
+            rooms.remove(enter)
+            if len(connected[enter]) < 2:
+                return enter
+    while 1:
+        enter = random.randint(1, 99999)
+        if enter not in connected:
+            rooms.append(enter)
+            return enter
+            
+        
+    
+async def enter_room(websocket):
+    global connected ,sad, fut
+    
+    room_list = [room_id for room_id in connected if len(connected[room_id])<2 and room_id != -1]
+    #print("I'm here")
+    await websocket.send(str(room_list))
+    #print("In enter_room, SAD")
+            
+    message = await wait(websocket, websocket.recv)
+    if message == "n":
+        room_id = random_room()
+    else:
+        room_id = int(message)
+
+    connected[room_id] = connected.get(room_id, Room(room_id))
+
+                    
+    count = len(connected[room_id])
+    print(count)
+                    
+    if count <= 1: # Enter the room
+        connected[room_id].player_add(websocket)
+        connected[-1].remove(websocket)
+
+        websocket.room = room_id
+        websocket.status = Room.WAITING
+                
+        if count+1 == 1: # 該玩家已加入房間
+            await websocket.send(str(room_id))
+            sad = websocket
+        else:
+            players = connected[websocket.room].start()
+            
+            for ws in connected[room_id]:
+                ws.status = Room.PLAYING
+                wsene = connected[room_id].players[0] if connected[room_id].players[1] is websocket else connected[room_id].players[1]
+                await ws.send(dumps({"room": room_id, "cur": websocket.player.name, "ene": wsene.player.name}))
+                await ws.send(dumps({"msg": "firstAttack", "data": [players[0].player.name], "hand": ws.player.hand}))
+    
+            fut.cancel()
+            for ws_list, message in Room.start_turn(*players):
+                    await sendTo(message, *ws_list)
 async def handler(websocket, path):
-    global connected
+    global connected,sad, fut
     # Register.
     connected[-1].append(websocket)
     websocket.status = Room.CONNECTED
+
+    # CHOOSE CHARACTER
     await websocket.send("CHOOSE CHARACTER")
+    try:
+        choice = await wait(websocket, websocket.recv)
+        if int(choice) not in range(1, len(name)+1):
+            raise ValueError("Wrong input, close the connection...")
+        websocket.player = game.Player(name[int(choice)-1], card.default_deck)
+            
+        websocket.status = Room.MATCHING
+    except:
+        return # close the connection
+
+    
+    
     try:
         # Implement logic here.
-        while 1:
-            message = await websocket.recv()
-            if websocket.status == Room.CONNECTED: # choose character
-                choice = message
-                while choice not in map(lambda x : str(x+1),list(range(len(name)))):
-                    await websocket.send("CHOOSE")
-                    await websocket.send("CHOOSE: "+ str(choice) + "\n" + str(list(range(len(name)))))
-                    choice = await websocket.recv()
-                p_name = character[choice]
-                await websocket.send("PLAYER "+p_name)
-                websocket.player = game.Player(p_name,card.default_deck)
-                
-                websocket.status = Room.MATCHING
-
-            elif websocket.status == Room.MATCHING: 
-                try:
-                    room_id = int(message)
-                    connected[room_id] = connected.get(room_id, Room(room_id))
-                    
-                    count = connected[room_id].count()
-                    
-                    if count <= 1: # Enter the room
-                        connected[room_id].player_add(websocket)
-                        connected[-1].remove(websocket)
-                        await websocket.send("You have entered room "+ str(connected[room_id]))
-                        websocket.room = room_id
-                        
-                        if count+1 == 1: # 該玩家已加入房間
-                            await websocket.send("Waiting for another player...")
-                        else:
-                            for ws in connected[room_id]:
-                                ws.status = Room.PLAYING
-                                await ws.send("The game will start soon.....")
-                            # await connected[room_id].start()
-                            # Testing
-
-                    else: # Can't enter the room
-                        await websocket.send("SAD, This room is full. Please enter another room.")
-                except Exception as e:
-                    print(e)
-                print("STATUS = MATCHING")
-            elif websocket.status == Room.PLAYING:
-                print("STATUS = PLAYING, message got")
-                for ws in connected[websocket.room]:
-                    await ws.send("STARTING... But unfortunately, we haven't completed this part of code.")
-                print("STATUS = PLAYING, message sent")
         
+        while 1:
+            #message = await wait(websocket, websocket.recv, timeout=10)
+            
+            if websocket.status == Room.MATCHING:
+                await enter_room(websocket)
+            elif websocket.status == Room.WAITING:
+                print("SAD", "FIRST" if websocket == sad else "SECOND")
+                
+                fut = asyncio.ensure_future(websocket.recv())
+                try:
+                    message = await wait(websocket, timeout=100000, futs=[fut])
+                    if message == "e":
+                        connected[websocket.room].player_delete(websocket)
+                        
+                        await websocket.send("You have left Room "+str(connected[websocket.room]))
+                        del websocket.room
+                        connected[-1].append(websocket)
+                        websocket.status = Room.MATCHING
+                except asyncio.CancelledError:
+                    pass
+                print("SADDDDDD", "FIRST" if websocket == sad else "SECOND")
+                
+            elif websocket.status == Room.PLAYING:
+                print("wait for message", "FIRST" if websocket == sad else "SECOND")
+                message = await wait(websocket, websocket.recv, timeout=100000)
+                print("received message", "FIRST" if websocket == sad else "SECOND")
+
+                message_to_send = connected[websocket.room].process(websocket, message)
+                for ws_list, message in message_to_send:
+                    await sendTo(message, *ws_list)
     finally:
         # Unregister.
-        connected[websocket.room].player_delete(websocket)
+        try:
+            connected[websocket.room].player_delete(websocket)
+        except:
+            connected[-1].remove(websocket)
         print(connected)
 
         

room.py

@@ -1,55 +1,178 @@
-import game
+import game, card
-import random
+import random
-  
+from json import dumps, loads
-class Room:
+  
-    CONNECTED = 0
+class Room:
-    MATCHING = 1
+    CONNECTED = 0
-    PLAYING = 2
+    MATCHING = 1
-    WAITING = -1
+    PLAYING = 2
-    def __init__(self, room, players=[]):
+    WAITING = -1
-        self.room = room
+
-        self.players = players
+    # Player Status Definition
-        
+    NOTHING = -1
-    def __repr__(self):
+    IN_TURN = 0
-        return "ROOM {}, {} player(s)".format(str(self.room), len(self.players))
+    ROBBED = 1
-
+    DEFENCE = 2
-    def __iter__(self):
+    ROBBING = 3
-        return iter(self.players)
+    TRADE = 4
-    
+    PLAN = 5
-    def player_add(self, player):
+    def __init__(self, room):
-        if self.count() >= 2:
+        self.room = room
-            return
+        self.players = []
-        self.players.append(player)
+
-        
+        
-    def player_delete(self, player):
+    def __len__(self):
-        try:
+        return len(self.players)
-            self.players.remove(player)
+    
-        except:
+    def __repr__(self):
-            pass
+        return "ROOM {}, {} player(s)".format(str(self.room), len(self))
-        
+
-    def count(self):
+    def __iter__(self):
-        return len(self.players)
+        return iter(self.players)
-        
+    
-    async def start(self):
+    def player_add(self, player):
-        p1, p2 = self.players[0].player, self.players[1].player
+        if len(self) >= 2:
-        first = random.choice([p1, p2])
+            return
-        print(first, p1, p2)
+        self.players.append(player)
-        first.playing = True # so the first one will be random
+        
-        await sendTo(first.name + "先攻", *self.players)
+    def player_delete(self, player):
-        print(first.name,"先攻")
+        try:
-        print() # change line
+            self.players.remove(player)
-        for _ in range(3): # 初始手牌*3
+        except:
-            game.draw(p1)
+            pass
-            game.draw(p2)
+        
-
+    
-        while p1.life > 0 and p2.life > 0:
+        
-            await game.turn(self.players[0], self.players[1])
+    """async def start(self):
-
+        p1, p2 = self.players[0].player, self.players[1].player
-        if p1.life <= 0:
+        first = random.choice([p1, p2])
-            print("{} 獲勝".format(p2.name))
+        print(first, p1, p2)
-        elif p2.life <= 0:
+        first.playing = True # so the first one will be random
-            print("{} 獲勝".format(p1.name))
+        await sendTo(first.name + "先攻", *self.players)
-
+        print(first.name,"先攻")
-async def sendTo(message, *ws_list):
+        print() # change line
-        for ws in ws_list:
+        for _ in range(3): # 初始手牌*3
-            await ws.send(message)
+            game.draw(p1)
+            game.draw(p2)
+
+        while p1.life > 0 and p2.life > 0:
+            print("game.turn start")                
+            await game.turn(self.players[0], self.players[1])
+            print("game.turn end")
+        if p1.life <= 0:
+            print("{} 獲勝".format(p2.name))
+        elif p2.life <= 0:
+            print("{} 獲勝".format(p1.name))"""
+    def start(self): # initialize the game
+        p1, p2 = self.players[0].player, self.players[1].player
+        ws_list = self.players[:]
+        
+        firstws = ws_list.pop(random.randint(0, 1))
+        #print(first, p1, p2)
+        firstws.player.playing = True # so the first one will be random
+        #await sendTo(first.player.name + "先攻", *self.players)
+        
+        print(firstws.player.name,"先攻")
+        print() # change line
+        for _ in range(3): # 初始手牌*3
+            game.draw(p1)
+            game.draw(p2)
+        return firstws, ws_list[0] # it will be second player
+    @staticmethod
+    def start_turn(wscur, wsene):
+        cur, ene = wscur.player, wsene.player
+        
+        message_to_send = []
+        
+        cur.playing, ene.playing = ene.playing, cur.playing
+        
+        cur.turn += 1
+        
+        message_to_send.append(( (wscur,), game.draw(cur)))
+        message_to_send.append(( (wscur,), 
+            dumps({"player": {
+                        "turn": cur.turn, "hand": cur.hand, "deck_left": len(cur.deck),
+			"life": cur.life
+                    }
+                }
+            )
+        ))
+
+        message_to_send.append(( (wsene,), 
+            dumps({"enemy": {
+                        "turn": cur.turn, "deck_left": len(cur.deck),
+			"life": cur.life # cur為當前回合之玩家，故此處仍為cur
+                    }
+                }
+            )
+        ))
+
+        message_to_send.append(( (wsene,), dumps({"msg": "drawEne", "data": [cur.name]})))
+
+        cur.status = Room.IN_TURN
+        if cur.poison_check():
+            message_to_send.append(( (wscur,wsene), "{} 受到了劇毒的侵蝕, 損失{}點生命".format(cur.name,cur.poison)))
+        if cur.life <= 0:
+            pass
+        #await sendTo(health(p1,p2), wsp1, wsp2)
+        #await sendTo(draw(cur), wsp1, wsp2) # 抽卡
+        #message_to_send.append(( (wscur,), game.display(cur))) # 顯示手牌
+        #message_to_send.append(( (wscur,), "請問要使用手牌嗎? 若不使用請輸入0"))
+        return message_to_send
+        
+    def process(self, wscur, message): # cur is the person who send message to server
+
+        start_next_turn_cards = ['2', '3', '4', '8', '11', '12', '13', '14', '15', '16']
+        cur = wscur.player
+        wsene = self.players[1] if wscur is self.players[0] else self.players[0]
+        ene = wsene.player
+        message_to_send = []
+        choice = message
+        if cur.status == self.IN_TURN:
+            
+            if choice in cur.hand:
+                
+                message_to_send.extend(card.skills[choice](wscur, wsene))
+                if choice in start_next_turn_cards:
+                    cur.status = self.NOTHING 
+                    message_to_send.extend(Room.start_turn(wsene, wscur))
+                    
+                cur.remove_card(choice)
+            elif choice == "0":
+                cur.status = self.NOTHING
+                message_to_send.extend(Room.start_turn(wsene, wscur))
+            """elif choice == "-1":
+                cur.surrender()
+                {}投降".format(cur.name)"""
+                
+        elif cur.status == self.ROBBING:
+            pass
+        
+        elif cur.status == self.ROBBED:
+            pass
+        elif cur.status == self.DEFENCE: # cur是被攻擊方
+            if choice in cur.hand:
+                if choice in card.unattackable:
+                    message_to_send.extend(card.skills[choice](wscur,wsene))
+                    cur.remove_card(choice)
+                elif choice == "0":
+                    message_to_send.append(( (wsene, wscur), "{} 受到{}點傷害".format(cur.name,ene.damage)))
+                    ene.life -= cur.damage
+            else:
+                message_to_send.append(( (wscur,wsene), "{} 受到{}點傷害".format(cur.name,ene.damage)))
+            cur.life -= cur.damage
+            ene.attacking = False
+            ene.damage = 0 # reset
+
+            message_to_send.extend(Room.start_turn(wscur, wsene))
+        
+        elif cur.status == self.TRADE:
+            pass
+        
+        elif cur.status == self.PLAN:
+            pass
+
+        return message_to_send
+async def sendTo(message, *ws_list):
+        for ws in ws_list:
+            await ws.send(message)

spec.json

@@ -0,0 +1,192 @@
+choose character: "5"
+
+enter_room: room number / "n" // "n" to create a random room and enter it
+	out: room number / {"room": 18693, "cur": "圭月", "ene": "小兔"}
+		// shows room number, or send a object shows your player and enemy's
+
+遊戲剛開始時發送:
+{"msg": "firstAttack", "data": [firstPlayer.name], "hand": player.hand}
+
+
+每回合開始發送:
+{
+	"player": { 
+				"turn": 3, "hand": ['1','2','3','1','1','1'], "deck_left": 35,
+				"life": 20
+		},
+	"enemy": {"turn": 3, "life": 20, "deck_left": 35
+	
+	}
+}
+
+{
+	"attack": "{} 攻擊 {}", 
+	"damaged": "{} 受到{}點傷害", 
+	//"toDefend": "請問要防禦嗎?不出牌請輸入0", 
+	"defended": "{} 防禦成功", 
+	"defend": "{} 沒什麼可以防禦的，回復一點生命", 
+	"heal": "{} 回復兩點生命", 
+	"supply": "{} 增加兩張手牌", 
+	"rob": "{} 正在對 {} 行搶", 
+	"cantRob": "可惜，{} 有夠窮，沒東西能搶", 
+	"robbed": "{} 搶到了 {}"
+	"surprise": "{} 發動奇襲", 
+	"surprised": "{} 受到{}點傷害，而且掉了一張手牌", 
+	"trade": "{} 想與 {} 進行交易", 
+	"tradeChoose": "{} 選擇了 {}",
+	//"toRob": "{} 要搶哪張?", 
+	//"toBeRobbed": "請問要防禦嗎?"
+	//"toTrade": "選擇一張手牌以交換",  
+	"awared": "{} 洞悉了 {} 的{}，並抽取了一張手牌", 
+	/* 整併於上
+		"": "{} 洞悉了 {} 的強奪，並抽取了一張手牌", 
+		"": "{} 洞悉了 {} 的奇襲，並抽取了一張手牌",
+	*/ 
+	"aware": "{} 增加三張手牌", 
+	"plan": "{} 有個妙策", 
+	//"toAdd": "選擇一張卡加入手牌",  
+	"sweep": "{} 對 {} 進行掃射，威力是 {}", 
+	"bless": "{} 獲得加護，身上的毒素一掃而空，並回復三點生命，還抽取了兩張手牌", 
+	"poison": "{} 在食物下毒，{}中毒了", 
+	"curse": "{} 詛咒了 {}，使其損失四點生命，並掉了一張手牌", 
+	"countered": "{} 反制了 {} 的攻擊，反彈了{}點傷害", 
+	"counteredSur": "{} 反制了 {} 的攻擊，反彈了{}點傷害，並使其掉了一張手牌", 
+	"counter": "{} 反制了敵手，使 {} 生命值減半了!", 
+	"chaos": "{} 進入狂亂模式，回復三點生命，並對 {} 造成三點傷害", 
+	"reverse": "{} 一口氣逆轉了情勢",
+	//"": "{} 的生命: {}", 
+	//"": "這是 {} 的手牌", 
+	"noCard": "你抽到了死神", 
+	"left": "牌組剩餘: {} 張", 
+	//"": "{} 抽到了 {}", 
+	//"inTurn": "請問要使用手牌嗎? 若不使用請輸入0", 
+	"turnNumber": "{} 的第{}回合", 
+	"poisonDamaged": "{} 受到了劇毒的侵蝕，損失{}點生命", 
+	"surrender": "{}投降", 
+	"firstAttack": "{}先攻", 
+	"win": "{}獲勝", 
+	"draw": "{}抽到了{}",
+	"drawEne": "{}抽了一張卡片"
+	
+}
+
+
+
+1. attack
+	in: "1"
+	out: 
+		cur: {"msg": "attack", "data": [cur.name, ene.name]}
+		ene: {"msg": "attack", "data": [cur.name, ene.name], 
+				"action": "toDefend", "value": {"damage": cur.damage}} / 無(不能防禦)
+			in: "2" / "8" / "14" / "0"
+			out: 
+				cur: {"msg": "defended", "data": [ene.name]} / 
+						{"msg": "countered", "data": [ene.name]} /
+						{"msg": "awared", "data": [ene.name, "攻擊"]} / 
+						{"msg": "damaged", "data": [ene.name, cur.damage]}
+				ene: 同上
+2. defend //此處指主動使用
+	in: "2"
+	out:
+		cur: {"msg": "defend", "data": [cur.name]}
+		ene: 同上
+3. heal
+	in: "3"
+	out:
+		cur: {"msg": "heal", "data": [cur.name]}
+		ene: 同上
+4. supply
+	in: "4"
+	out:
+		cur: {"msg": "supply", "data": [cur.name]}
+		ene: 同上
+5. rob
+	in: "5"
+	out:
+		cur: {"msg": "rob", "data": [cur.name, ene.name], 
+				"action": "toRob", "value": {"emeny_card:", ene.hand}} /
+				{"msg": "cantRob", "data": [ene.name]}
+			in: card number
+			out:
+				ene: {"action": "toBeRobbed"} / 無(不能防禦時)
+					in: "8" / "0"
+					out: 
+						cur: {"msg": "defended", "data": [ene.name]} /
+								{"msg": "robbed", "data": [ene.name, card]}
+						ene: 同上
+		ene: 無 / {"msg": "cantRob", "data": [ene.name]}
+6. surprise
+	in: "6"
+	out: 
+		cur: 
+		ene: {"action": "toDefend", "value": {"damage": cur.damage}} / 無(不能防禦)
+			in: "2" / "8" / "14" / "0"
+			out: 
+				cur: {"msg": "defended", "data": [ene.name]} /
+						{"msg": "counteredSur", "data": [ene.name]} /
+						{"msg": "awared", "data": [ene.name, "奇襲"]} / 
+						{"msg": "surprised", "data": [ene.name, cur.damage]}
+				ene: 同上
+7. trade
+	in: "7"
+	out:
+		cur: {"msg": "trade", "data": [cur.name, ene.name], "action": "toTrade"}
+			in: card number
+			out:
+				cur: {"msg": "tradeChoose", "data": [cur.name, card number]}
+				ene: {"action": "toTrade"}
+		ene: {"msg": "trade", "data": [cur.name, ene.name]}
+8. aware //此處指主動使用
+	in: "8"
+	out:
+		cur: {"msg": "aware", "data": [cur.name]}
+		ene: 同上
+9. plan
+	in: "9"
+	out: 
+		cur: {"msg": "plan", "data": [cur.name], 
+				"action": "toAdd", "value": {"cards": list}}
+			in: card number
+		ene: {"msg": "plan", "data": [cur.name]}
+10. bless
+	in: "10"
+	out:
+		cur: {"msg": "bless", "data": [cur.name]}
+		ene: 同上
+11. sweep
+	in: "11"
+	out: 
+		cur: 
+		ene: {"action": "toDefend", "value": {"damage": cur.damage}} / 無(不能防禦)
+			in: "2" / "8" / "14" / "0"
+			out: 
+				cur: {"msg": "defended", "data": [ene.name]} / 
+						{"msg": "countered", "data": [ene.name]} /
+						{"msg": "awared", "data": [ene.name, "掃射"]} / 
+						{"msg": "damaged", "data": [ene.name, cur.damage]}
+				ene: 同上
+12. poison
+	in: "12"
+	out:
+		cur: {"msg": "poison", "data": [cur.name, ene.name]}
+		ene: 同上
+13. curse
+	in: "13"
+	out:
+		cur: {"msg": "curse", "data": [cur.name, ene.name]}
+		ene: 同上
+14. counter //此處指主動使用
+	in: "14"
+	out:
+		cur: {"msg": "counter", "data": [cur.name, ene.name]}
+		ene: 同上
+15. chaos
+	in: "15"
+	out:
+		cur: {"msg": "chaos", "data": [cur.name, ene.name]}
+		ene: 同上
+16. reverse
+	in: "16"
+	out:
+		cur: {"msg": "reverse", "data": [cur.name]}
+		ene: 同上