def main():
game = Game.Game(("player 1", "X"), ("player 2", "O"))
server = GameServer(sys.argv[1], int(sys.argv[2]), game)
server.start()
print(MESSAGE_EXITING)
def main():
"""
This invokes the game and can run either the server or the client.
To run the server run: python run_game.py -t s -i <path to input text file>
To run the client run: python run_game.py -t c -i <name of player>
"""
try:
opts, args = getopt(sys.argv[1:], 't:n:i:')
except GetoptError:
sys.stderr.write('Error parsing options\n')
sys.stderr.write(__doc__)
exit(-1)
name = 'Default_Player'
input_file = None
server_client_flag = None
for o, a in opts:
if o == '-t':
server_client_flag = a
elif o == '-n':
name = a
elif o == '-i':
input_file = a
if server_client_flag == 's':
gs = GameServer(input_file)
elif server_client_flag == 'c':
pl = Player(name)
pl.play_game()
else:
print(
'None or invalid game side provided. Please specify "s" for server or "c" for client'
)
exit(1)
from client import client
from server import GameServer
NAME, IPADDR, LGSM_NAME = "Brazen Floor 2", "192.168.0.155", "kf2server"
class kf2_server(GameServer):
# name = "Killing Floor 2"
def __init__(self, name, ipaddr, lgsm_name):
self.name = "Brazen Floor 2"
self.ipaddr = "192.168.0.155"
self.lgsm_name = "kf2server"
#self.local_ipaddr = "192.168.0.155"
brazenfloor = kf2_server(NAME, IPADDR, LGSM_NAME)
kf2_server.monitor(brazenfloor, "kf2server") #gross
brazenfloor2 = GameServer("Brazen Floor 2", )
import asyncio
import os
import signal
import sys
from server import GameServer
loop = asyncio.get_event_loop()
server = GameServer(loop, sys.argv[1])
loop.add_signal_handler(signal.SIGINT, lambda: asyncio.async(server.stop()))
loop.add_signal_handler(signal.SIGTERM, lambda: asyncio.async(server.stop()))
print("Signal SIGINT or SIGTERM at PID", os.getpid(), "to stop.")
loop.run_forever()
import aioftp
from server import GameServer, CDN
servers = [
GameServer("raiden.game.nfoservers.com", "ftp_user", "ftp_pass"),
GameServer("armstrong.game.nfoservers.com", "ftp_user", "ftp_pass"),
GameServer("mistral.game.nfoservers.com", "ftp_user", "ftp_pass"),
GameServer("ocelot.game.nfoservers.com", "ftp_user", "ftp_pass"),
]
cdn = CDN('ftp.keycdn.com', 'cdn_user', 'cdn_pass')
def test_game_server(self):
game = GameServer()
game.players["anthony"]["pile"]
self.assertTrue(type(game.players["anthony"]["pile"]) is deque)
def init():
'''初始化python server'''
Logger.LogInfo("Py Init")
GameServerRepo.game_server = GameServer.GameServer()
def main():
from server import GameServer
GameServer.run_server(
"127.0.0.1", 52700,
ExampleGame,
banner='=== Guess Number Game ===')
class GameClient(GameModule):
"""Contains game client and pyGame functionality."""
def __init__(self):
self.in_queue = Queue()
self.dispatch_queue = Queue()
GameModule.__init__(self, self.in_queue, self.dispatch_queue)
self.name = 'Client'
self.module_id = GAME.INVALID_ID
self.server_id = GAME.LOCAL_SERVER_ID
self.server_addr = '127.0.0.1'
self.local_server_instance = None
self.dispatch = None
self.network_mgr = None
self.connected = False
# Initialize pyGame
pygame.mixer.pre_init()
pygame.init()
self.screen = pygame.display.set_mode((GAME.WIDTH, GAME.HEIGHT))
pygame.display.set_caption('AstroBlast!')
self.clock = pygame.time.Clock()
pygame.mouse.set_visible(False)
# Initialize pgu.gui
# Title screen GUI
self.title_app = gui.App()
self.title_container = gui.Container(width=GAME.WIDTH,
height=GAME.HEIGHT,
x=0,
y=0)
self.title_sp_button = gui.Button("Single Player",
width=150,
height=100)
self.title_sp_button.connect(gui.CLICK, self.gui_button_clicked,
GAME.GUI_BUTTON_SP)
self.title_container.add(self.title_sp_button, GAME.WIDTH / 2 - 75,
GAME.HEIGHT / 2)
self.title_mp_button = gui.Button("Multiplayer", width=150, height=100)
self.title_mp_button.connect(gui.CLICK, self.gui_button_clicked,
GAME.GUI_BUTTON_MP)
self.title_container.add(self.title_mp_button, GAME.WIDTH / 2 - 75,
2 * GAME.HEIGHT / 3)
self.title_sp_button.connect(gui.CLICK, self.gui_button_clicked,
GAME.GUI_BUTTON_MP)
self.title_app.init(self.title_container, self.screen,
pygame.rect.Rect(0, 0, GAME.WIDTH, GAME.HEIGHT))
# Multiplayer Menu GUI
self.multi_app = gui.App()
self.multi_container = gui.Container(width=GAME.WIDTH,
height=GAME.HEIGHT,
x=0,
y=0)
self.multi_host_button = gui.Button("Host Game", width=100, height=100)
self.multi_host_button.connect(gui.CLICK, self.gui_button_clicked,
GAME.GUI_BUTTON_HOST)
self.multi_container.add(self.multi_host_button, GAME.WIDTH / 3,
GAME.HEIGHT / 3)
self.multi_join_button = gui.Button("Join Game", width=100, height=100)
self.multi_join_button.connect(gui.CLICK, self.gui_button_clicked,
GAME.GUI_BUTTON_JOIN)
self.multi_container.add(self.multi_join_button, GAME.WIDTH / 3 + 150,
GAME.HEIGHT / 3)
self.multi_back_button = gui.Button("Back", width=50, height=50)
self.multi_back_button.connect(gui.CLICK, self.gui_button_clicked,
GAME.GUI_BUTTON_BACK)
self.multi_container.add(self.multi_back_button, 30, GAME.HEIGHT - 80)
self.multi_ip_input = gui.Input("IP address")
self.multi_container.add(self.multi_ip_input, 2 * GAME.WIDTH / 3,
GAME.HEIGHT / 3)
self.multi_port_input = gui.Input("Port")
self.multi_container.add(self.multi_port_input, 2 * GAME.WIDTH / 3,
GAME.HEIGHT / 3 + 50)
self.multi_app.init(self.multi_container, self.screen,
pygame.rect.Rect(0, 0, GAME.WIDTH, GAME.HEIGHT))
# Mouse cursor
cursor, rect = load_image('cursor.png')
self.cursor = cursor
# Images for sprites
self.frames = {
'ship': [
load_image_all_rotations('ship.png'),
load_image_all_rotations('ship_thrust.png')
],
'asteroid_big': [load_image_all_rotations('asteroid_big.png')],
'asteroid_med': [load_image_all_rotations('asteroid_med.png')],
'asteroid_small': [load_image_all_rotations('asteroid_small.png')],
'bullet_g': [load_image_all_rotations('bullet_g.png')],
'explosion': [
load_image_all_rotations('explosion_1.png'),
load_image_all_rotations('explosion_2.png')
]
}
self.background = load_image('bg5.jpg')[0]
# Sounds
self.thrust_sound = pygame.mixer.Sound(
path.join(ASSETSDIR, 'thrust.ogg'))
self.thrust_sound.set_volume(1)
self.shot_sound = pygame.mixer.Sound(path.join(ASSETSDIR, 'shot.wav'))
self.shot_sound.set_volume(0.75)
self.explode_sound = pygame.mixer.Sound(
path.join(ASSETSDIR, 'explode.wav'))
self.explode_sound.set_volume(1)
self.entities = {}
self.unused_entities = []
# Generate some unused entities
for x in range(100):
self.unused_entities.append(EntitySprite(None))
self.sprites = pygame.sprite.Group()
self.player_entity_id = -1
self.player_alive = False
self.player_lives = 0
self.player_score = 0
self.game_state = GAME.STATE_TITLE
def quit(self):
"""Sends quit message and halts client"""
# Make sure Server and Dispatcher quit too
if self.local_server_instance is not None:
self.local_server_instance.running = False
if self.dispatch is not None:
self.dispatch.running = False
if self.network_mgr is not None:
self.network_mgr.running = False
# self.send_msg(MESSAGES.TERMINATE, self.local_server_id)
self.running = False
def process_msg(self, msg_type, sender_id, msg_content):
"""Process an incoming message"""
# Server accepted connection request
if msg_type == MESSAGES.CONNECT_ACCEPT:
self.connected = True
self.send_msg(MESSAGES.CONNECT_SUCCESS, sender_id)
# Server rejected connection request
elif msg_type == MESSAGES.CONNECT_REJECT:
self.log("Connection to server unsuccessful; connection rejected")
# Server is disconnecting
elif msg_type == MESSAGES.SIGNAL_DISCONNECT:
self.disconnect(False)
# Server created an entity
elif msg_type == MESSAGES.CREATE_ENTITY:
expected_content = (MSGCONTENT.ENTITY_ID, MSGCONTENT.ENTITY_TYPE,
MSGCONTENT.X_POS, MSGCONTENT.Y_POS,
MSGCONTENT.ROTATION)
if self.assert_msg_content(msg_type, msg_content,
*expected_content):
entity_id = msg_content[MSGCONTENT.ENTITY_ID]
entity_type = msg_content[MSGCONTENT.ENTITY_TYPE]
pos = (msg_content[MSGCONTENT.X_POS],
msg_content[MSGCONTENT.Y_POS])
rot = msg_content[MSGCONTENT.ROTATION]
# Try to get an unused entity, or create one if there are none
try:
e = self.unused_entities.pop()
except IndexError:
e = EntitySprite(None)
if entity_type == GAME.ENTITY_TEST:
info = SpriteInfo(entity_type, self.frames['ship'], 0, 0)
e.initialize(info, pos, rot, entity_id, entity_type)
self.entities[e.entity_id] = e
self.sprites.add(e)
elif entity_type == GAME.ENTITY_PLAYERSHIP:
info = SpriteInfo(entity_type, self.frames['ship'], 0, 0)
e.initialize(info, pos, rot, entity_id, entity_type)
self.entities[e.entity_id] = e
self.sprites.add(e)
pid = msg_content.get(MSGCONTENT.PLAYER_ID, None)
if pid is not None and pid == self.module_id:
self.player_entity_id = e.entity_id
self.player_alive = True
elif entity_type == GAME.ENTITY_ASTEROID_BIG:
info = SpriteInfo(entity_type, self.frames['asteroid_big'],
0, 0)
e.initialize(info, pos, rot, entity_id, entity_type)
self.entities[e.entity_id] = e
self.sprites.add(e)
elif entity_type == GAME.ENTITY_ASTEROID_MED:
info = SpriteInfo(entity_type, self.frames['asteroid_med'],
0, 0)
e.initialize(info, pos, rot, entity_id, entity_type)
self.entities[e.entity_id] = e
self.sprites.add(e)
elif entity_type == GAME.ENTITY_ASTEROID_SMALL:
info = SpriteInfo(entity_type,
self.frames['asteroid_small'], 0, 0)
e.initialize(info, pos, rot, entity_id, entity_type)
self.entities[e.entity_id] = e
self.sprites.add(e)
elif entity_type == GAME.ENTITY_BULLET:
info = SpriteInfo(entity_type, self.frames['bullet_g'], 0,
0)
e.initialize(info, pos, rot, entity_id, entity_type)
self.entities[e.entity_id] = e
self.sprites.add(e)
self.shot_sound.play()
elif entity_type == GAME.ENTITY_EXPLOSION:
info = SpriteInfo(entity_type, self.frames['explosion'], 1,
500)
e.initialize(info, pos, rot, entity_id, entity_type)
self.entities[e.entity_id] = e
self.sprites.add(e)
self.explode_sound.play()
# Server destroyed an entity
elif msg_type == MESSAGES.DESTROY_ENTITY:
if self.assert_msg_content(msg_type, msg_content,
MSGCONTENT.ENTITY_ID):
entity_id = msg_content[MSGCONTENT.ENTITY_ID]
e = self.entities.pop(entity_id)
if e is not None:
self.sprites.remove(e)
self.unused_entities.append(e)
if e.entity_id == self.player_entity_id:
self.player_alive = False
else:
self.log(
'Received message to destroy sprite for entity %d, but sprite did not exist'
% entity_id)
# An entity rotated by some amount
elif msg_type == MESSAGES.UPDATEROT:
expected_content = (MSGCONTENT.ENTITY_ID, MSGCONTENT.ROTATION)
if self.assert_msg_content(msg_type, msg_content,
*expected_content):
entity_id = msg_content[MSGCONTENT.ENTITY_ID]
rot = msg_content[MSGCONTENT.ROTATION]
e = self.entities.get(entity_id)
if e is not None:
e.rotation = rot
else:
self.log(
'Received message to update rotation for entity %d, but sprite does not exist'
% entity_id)
# An entity moved
elif msg_type == MESSAGES.UPDATEPOS:
expected_content = (MSGCONTENT.X_POS, MSGCONTENT.Y_POS)
if self.assert_msg_content(msg_type, msg_content,
*expected_content):
entity_id = msg_content[MSGCONTENT.ENTITY_ID]
pos = (msg_content[MSGCONTENT.X_POS],
msg_content[MSGCONTENT.Y_POS])
e = self.entities.get(entity_id)
if e is not None:
e.position = pos
else:
self.log(
'Received message to update position for entity %d, but sprite does not exist'
% entity_id)
# Player life count changed
elif msg_type == MESSAGES.UPDATELIVES:
expected_content = MSGCONTENT.PLAYER_LIVES
if self.assert_msg_content(msg_type, msg_content,
expected_content):
self.player_lives = msg_content[MSGCONTENT.PLAYER_LIVES]
# Player score changed
elif msg_type == MESSAGES.UPDATESCORE:
expected_content = MSGCONTENT.PLAYER_SCORE
if self.assert_msg_content(msg_type, msg_content,
expected_content):
self.player_score = msg_content[MSGCONTENT.PLAYER_SCORE]
# Server wants to change the client state to some other setting
elif msg_type == MESSAGES.CHANGE_STATE:
expected_content = MSGCONTENT.GAME_STATE
if self.assert_msg_content(msg_type, msg_content,
expected_content):
self.game_state = msg_content[MSGCONTENT.GAME_STATE]
def disconnect(self, should_send_signal=True):
"""Disconnect this client from a server"""
if should_send_signal:
self.send_msg(MESSAGES.SIGNAL_DISCONNECT, self.server_id,
self.server_addr)
self.connected = False
self.log("Disconnected from server")
self.module_id = GAME.INVALID_ID
# Delete sprites
self.sprites.empty()
self.entities.clear()
def gui_button_clicked(self, button_type):
"""Called when one of the buttons in the UI is clicked"""
# Singleplayer button
if button_type == GAME.GUI_BUTTON_SP:
server_queue = Queue()
remote_queue = Queue()
# Create server and dispatcher
self.dispatch = Dispatcher(self.dispatch_queue, server_queue,
self.in_queue, remote_queue)
self.dispatch.start()
self.out_queue = self.dispatch_queue
self.module_id = GAME.LOCAL_CLIENT_ID
self.local_server_instance = GameServer(self.dispatch,
server_queue)
self.local_server_instance.start()
self.server_id = self.local_server_instance.module_id
self.server_addr = self.local_server_instance.addr
# Start singleplayer by connecting to server
self.send_msg(MESSAGES.REQCONNECT, self.server_id)
# Switch to multiplayer menu
elif button_type == GAME.GUI_BUTTON_MP:
self.game_state = GAME.STATE_MULTIPLAYER_MENU
# Host Multiplayer Session
elif button_type == GAME.GUI_BUTTON_HOST:
port = int(self.multi_port_input.value)
server_queue = Queue()
remote_queue = Queue()
# Create server and dispatcher
self.dispatch = Dispatcher(self.dispatch_queue, server_queue,
self.in_queue, remote_queue)
self.network_mgr = NetworkManager(remote_queue, self.dispatch,
self.dispatch_queue,
NETWORK.MODE_SERVER, port)
self.dispatch.start()
self.network_mgr.start()
self.addr = self.network_mgr.addr
self.server_addr = self.network_mgr.addr
self.out_queue = self.dispatch_queue
self.module_id = GAME.LOCAL_CLIENT_ID
self.local_server_instance = GameServer(self.dispatch,
server_queue)
self.local_server_instance.start()
self.server_id = GAME.LOCAL_SERVER_ID
self.send_msg(MESSAGES.REQCONNECT, self.server_id)
# Join a Multiplayer session
elif button_type == GAME.GUI_BUTTON_JOIN:
server_queue = Queue()
remote_queue = Queue()
self.server_addr = self.multi_ip_input.value
port = int(self.multi_port_input.value)
self.dispatch = Dispatcher(self.dispatch_queue, server_queue,
self.in_queue, remote_queue)
self.dispatch.mode = NETWORK.MODE_CLIENT
self.network_mgr = NetworkManager(remote_queue, self.dispatch,
self.dispatch_queue,
NETWORK.MODE_CLIENT, port,
self.server_addr)
self.dispatch.start()
self.network_mgr.start()
self.out_queue = self.dispatch_queue
self.addr = get_lan_ip()
self.module_id = GAME.REMOTE_CLIENT_ID
self.send_msg(MESSAGES.REQCONNECT, self.server_id)
elif button_type == GAME.GUI_BUTTON_BACK:
self.game_state = GAME.STATE_TITLE
def update(self):
"""Update game state/input state"""
self.clock.tick(GAME.FPS)
# Handle pyGame events
events_found = False
event_str = 'pyGame events: '
for event in pygame.event.get():
# Cache the event name for logging
events_found = True
event_str += pygame.event.event_name(event.type) + ', '
if self.game_state == GAME.STATE_TITLE:
# Pass events to gui
self.title_app.event(event)
elif self.game_state == GAME.STATE_MULTIPLAYER_MENU:
# Pass events to gui
self.multi_app.event(event)
else:
# Handle keyboard events
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.quit()
elif event.key == pygame.K_BACKSLASH:
pass
elif event.key == pygame.K_BACKSPACE:
self.disconnect()
elif event.key == pygame.K_LEFT:
self.send_msg(MESSAGES.INPUT_LEFT_DOWN, self.server_id)
elif event.key == pygame.K_RIGHT:
self.send_msg(MESSAGES.INPUT_RIGHT_DOWN,
self.server_id)
elif event.key == pygame.K_UP:
pship = self.entities.get(self.player_entity_id)
if pship is not None:
pship.current_frame = 1
self.thrust_sound.play()
else:
self.thrust_sound.stop()
self.send_msg(MESSAGES.INPUT_THRUST_DOWN,
self.server_id)
elif event.key == pygame.K_SPACE:
self.send_msg(MESSAGES.INPUT_SHOOT_DOWN,
self.server_id)
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
self.send_msg(MESSAGES.INPUT_LEFT_UP, self.server_id)
elif event.key == pygame.K_RIGHT:
self.send_msg(MESSAGES.INPUT_RIGHT_UP, self.server_id)
elif event.key == pygame.K_UP:
pship = self.entities.get(self.player_entity_id)
if pship is not None:
pship.current_frame = 0
self.thrust_sound.stop()
self.send_msg(MESSAGES.INPUT_THRUST_UP, self.server_id)
elif event.key == pygame.K_SPACE:
self.send_msg(MESSAGES.INPUT_SHOOT_UP, self.server_id)
if event.type == pygame.QUIT:
self.quit()
# Print the event name to stdout
if events_found and GAME.PRINTEVENTS:
print(event_str)
# Clear surface
self.screen.fill(GAME.BLACK)
# Draw background
self.screen.blit(self.background, (0, 0))
# Draw sprites on the surface
# self.ship_sprite.rotation += 10
self.sprites.update()
self.sprites.draw(self.screen)
# Text/GUI
if (self.game_state == GAME.STATE_TITLE):
# Draw GUI
self.title_app.paint(self.screen)
# Draw cursor when appropriate
if pygame.mouse.get_focused():
self.screen.blit(self.cursor, pygame.mouse.get_pos())
elif (self.game_state == GAME.STATE_MULTIPLAYER_MENU):
# Draw GUI
self.multi_app.paint(self.screen)
# Draw cursor when appropriate
if pygame.mouse.get_focused():
self.screen.blit(self.cursor, pygame.mouse.get_pos())
# Draw labels
normal_font = pygame.font.SysFont('Helvetica, Arial', 20, 1)
larger_font = pygame.font.SysFont('Helvetica, Arial', 30, 1)
huge_font = pygame.font.SysFont('Helvetica, Arial,', 150, 1)
if (self.game_state == GAME.STATE_TITLE):
width, height = huge_font.size('AstroBlast!')
title_label = huge_font.render('AstroBlast!', 1, (0, 255, 0))
self.screen.blit(title_label, (GAME.WIDTH / 2 - width / 2, height))
if (self.game_state == GAME.STATE_IN_GAME
or self.game_state == GAME.STATE_GAME_START
or self.game_state == GAME.STATE_PLAYER_DIED):
width, height = normal_font.size('Lives:')
lives_label = normal_font.render('Lives: %d' % self.player_lives,
1, (255, 255, 0))
self.screen.blit(lives_label, (20, 20))
score_label = normal_font.render('Score: %d' % self.player_score,
1, (255, 255, 0))
self.screen.blit(score_label, (20, height + 20))
if self.game_state == GAME.STATE_GAME_START or self.game_state == GAME.STATE_GAME_OVER:
width, height = normal_font.size('Press Fire (Spacebar)')
start_label = normal_font.render('Press Fire (Spacebar)', 1,
(255, 255, 0))
self.screen.blit(start_label,
(GAME.WIDTH / 2 - width / 2, GAME.HEIGHT / 2))
if self.game_state == GAME.STATE_GAME_OVER:
width, height = larger_font.size('Game Over!')
game_over_label = larger_font.render('Game Over!', 1,
(255, 255, 0))
self.screen.blit(
game_over_label,
(GAME.WIDTH / 2 - width / 2, GAME.HEIGHT / 2 - 40))
# Display surface to the screen
pygame.display.flip()
# Handles quitting/etc.
super().update()
def gui_button_clicked(self, button_type):
"""Called when one of the buttons in the UI is clicked"""
# Singleplayer button
if button_type == GAME.GUI_BUTTON_SP:
server_queue = Queue()
remote_queue = Queue()
# Create server and dispatcher
self.dispatch = Dispatcher(self.dispatch_queue, server_queue,
self.in_queue, remote_queue)
self.dispatch.start()
self.out_queue = self.dispatch_queue
self.module_id = GAME.LOCAL_CLIENT_ID
self.local_server_instance = GameServer(self.dispatch,
server_queue)
self.local_server_instance.start()
self.server_id = self.local_server_instance.module_id
self.server_addr = self.local_server_instance.addr
# Start singleplayer by connecting to server
self.send_msg(MESSAGES.REQCONNECT, self.server_id)
# Switch to multiplayer menu
elif button_type == GAME.GUI_BUTTON_MP:
self.game_state = GAME.STATE_MULTIPLAYER_MENU
# Host Multiplayer Session
elif button_type == GAME.GUI_BUTTON_HOST:
port = int(self.multi_port_input.value)
server_queue = Queue()
remote_queue = Queue()
# Create server and dispatcher
self.dispatch = Dispatcher(self.dispatch_queue, server_queue,
self.in_queue, remote_queue)
self.network_mgr = NetworkManager(remote_queue, self.dispatch,
self.dispatch_queue,
NETWORK.MODE_SERVER, port)
self.dispatch.start()
self.network_mgr.start()
self.addr = self.network_mgr.addr
self.server_addr = self.network_mgr.addr
self.out_queue = self.dispatch_queue
self.module_id = GAME.LOCAL_CLIENT_ID
self.local_server_instance = GameServer(self.dispatch,
server_queue)
self.local_server_instance.start()
self.server_id = GAME.LOCAL_SERVER_ID
self.send_msg(MESSAGES.REQCONNECT, self.server_id)
# Join a Multiplayer session
elif button_type == GAME.GUI_BUTTON_JOIN:
server_queue = Queue()
remote_queue = Queue()
self.server_addr = self.multi_ip_input.value
port = int(self.multi_port_input.value)
self.dispatch = Dispatcher(self.dispatch_queue, server_queue,
self.in_queue, remote_queue)
self.dispatch.mode = NETWORK.MODE_CLIENT
self.network_mgr = NetworkManager(remote_queue, self.dispatch,
self.dispatch_queue,
NETWORK.MODE_CLIENT, port,
self.server_addr)
self.dispatch.start()
self.network_mgr.start()
self.out_queue = self.dispatch_queue
self.addr = get_lan_ip()
self.module_id = GAME.REMOTE_CLIENT_ID
self.send_msg(MESSAGES.REQCONNECT, self.server_id)
elif button_type == GAME.GUI_BUTTON_BACK:
self.game_state = GAME.STATE_TITLE