def recvNumOfPlayers(self):
getPlayerCountPacket = UDPpacket.UDPpacket("PLAYER_COUNT")
self.socket.sendto(pickle.dumps(getPlayerCountPacket),
self.server_address)
#Receive player count from server
data, addr = self.socket.recvfrom(self.BUFFER_SIZE)
loaded_data = pickle.loads(data)
return (loaded_data.player_count)
def startGame(self):
startGamePacket = UDPpacket.UDPpacket("START_GAME")
self.socket.sendto(pickle.dumps(startGamePacket), self.server_address)
#Receive game map
#Receive player count from server
data, addr = self.socket.recvfrom(self.BUFFER_SIZE)
loaded_data = pickle.loads(data)
self.map_matrix = loaded_data.map_matrix
self.gui = self.RenderBoard(self.map_matrix)
def join(self, lobby_id_udp):
joinPacket = UDPpacket.UDPpacket("JOIN")
joinPacket.player = self.player
joinPacket.lobby_id_udp = lobby_id_udp
self.socket.sendto(pickle.dumps(joinPacket), self.server_address)
data, addr = self.socket.recvfrom(self.BUFFER_SIZE)
loaded_data = pickle.loads(data)
if loaded_data.packet_type == "VALID_LOBBY_ID":
return True
else:
return False
def create_room(self):
createroomPacket = UDPpacket.UDPpacket("CREATE_ROOM")
createroomPacket.player = self.player
self.socket.sendto(pickle.dumps(createroomPacket), self.server_address)
#Receive response lobby id from server
data, addr = self.socket.recvfrom(self.BUFFER_SIZE)
loaded_data = pickle.loads(data)
print("LOBBY ID FROM SERVER: ")
print(loaded_data.lobby_id_udp)
#return lobby id
return (loaded_data.lobby_id_udp)
def move(self, movement):
movementPacket = UDPpacket.UDPpacket("MOVE")
movementPacket.movement = movement
movementPacket.player = self.player
self.socket.sendto(pickle.dumps(movementPacket), self.server_address)
#Receive player count from server
data, addr = self.socket.recvfrom(self.BUFFER_SIZE)
loaded_data = pickle.loads(data)
self.map_matrix = loaded_data.map_matrix
self.renew_map()
def connect(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.client_addr = (self.hostname, self.port)
self.socket.bind(self.client_addr)
# self.socket.setblocking(0)
#Always create a UDPpacket first! before sending to server.
#Kasi mas madali iaccess and mas organized, madaling i-trace
#send connect packet to server
connectPacket = UDPpacket.UDPpacket("CONNECT")
connectPacket.player = self.player
self.socket.sendto(pickle.dumps(connectPacket), self.server_address)
def startGame(self):
startGamePacket = UDPpacket.UDPpacket("START_GAME")
self.socket.sendto(pickle.dumps(startGamePacket), self.server_address)
#Receive game map
#Receive player count from server
data, addr = self.socket.recvfrom(self.BUFFER_SIZE)
loaded_data = pickle.loads(data)
self.map_matrix = loaded_data.map_matrix
# if self.selected_map == 1:
# self.selected_map = "map1.txt"
# if self.selected_map == 2:
# self.selected_map = "map2.txt"
# if self.selected_map == 3:
# self.selected_map = "map3.txt"
# mapPacket = UDPpacket.UDPpacket("MAP_PACKET")
# mapPacket.map_file = self.selected_map
# self.socket.sendto(pickle.dumps(mapPacket), self.server_address)
self.game_map()
def run(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_addr = (self.hostname, self.port)
self.socket.bind(server_addr)
print("Hosting at: ", self.hostname)
while True:
data, addr = self.socket.recvfrom(self.BUFFER_SIZE)
loaded_data = pickle.loads(data)
packet_type = loaded_data.packet_type
if packet_type == "CONNECT":
print("{} succesfully connected to server!".format(loaded_data.player.name))
if packet_type == "CREATE_ROOM":
#generate a lobby_id
allchar = string.ascii_letters + string.digits
self.lobby_id = "".join(choice(allchar) for x in range(randint(6, 6)))
self.lobby_id = self.lobby_id.upper()
print("LOBBY ID :", self.lobby_id)
#create room using pacman.Room(lobby_id)
self.room = pacman.Room(self.lobby_id)
#Send lobby_id to client
sendLobbyIdPacket = UDPpacket.UDPpacket("SEND_LOBBY_ID")
sendLobbyIdPacket.lobby_id_udp = self.lobby_id
self.socket.sendto(pickle.dumps(sendLobbyIdPacket), addr)
if packet_type == "JOIN":
if loaded_data.lobby_id_udp == self.lobby_id:
#Add client to room
self.room.add_client(loaded_data.player)
print("ADDED " + loaded_data.player.name + " to room")
sendLobbyIdPacket = UDPpacket.UDPpacket("VALID_LOBBY_ID")
else:
#Send error to client
print(loaded_data.player.name + " sent invalid LOBBY_ID")
sendLobbyIdPacket = UDPpacket.UDPpacket("INVALID_LOBBY_ID")
self.socket.sendto(pickle.dumps(sendLobbyIdPacket), addr)
if packet_type == "PLAYER_COUNT":
#send room to client
sendRoomPacket = UDPpacket.UDPpacket("SEND_ROOM")
sendRoomPacket.player_count = self.room.player_counter
self.socket.sendto(pickle.dumps(sendRoomPacket), addr)
if packet_type == "START_GAME":
map_file = loaded_data.map_file
# print(map_file)
self.game_map = pacman.GameMap("map1.txt", self.room.clients)
#Send gamemap
sendGameMapPacket = UDPpacket.UDPpacket("SEND_GAMEMAP")
sendGameMapPacket.map_matrix = self.game_map.map_matrix
self.socket.sendto(pickle.dumps(sendGameMapPacket), addr)
if packet_type == "MOVE":
movement = loaded_data.movement
player = loaded_data.player
self.game_map.move(player,movement)
#Send gamemap
sendGameMapPacket = UDPpacket.UDPpacket("SEND_GAMEMAP")
sendGameMapPacket.map_matrix = self.game_map.map_matrix
self.socket.sendto(pickle.dumps(sendGameMapPacket), addr)
if packet_type == "UPDATE_PACKET":
#Send gamemap
sendGameMapPacket = UDPpacket.UDPpacket("SEND_GAMEMAP")
sendGameMapPacket.map_matrix = self.game_map.map_matrix
self.socket.sendto(pickle.dumps(sendGameMapPacket), addr)
def run(self):
socket.socket.__init__(self, type=socket.SOCK_DGRAM)
self.bind(('', self.port))
self.host_address = self.getsockname()[0]
print('Hosting at:', self.host_address)
while True:
data, address_info = self.recvfrom(self.BUFFER_SIZE)
deserialized_data = pickle.loads(data)
packet_type = deserialized_data[0]
if packet_type == "CONNECT":
player_name = deserialized_data[1]
player_type = deserialized_data[2]
print("{} {} connected from {}".format(player_type, player_name, address_info))
player = pacman.Player(player_name, player_type)
player.address_info = address_info
self.client_list.append(player)
elif packet_type == "CREATE_ROOM":
player = deserialized_data[1]
lobby_id = "JK898"
print("{} created room in lobby {}".format(player, lobby_id))
self.room = pacman.Room(lobby_id)
for client in self.client_list:
if client.name == player:
self.room.add_client(client)
elif packet_type == "JOIN":
player = deserialized_data[1]
print("{} joined lobby {}".format(player, lobby_id))
for client in self.client_list:
if client.name == player:
self.room.add_client(client)
elif packet_type == "START_GAME":
print("Received start game")
map = pacman.GameMap("map1.txt")
print(map.map_matrix)
#Create datapacket with UPDATE PACKET as value
dataPacket = udp.UDPpacket("UPDATE_PACKET")
dataPacket.map_state = map.map_matrix
#Send map_state as data to all clients by looping. For each client in client_list.
for client in self.client_list:
dataPacket.player_position = self.getInitialCoordinates(self.player_number)
self.player_number = self.player_number + 1
client.current_pos = dataPacket.player_position
print("Client address info")
print(client.address_info)
send(client.address_info, dataPacket)
print("sent!")
# if self.room.player_counter == 1003 or self.room.player_counter == 1004:
# print("hello")
# map_name = deserialized_data[1]
# map_state = pacman.GameMap(map_name)
# print(map_state.map_matrix)
# send to client, after client receive: on_execute(matrix)
# for client in self.room.clients:
# send(self._address, )
elif packet_type == "MOVE":
movement = deserialized_data[1]
game.move(movement)
else:
print("[ERROR] Packet type: {} not recognized".format(packet_type))
def join(self, lobby_id):
joinPacket = UDPpacket.UDPpacket("JOIN")
joinPacket.player = self.player
joinPacket.lobby_id = lobby_id
self.socket.sendto(pickle.dumps(joinPacket), self.server_address)
