def run(self):
try:
# listen_ip = get_inner_ip() if self.default else self.outer_ip
listen_ip = self.inner_ip
self.server_socket.bind((listen_ip, self.SERVER_PORT))
self.server_socket.listen(1)
# Always accept new clients
threading.Thread(target=self.connect_clients, daemon=True).start()
while True:
if not self.client_list:
continue
read_list, write_list, _ = select(self.client_list,
self.client_list, [])
self.handle_read(read_list)
self.handle_write(write_list)
if len(self.ready_clients) < 2:
continue
else:
# Start the game
game_server = GameServer(listen_ip, self.current_game_port,
self.ready_clients)
self.game_running = True
print(self.client_list)
winner, players = game_server.run()
self.game_running = False
# Update the player's on the winner
if winner:
self.players_wins[winner] += 1
player_left = None
temp_players = {
player: self.players[player]
for player in self.players
if self.players[player] in players
}
for player in self.players:
if player not in temp_players:
player_left = player
if winner:
for client in self.client_list:
client.send(f"Win%{winner}".encode())
else:
self.handle_message("disconnect", player_left)
self.players = temp_players
self.client_list = list(self.players.keys())
# Accept clients again
threading.Thread(target=self.connect_clients,
daemon=True).start()
self.current_game_port += 1
self.ready_clients = []
# self.client_list = new_clients
except Exception as e:
print("bruhhh", e)
def main():
server = GameServer("tcp://*:5555", pyspiel.load_game("tic_tac_toe"))
server_process = Process(target=server.run)
server_process.start()
bot1 = uniform_random.UniformRandomBot(0, np.random.RandomState())
bot2 = uniform_random.UniformRandomBot(1, np.random.RandomState())
players = [bot1, bot2]
game = NetworkGame("tcp://localhost:5555")
state = game.new_initial_state()
while not state.is_terminal():
print('state:')
print(state)
current_player = players[state.current_player()]
print('current player', state.current_player())
action = current_player.step(state)
print('bot action:', action)
state.apply_action(action)
game.exit()
server_process.join()
def start_game_server(url):
server = GameServer(url, pyspiel.load_game("tic_tac_toe"))
process = Process(target=server.run)
process.start()
return process
async def init_webserver(loop):
app = web.Application(loop=loop)
app.router.add_route('*', '/', bridge_endpoint)
return app
async def discord_manager():
while True:
try:
await client.start(config.DISCORD_TOKEN)
except Exception as e:
logger.error(f"Error starting Discord client: {e}")
pass
time.sleep(10)
game_server = GameServer(loop, event_handler=on_gameserver_event)
asyncio.ensure_future(discord_manager())
while True:
try:
app = loop.run_until_complete(init_webserver(loop))
web.run_app(app, host='0.0.0.0', port=config.WEBSERVER_PORT)
except Exception as e:
logger.error(e)
time.sleep(5)
from game_server import GameServer
gameServer = GameServer()
gameServer.start()
while 1:
pass
class WaitingRoomState(BaseState):
# team names
TEAM1 = "yee"
TEAM2 = "OwO"
# the player that game requires
MAX_PLAYER = 2
# key: uuid
# value: {"playerName":str , "ready":boolean , "team":int}
players = {}
players_ready = {}
player_entered = {}
server = GameServer.get_server_ins()
STILL_WAITING = 0
CLIENT_LOADING = 1
ALL_READY = 2
status_code = 0
def __init__(self):
pass
# find wheather player existed
def check_player(self, i: UUID, player_name: str) -> bool:
if i not in get_player_list():
return False
player = get_player(i)
print("create new player uuid:", i.hex)
print("b4 player_ready:", self.players_ready)
print("b4 player_entered", self.player_entered)
player.name = player_name
self.players.update({player.uuid: player})
self.players_ready.update({player.uuid: False})
self.player_entered.update({player.uuid: False})
return True
# set one player's status
def set_ready(self, uuid):
self.players_ready[uuid] = True
def set_enter(self, uuid):
self.player_entered[uuid] = True
# partition player into to team
def partition(self):
print("partitioning...")
first_team = 0
while first_team < self.MAX_PLAYER:
choice = list(self.players.keys())[random.randint(
0, self.MAX_PLAYER - 1)]
if self.players[choice].team != "":
continue
first_team += 1
self.players[choice].team = self.TEAM1
for k in list(self.players.keys()):
if self.players[k].team != "":
continue
self.players[k].team = self.TEAM2
print("partition done , ready to start game")
# aka
def check_if_ready(self):
if len(get_player_list()) < self.MAX_PLAYER:
return False
if self.players_ready == {}:
return False
for k in list(self.players_ready.keys()):
if self.players_ready[k] == False:
return False
if get_player(k).name == "":
return False
print("able to entered!!")
self.partition()
return True
# aka
def check_if_enter(self):
for k in list(self.player_entered.keys()):
if self.player_entered[k] == False:
return False
print("start!!")
return True
def dispatch(self, uuid: UUID, event: dict):
if event["event"] == "connect":
print("receive cooenct event from:", uuid.hex)
res = {}
if self.check_player(uuid, event["playerName"]):
res.update({
"event": "connect",
"playerName": event["playerName"],
"success": True,
"uuid": uuid.hex
})
else:
res.update({
"event": "connect",
"playerName": event["playerName"],
"success": False,
"uuid": ""
})
self.server.send(json.dumps(res), uuid)
if event["event"] == "ready":
print("receive ready from uuid:", uuid.hex)
self.set_ready(uuid)
print("player_ready:", self.players_ready)
if event["event"] == "entered_game":
print("receive entered game from uuid:", uuid.hex)
self.set_enter(uuid)
print("player_entered", self.player_entered)
def send_waiting(self):
msg = {"event": "waiting", "players": []}
for i in get_player_list():
if get_player(i).name == "":
continue
msg["players"].append({
"uuid": i.hex,
"playerName": get_player(i).name,
"ready": self.players_ready[i]
})
for i in msg["players"]:
self.server.send(json.dumps(msg), UUID(i["uuid"]))
def update(self, s: dict) -> str:
if self.status_code == self.STILL_WAITING:
if self.check_if_ready():
msg = {"event": "enterGame"}
self.server.broadcast(json.dumps(msg), None)
self.status_code = self.CLIENT_LOADING
elif self.status_code == self.CLIENT_LOADING:
if self.check_if_enter():
for i in get_player_list():
msg = {"event": "start_game", "team": get_player(i).team}
self.server.send(json.dumps(msg), i)
self.status_code = self.ALL_READY
elif self.status_code == self.ALL_READY:
print("entered stage")
return "Stage"
# broadcast waiting event
self.send_waiting()
if s == {}:
return ""
for k in list(s.keys()):
self.dispatch(k, json.loads(s[k]))
return ""
import sys
from twisted.spread import pb
from twisted.internet import reactor
from twisted.python import log
from game_server import GameServer
if __name__ == '__main__':
log.startLogging(sys.stdout)
log.msg('Initializing the server factory')
server_factory = pb.PBServerFactory(GameServer())
reactor.listenTCP(8789, server_factory)
log.msg('The game service is listening for requests')
reactor.run()
def on_host_game(self):
Game.instance = GameServer(self.background_image)
director.replace(FadeTRTransition(Game.instance.get_scene(), 2))
Game.instance.start()
from game_server import GameServer server = GameServer() server.start()
else:
return
self.send_response(200)
self.send_header("Content-type", Type)
self.end_headers()
self.wfile.write(Data)
class http_server:
def __init__(self, gs):
def handler(*args):
MyHandler(gs, *args)
server = HTTPServer(('', 80), handler)
server.serve_forever()
if __name__ == "__main__":
gs = GameServer()
# Create threads
thread_gs = Thread(target=gs.Clean)
thread_http = Thread(target=http_server, args=(gs, ))
# Start threads
thread_gs.start()
thread_http.start()
# Join threads
thread_gs.join()
thread_http.join()
{"player_ID": 0, "progress": 0.50},
{"player_ID": 1, "progress": 0.66}
]
}
- Game finished: {"type: "update", "game_ID": "", "status": "finished", "winner_ID": 0}
'''
import asyncio, json, traceback, sys
import websockets, random
from collections import defaultdict
from typing import Dict, List, Any
from multiprocessing import Process, Queue, Event
from threading import Thread
from game_server import GameServer
game_server = GameServer()
async def ws_connection_handle(websocket, path):
try:
await websocket.send(json.dumps({"type": "connected"}))
async for message in websocket:
try:
data = json.loads(message)
if data.get("type") == "new_game":
await websocket.send(await game_server.handle_new_game(
websocket, data))
elif data.get("type") == "join_game":
await game_server.handle_join_game(websocket, data)