def HandleServerStart(self):
# Connect to the MongoDB
self.database = DBManager(host="localhost", port=27017, testing=True)
address = self.server.address
logger.info("Server started in address %s:%d", *address)
self.admin_user = User(name="admin", user="******")
self.room_manager = RoomManager()
self.room_manager.CreateRoom("default", self.admin_user)
self.logged_users = Connect.SafeList()
def run(stdscr):
stdscr = curses.initscr()
curses.noecho()
curses.cbreak()
curses.start_color()
curses.initscr()
curses.use_default_colors()
curses.init_pair(1, -1, 246)
curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_RED)
db = DB()
rm = RoomManager()
rm.add_room(TitleRoom(stdscr, rm, VERSION, AUTHOR))
rm.add_room(TableRoom(stdscr, rm, db))
rm.add_room(HelpRoom(stdscr, rm))
rm.start()
class Sokoban(Scene):
"""Main class of game that creates all
the other classes and stores the pygame display"""
def __init__(self, screenRes=(640, 480)):
self.running = True
self.surfaceManager = SurfaceManager(screenRes, "Assets/northpole.jpg")
self.roomManager = RoomManager(
screenRes
) #Sokoban needs an extra manager for all the levels that contain sprites
self.uiManager = SokobanUIManager(
{
"room": Text("Room: 1", (0, 255, 0), 30, 440),
"totalMoves": Text("Total Moves: 0", (0, 255, 0), 130, 440),
"moves": Text("Moves: 0", (0, 255, 0), 230, 440)
}, {
"Reset":
Button("Reset", (32, 32, 32), (0, 140, 0), 400, 440,
screenRes[0] * 0.1, screenRes[1] * 0.05)
}, screenRes)
self.eventHandlers = SokobanEventHandlers(self)
self.eventManager = SokobanEventManager(
self.eventHandlers, self.roomManager.eventHandlers,
self.roomManager.currentRoom.eventHandlers,
self.uiManager.eventHandlers)
self.surfaceManager.setObjects([self.roomManager, self.uiManager])
def getTotalScore(self):
return self.roomManager.getTotalMoves()
def __init__(self, host, port, maxclients, maxdown, maxup):
self.room_manager = RoomManager()
Client.connected.connect(self.room_manager.on_client_connected)
if port == "*":
use_port = 0
else:
use_port = int(port)
if host == "*":
use_host = None
else:
use_host = host
address = enet.Address(use_host, use_port)
maxclients = int(maxclients)
maxdown = int(maxdown)
maxup = int(maxup)
self._enet_host = enet.Host(address, maxclients, 3, maxdown, maxup)
ClientBase.cn_pool.extend(list(range(maxclients)))
self.clients = {}
self._running = True
def __init__(self, screenRes=(640, 480)):
self.running = True
self.surfaceManager = SurfaceManager(screenRes, "Assets/northpole.jpg")
self.roomManager = RoomManager(screenRes)
self.uiManager = ScoreUIManager(
{"Total Moves": Text("Total Moves: 0", (0, 255, 0), 130, 440)}, {
"Restart":
Button("Restart", (32, 32, 32), (0, 140, 0), 560, 440, 130, 40)
}, screenRes)
self.eventManager = ScoreEventManager(self.uiManager.eventHandlers)
self.surfaceManager.setObjects([self.uiManager])
def __init__(self, screenRes=(640, 480)):
self.running = True
self.surfaceManager = SurfaceManager(screenRes, "Assets/northpole.jpg")
self.roomManager = RoomManager(
screenRes
) #Sokoban needs an extra manager for all the levels that contain sprites
self.uiManager = SokobanUIManager(
{
"room": Text("Room: 1", (0, 255, 0), 30, 440),
"totalMoves": Text("Total Moves: 0", (0, 255, 0), 130, 440),
"moves": Text("Moves: 0", (0, 255, 0), 230, 440)
}, {
"Reset":
Button("Reset", (32, 32, 32), (0, 140, 0), 400, 440,
screenRes[0] * 0.1, screenRes[1] * 0.05)
}, screenRes)
self.eventHandlers = SokobanEventHandlers(self)
self.eventManager = SokobanEventManager(
self.eventHandlers, self.roomManager.eventHandlers,
self.roomManager.currentRoom.eventHandlers,
self.uiManager.eventHandlers)
self.surfaceManager.setObjects([self.roomManager, self.uiManager])
class ChatServerHandler(Connect.BaseServerHandler):
def HandleServerStart(self):
# Connect to the MongoDB
self.database = DBManager(host="localhost", port=27017, testing=True)
address = self.server.address
logger.info("Server started in address %s:%d", *address)
self.admin_user = User(name="admin", user="******")
self.room_manager = RoomManager()
self.room_manager.CreateRoom("default", self.admin_user)
self.logged_users = Connect.SafeList()
def HandleNewConnection(self, socket_manager):
logger.info(
"New connection from {}:{}".format(*socket_manager.address))
def HandleClientRequest(self, socket_manager):
msg = socket_manager.Receive()
if msg is None or not IsValidMessage(msg):
self.SendResponse(msg.type, ResponseCode.INVALID_MESSAGE,
socket_manager)
return
if msg.type == MessageType.CHAT:
self.ProcessChatMessage(msg, socket_manager)
elif (msg.type == MessageType.LOGIN):
self.ProcessLoginMessage(msg, socket_manager)
elif (msg.type == MessageType.REGISTER):
self.ProcessRegisterMessage(msg, socket_manager)
elif (msg.type == MessageType.CREATE_ROOM):
self.ProcessCreateRoomMessage(msg, socket_manager)
elif (msg.type == MessageType.REMOVE_ROOM):
self.ProcessRemoveRoomMessage(msg, socket_manager)
def HandleClientClose(self, socket_manager):
logger.info("Closed conection {}:{}".format(*socket_manager.address))
if socket_manager in self.logged_users:
self.logged_users.remove(socket_manager)
def HandleServerClose(self):
msg = Connect.Message(MessageType.SERVER_CLOSE)
self.ServerBroadcast(msg, self.server.clients)
logger.info("Server Closed.")
def ProcessChatMessage(self, msg, socket_manager):
logger.debug(msg.content.get("message"))
self.SendResponse(MessageType.CHAT, ResponseCode.OK, socket_manager)
broadcast = Connect.Message(MessageType.NEW_CHAT, msg.content)
self.ServerBroadcast(broadcast, self.logged_users)
def ProcessLoginMessage(self, msg, socket_manager):
user = self.database.GetUser(msg.content.get("user"))
if user is None or user.password != msg.content.get("password"):
self.SendResponse(msg.type, ResponseCode.INVALID_LOGIN_INFO,
socket_manager)
else:
self.logged_users.append(socket_manager)
logger.debug("New login from user %s.", user.user)
self.SendResponse(msg.type, ResponseCode.OK, socket_manager,
self.room_manager.GetRoomList())
def ProcessRegisterMessage(self, msg, socket_manager):
# Check for an invalid user
match = re.fullmatch("^[a-zA-Z][a-zA-Z0-9_.]+$",
msg.content.get("user"))
if match is None:
self.SendResponse(msg.type, ResponseCode.INVALID_USERNAME,
socket_manager)
user = User(**msg.content)
result = self.database.Insert(user)
if result:
logger.debug("New user created with username: %s.", user.user)
self.SendResponse(msg.type, ResponseCode.OK, socket_manager)
else:
self.SendResponse(msg.type, ResponseCode.USER_ALREADY_REGISTERED,
socket_manager)
def ProcessCreateRoomMessage(self, msg, socket_manager):
room_name = msg.content.get("name")
user = self.database.GetUser(msg.content.get("owner"))
if user is not None:
result = self.room_manager.CreateRoom(room_name, user)
if result is not None:
self.SendResponse(msg.type, ResponseCode.OK, socket_manager)
broadcast = Connect.Message(MessageType.NEW_ROOM, msg.content)
self.ServerBroadcast(broadcast, self.logged_users)
else:
self.SendResponse(msg.type, ResponseCode.ROOM_ALREADY_CREATED,
socket_manager)
else:
self.SendResponse(msg.type, ResponseCode.NON_EXISTING_USER,
socket_manager)
def ProcessRemoveRoomMessage(self, msg, socket_manager):
room_name = msg.content.get("name")
user = self.database.GetUser(msg.content.get("owner"))
if user is not None:
result = self.room_manager.RemoveRoom(room_name, user)
if result == 0:
self.SendResponse(msg.type, ResponseCode.OK, socket_manager)
broadcast = Connect.Message(MessageType.DELETE_ROOM,
{"name": room_name})
self.ServerBroadcast(broadcast, self.logged_users)
elif result == 1:
self.SendResponse(msg.type, ResponseCode.NON_EXISTING_ROOM,
socket_manager)
elif result == 2:
self.SendResponse(msg.type, ResponseCode.NOT_ROOM_OWNER,
socket_manager)
else:
self.SendResponse(msg.type, ResponseCode.NON_EXISTING_USER,
socket_manager)
def SendResponse(self,
msg_type,
response_code,
socket_manager,
content=None):
response_content = {
"type": msg_type,
"code": response_code,
"content": content
}
response = Connect.Message(MessageType.RESPONSE, response_content)
socket_manager.Send(response)
def ServerBroadcast(self, msg, users):
for socket_manager in users:
try:
socket_manager.Send(msg)
except:
pass
class Engine(object):
clients = {}
room_manager = None
_running = False
_enet_host = None
def __init__(self, host, port, maxclients, maxdown, maxup):
self.room_manager = RoomManager()
Client.connected.connect(self.room_manager.on_client_connected)
if port == "*":
use_port = 0
else:
use_port = int(port)
if host == "*":
use_host = None
else:
use_host = host
address = enet.Address(use_host, use_port)
maxclients = int(maxclients)
maxdown = int(maxdown)
maxup = int(maxup)
self._enet_host = enet.Host(address, maxclients, 3, maxdown, maxup)
ClientBase.cn_pool.extend(list(range(maxclients)))
self.clients = {}
self._running = True
def stop(self):
self._running = False
def getpeerid(self, event):
return (event.peer.address.host, event.peer.address.port)
def service_host(self):
try:
event = self._enet_host.service(5)
except KeyboardInterrupt:
raise
if event.type == enet.EVENT_TYPE_CONNECT:
print("%s: CONNECT" % event.peer.address)
self.clients[self.getpeerid(event)] = Client(event.peer)
elif event.type == enet.EVENT_TYPE_DISCONNECT:
print("%s: DISCONNECT" % event.peer.address)
if self.getpeerid(event) in self.clients.keys():
client = self.clients[self.getpeerid(event)]
del self.clients[self.getpeerid(event)]
client.on_disconnect()
elif event.type == enet.EVENT_TYPE_RECEIVE:
if self.getpeerid(event) in self.clients.keys():
self.clients[self.getpeerid(event)].on_receive_event(event.channelID, event.packet.data)
def run(self):
while self._running:
try:
self.room_manager.update_rooms()
self.service_host()
if self.room_manager.sendpackets():
self._enet_host.flush()
except:
exceptionType, exceptionValue, exceptionTraceback = sys.exc_info()
if exceptionType == KeyboardInterrupt:
print ""
return
print "Uncaught exception occurred in server engine mainloop."
print traceback.format_exc()
