class Game:
def __init__(self, port):
self.running = False
self.pid = 0
self.pids = []
self.nbPlayer = 0
self.players = {}
self.entities = {}
self.moves = []
self.shoot = False
self.shoots = []
self.deads = []
self.killed = []
self.input = Input()
self.graphics = Graphics()
self.velocity = Constant.VELOCITY
self.id = 0
self.port = port
self.players_socket = {}
self.players_socket_awaiting = {}
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind(('', self.port))
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.listen(5)
def init(self, name, nbEntity, nbPlayer = 1, pids = None):
self.id = nbPlayer
self.players[self.id] = Player(name)
self.nbPlayer = nbPlayer
self.pids = pids if pids else list(range(1, nbEntity + 1))
self.pid = self.pids[random.randrange(len(self.pids))]
self.pids.remove(self.pid)
def connect(self, ip, port, name):
print("Connecting to ({}, {})...".format(ip, port))
player_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
player_socket.connect((ip, port))
message = self.receive(player_socket)
if message.type & Message.OK and message.type & Message.INIT:
(nbPlayer, pids, entities) = message.data
self.init(name, 0, nbPlayer, pids)
for (pid, position) in entities:
self.entities[pid] = self.entity(position.x, position.y)
n = nbPlayer - 2
self.players_socket[message.id] = player_socket
self.notify(player_socket, Message.OK | Message.PORT, self.port)
while n:
player_socket, addr = self.socket.accept()
print("Accepting new connection from", addr)
self.notify(player_socket, Message.OK | Message.ID, None)
message = self.receive(player_socket)
if message.type & Message.OK and message.type & Message.ID:
self.players_socket[message.id] = player_socket
else:
print("Can't join")
self.disconnect()
return
self.notify(player_socket, Message.OK | Message.DONE, None)
n -= 1
self.run()
def connectTo(self, ip, port):
print("Connecting to ({}, {})...".format(ip, port))
player_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
player_socket.connect((ip, port))
self.players_socket_awaiting[self.nbPlayer] = player_socket
def disconnect(self):
print("Disconnecting...")
self.socket.close()
if self.nbPlayer > 1:
player_socket = next(iter(self.players_socket.values()))
data = [[(pid, entity.position) for (pid, entity) in self.entities.items()]]
self.notify(player_socket, Message.OK | Message.MOVE, data)
time.sleep(0.05) # NEEDED : Wait at least one loop from the remote player
self.notify(player_socket, Message.OK | Message.INIT, self.pids + [self.pid])
time.sleep(0.05)
self.notifyAll(Message.OK | Message.DISCONNECT | Message.STRING, "Disconnecting...")
for s in self.players_socket.values():
s.shutdown(socket.SHUT_WR)
while len(self.players_socket):
self.handleMessages(self.handleDisconnected)
self.running = False
print("Disconnected")
def new(self, name, nbEntity):
print("Game created")
print("Listening on port", self.port)
self.init(name, nbEntity)
for i in range(1, nbEntity + 1):
self.entities[i] = self.entity(random.randrange(Constant.WIDTH), random.randrange(Constant.HEIGHT))
self.run()
def run(self):
self.running = True
self.graphics.createWindow(Constant.WIDTH, Constant.HEIGHT)
t = time.time()
while self.running:
dt, t = self.getDt(t)
self.clear()
self.handleConnections()
self.handleMessages(self.handleMessage)
self.handleInputs(dt)
self.update(dt)
self.sendMessages()
self.render()
# NETWORK HANDLER
def handleConnection(self, connection):
player_socket, addr = connection.accept()
self.nbPlayer += 1
player_pids, self.pids = self.pids[:len(self.pids)//2+1], self.pids[len(self.pids)//2+1:]
data = (self.nbPlayer, player_pids, [(pid, self.entities[pid].position) for pid in player_pids])
self.notify(player_socket, Message.OK | Message.INIT, data)
self.players_socket_awaiting[self.nbPlayer] = player_socket
print("Accepting new connection from", addr)
def handleConnections(self):
connections, wlist, xlist = select.select([self.socket], [], [], 0.05)
for connection in connections:
self.handleConnection(connection)
def handleMessage(self, player_socket):
message = self.receive(player_socket)
if message.type & Message.OK:
if message.type & Message.CONNECT:
self.nbPlayer += 1
(host, port) = message.data
self.connectTo(host, port)
elif message.type & Message.INIT:
self.pids.extend(message.data)
elif message.type & Message.DISCONNECT:
self.nbPlayer -= 1
self.notify(player_socket, Message.OK | Message.DISCONNECTED, None)
player_socket.shutdown(socket.SHUT_RDWR)
player_socket.close()
del self.players_socket[message.id]
elif message.type & Message.ID:
self.notify(player_socket, Message.OK | Message.ID, None)
elif message.type & Message.PORT:
self.notifyAll(Message.OK | Message.CONNECT, (player_socket.getpeername()[0], message.data))
self.players_socket[message.id] = self.players_socket_awaiting[message.id]
del self.players_socket_awaiting[message.id]
elif message.type & Message.DONE:
self.players_socket[message.id] = self.players_socket_awaiting[message.id]
del self.players_socket_awaiting[message.id]
if message.type & Message.MOVE:
for (pid, position) in message.data[0]:
if pid in self.entities:
self.entities[pid].position = position
else:
self.entities[pid] = self.entity(position.x, position.y)
if message.type & Message.SHOOT:
self.shoots.append(message.id)
if message.type & Message.DEAD:
self.killed.extend(message.data[1])
#elif message.type & Message.STRING:
# print(message)
def handleDisconnected(self, player_socket):
message = self.receive(player_socket)
if message.type & Message.OK and message.type & Message.DISCONNECTED:
player_socket.close()
del self.players_socket[message.id]
def handleMessages(self, f):
players_socket = []
if len(self.players_socket) + len(self.players_socket_awaiting):
try:
players_socket, wlist, xlist = select.select(list(self.players_socket.values()) + list(self.players_socket_awaiting.values()), [], [], 0.05)
for player_socket in players_socket:
f(player_socket)
except select.error as e:
#print(e)
pass
# GAME HANDLER
def handleInputs(self, dt):
# Get keyboard inputs
actionKeys = self.input.update()
# Create action
for (actionType, obj) in actionKeys:
if actionType == pygame.QUIT:
self.disconnect()
elif actionType == pygame.KEYDOWN:
if obj == pygame.K_ESCAPE:
self.disconnect()
elif obj == pygame.K_SPACE:
self.shoot = True
# Get player action
dx = 0
dy = 0
if self.input.getKeyDown(pygame.K_LEFT):
dx = int(-self.velocity * dt)
if self.input.getKeyDown(pygame.K_RIGHT):
dx += int(self.velocity * dt)
if self.input.getKeyDown(pygame.K_UP):
dy = int(-self.velocity * dt)
if self.input.getKeyDown(pygame.K_DOWN):
dy += int(self.velocity * dt)
if self.input.getKeyDown(pygame.K_w):
self.velocity = max(self.velocity - 5, 5)
if self.input.getKeyDown(pygame.K_x):
self.velocity = min(self.velocity + 5, 80)
if dx != 0 or dy != 0:
self.entities[self.pid].move(dx, dy, Constant.WIDTH, Constant.HEIGHT)
self.moves.append(self.pid)
# NETWORK UTILITY
def notify(self, player, type, data):
try:
player.sendall(pickle.dumps(Message(self.id, type, data)))
#print("Sending -> ", Message(self.id, type, data))
except:
pass
def notifySome(self, players, type, data):
for player in players:
self.notify(player, type, data)
def notifyAll(self, type, data):
self.notifySome(self.players_socket.values(), type, data)
def receive(self, s):
BUFFER_SIZE = 4096
data = b''
while True:
data += s.recv(BUFFER_SIZE)
if not data:
return Message(0, Message.ERROR, None)
else:
if data.endswith(b'.'):
m = pickle.loads(data)
print(m)
return m
def sendMessages(self):
data = [[], []]
data_move = []
move = Message.NOTHING
data_shoot = []
shoot = Message.NOTHING
data_deads = []
deads = Message.NOTHING
if len(self.moves):
move = Message.MOVE
data[0] = [(pid, self.entities[pid].position) for pid in self.moves]
if self.shoot:
shoot = Message.MOVE | Message.SHOOT
data_shoot = [(self.pid, self.entities[self.pid].position)]
if len(self.deads):
deads = Message.DEAD
data_deads = [pid for pid in self.deads]
data[0].extend(data_move)
data[0].extend(data_shoot)
data[1].extend(data_deads)
if move or shoot or deads:
self.notifyAll(Message.OK | move | shoot | deads, data)
# GAME UTILITY
def getDt(self, lastTime):
t = time.time()
dt = t - lastTime
return dt, t
def entity(self, x, y):
return Entity(x, y, (random.randrange(256), random.randrange(256), random.randrange(256)))
def clear(self):
self.shoot = False
self.moves.clear()
self.shoots.clear()
self.deads.clear()
self.killed.clear()
def update(self, dt):
for pid in self.pids:
if self.entities[pid].behave(dt, Constant.WIDTH, Constant.HEIGHT):
self.moves.append(pid)
for pid_shoot in self.shoots:
for pid in self.pids:
if self.entities[pid].collide(self.entities[pid_shoot], Constant.DEFAULT_RADIUS, Constant.FIRING_RADIUS):
del self.entities[pid]
self.deads.append(pid)
for pid in self.killed:
del self.entities[pid]
def render(self):
self.graphics.clear()
self.graphics.renderEntities(self.entities, self.pid, self.shoot, self.shoots)
self.graphics.displayTopScore(self.players)
self.graphics.displayOverlay(Constant.VELOCITY, Constant.HEIGHT)
self.graphics.flip()
