-
Notifications
You must be signed in to change notification settings - Fork 0
/
server.py
executable file
·181 lines (135 loc) · 5.68 KB
/
server.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#!/usr/bin/env python2
import sys
import logging
import time
from hashlib import sha1
from wspy import AsyncServer, TextMessage, DeflateFrame, WebkitDeflateFrame
from game import Board
class BadRequest(RuntimeError):
pass
def check(condition, error='invalid format'):
if not condition:
raise BadRequest(error)
class Msg:
def __init__(self, mtype, *args):
self.mtype = mtype
self.args = args
@classmethod
def decode(cls, message):
check(isinstance(message, TextMessage))
parts = message.payload.split(';')
check(parts)
mtype = parts[0]
args = [int(p) if p.isdigit() else p for p in parts[1:]]
return cls(mtype, *args)
def encode(self):
return TextMessage(';'.join([self.mtype] + map(str, self.args)))
STATE_JOINING = 0
STATE_PLAYING = 1
STATE_FINISHED = 2
class Session:
def __init__(self, w, h, owner):
self.sid = sha1(str(time.time())).hexdigest()
self.clients = [owner]
owner.player = 1
self.player_counter = 2
self.state = STATE_JOINING
self.board = Board(w, h)
self.turn = owner
owner.send(Msg('newgame', self.sid, w, h).encode())
owner.send(Msg('turn', self.turn.player).encode())
def __str__(self):
return '<Session %s state=%d size=%dx%d>' % \
(self.sid, self.state, self.board.w, self.board.h)
def click_wall(self, client, x, y, direction):
check(self.turn is client, 'not your turn')
check(self.state < STATE_FINISHED, 'already finished')
self.state = STATE_PLAYING
occupied = self.board.click_wall(x, y, direction, client.player)
self.bcast('clickwall', x, y, direction)
if occupied:
for x, y in occupied:
self.bcast('occupy', x, y, client.player)
if self.board.is_finished():
scores = self.board.scores()
for player in xrange(1, self.player_counter):
scores.setdefault(player, 0)
scores = scores.items()
scores.sort(key=lambda (player, score): score, reverse=True)
self.state = STATE_FINISHED
self.bcast('finish', *['%d:%d' % s for s in scores])
else:
index = (self.clients.index(self.turn) + 1) % len(self.clients)
self.turn = self.clients[index]
self.bcast('turn', self.turn.player)
def bcast(self, mtype, *args):
encoded = Msg(mtype, *args).encode()
for client in self.clients:
client.send(encoded)
def join(self, client):
client.player = self.player_counter
self.player_counter += 1
self.bcast('join', client.player)
client.send(Msg('newgame', self.sid, self.board.w, self.board.h,
client.player).encode())
client.send(Msg('turn', self.turn.player).encode())
for other in self.clients:
client.send(Msg('join', other.player).encode())
self.clients.append(client)
def leave(self, client):
self.clients.remove(client)
self.bcast('leave', client.player)
if self.state == STATE_PLAYING:
self.bcast('cancel', 'a player has quit before the game ended')
elif client is self.turn:
self.turn = self.clients[0]
self.bcast('turn', self.turn.player)
def is_dead(self):
return not self.clients
class GameServer(AsyncServer):
def __init__(self, *args, **kwargs):
super(GameServer, self).__init__(*args, **kwargs)
self.sessions = {}
def onmessage(self, client, message):
try:
msg = Msg.decode(message)
if msg.mtype == 'newgame':
check(len(msg.args) == 2)
w, h = msg.args
client.session = session = Session(w, h, client)
self.sessions[session.sid] = session
logging.info('%s created session %s' % (client, session))
elif msg.mtype == 'join':
check(len(msg.args) == 1)
sid = msg.args[0]
check(not hasattr(client, 'session'), 'already in a session')
check(sid in self.sessions, 'no such session')
session = self.sessions[sid]
check(session.state == STATE_JOINING, 'game already started')
session.join(client)
client.session = session
logging.info('%s joined %s' % (client, session))
elif msg.mtype == 'clickwall':
check(len(msg.args) == 3)
x, y, direction = msg.args
check(hasattr(client, 'session'), 'no session associated with client')
client.session.click_wall(client, x, y, direction)
if client.session.state == STATE_FINISHED:
logging.info('session %s finished' % client.session.sid)
else:
raise BadRequest('unknown message type')
except BadRequest as e:
logging.warning('bad request: %s' % e.message)
client.send(Msg('error', e.message).encode())
def onclose(self, client, code, reason):
if hasattr(client, 'session'):
client.session.leave(client)
logging.info('%s left %s' % (client, client.session))
if client.session.is_dead():
logging.info('deleting session %s' % client.session)
del self.sessions[client.session.sid]
if __name__ == '__main__':
port = int(sys.argv[1]) if len(sys.argv) > 1 else 8099
GameServer(('localhost', port),
extensions=[DeflateFrame(), WebkitDeflateFrame()],
loglevel=logging.DEBUG).run()