def __init__(self, parent=None):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle("Server's list")
self.setFixedSize(440, 250)
self.filled_rows = 0
self.game_client = GameClient(self)
self.tablewidget = QtGui.QTableWidget(1, 4, self)
self.tablewidget.setFixedSize(440, 250)
self.tablewidget.setSelectionBehavior(
QtGui.QAbstractItemView.SelectRows)
HeaderIp = QtGui.QTableWidgetItem("IP")
HeaderRow = QtGui.QTableWidgetItem("Row")
HeaderCol = QtGui.QTableWidgetItem("Col")
HeaderConnect = QtGui.QTableWidgetItem("Win line")
self.tablewidget.setHorizontalHeaderItem(0, HeaderIp)
self.tablewidget.setHorizontalHeaderItem(1, HeaderRow)
self.tablewidget.setHorizontalHeaderItem(2, HeaderCol)
self.tablewidget.setHorizontalHeaderItem(3, HeaderConnect)
cell_clicked = self.tablewidget.cellDoubleClicked
cell_clicked.connect(self.server_choosed)
self.game_client.writeMsg(["FindGame"])
def __init__(self, rows, cols, win_lane, parent=None, sock=None, create=True, IP=""):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle("The Network Game")
self.buttons = []
self.char = ""
self.game_client = None
if sock == None:
self.game_client = GameClient(self)
else:
self.game_client = sock
self.game_client.dialog = self
self.game_desk = GameDesk(rows, cols, win_lane)
self.grid = QtGui.QGridLayout()
self.grid.setSpacing(0)
for row in range(0, rows):
for col in range(0, cols):
button = GameButton(row, col)
button.setEnabled(False)
button.clicked.connect(self.gameButtonClicked)
self.buttons.append(button)
self.grid.addWidget(button, row, col)
self.setLayout(self.grid)
if create:
msg = ["CreateGame", str(rows), str(cols), str(win_lane)]
self.game_client.writeMsg(msg)
else:
msg = ["ConnectToGame", IP]
self.game_client.writeMsg(msg)
class MyTable(QtGui.QDialog):
def __init__(self, parent=None):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle("Server's list")
self.setFixedSize(440, 250)
self.filled_rows = 0
self.game_client = GameClient(self)
self.tablewidget = QtGui.QTableWidget(1, 4, self)
self.tablewidget.setFixedSize(440, 250)
self.tablewidget.setSelectionBehavior(
QtGui.QAbstractItemView.SelectRows)
HeaderIp = QtGui.QTableWidgetItem("IP")
HeaderRow = QtGui.QTableWidgetItem("Row")
HeaderCol = QtGui.QTableWidgetItem("Col")
HeaderConnect = QtGui.QTableWidgetItem("Win line")
self.tablewidget.setHorizontalHeaderItem(0, HeaderIp)
self.tablewidget.setHorizontalHeaderItem(1, HeaderRow)
self.tablewidget.setHorizontalHeaderItem(2, HeaderCol)
self.tablewidget.setHorizontalHeaderItem(3, HeaderConnect)
cell_clicked = self.tablewidget.cellDoubleClicked
cell_clicked.connect(self.server_choosed)
self.game_client.writeMsg(["FindGame"])
def fillTable(self, msg):
print msg
for game in msg:
parse_game = game.split('|')
ip = QtGui.QTableWidgetItem(parse_game[0])
row = QtGui.QTableWidgetItem(parse_game[1])
col = QtGui.QTableWidgetItem(parse_game[2])
win_line = QtGui.QTableWidgetItem(parse_game[3])
self.tablewidget.setItem(self.filled_rows, 0, ip)
self.tablewidget.setItem(self.filled_rows, 1, row)
self.tablewidget.setItem(self.filled_rows, 2, col)
self.tablewidget.setItem(self.filled_rows, 3, win_line)
self.filled_rows += 1
self.tablewidget.setRowCount(self.tablewidget.rowCount() + 1)
def server_choosed(self, row, col):
ip = self.tablewidget.item(row, 0).text()
game_row = int(self.tablewidget.item(row, 1).text())
game_col = int(self.tablewidget.item(row, 2).text())
win_lane = int(self.tablewidget.item(row, 3).text())
ngd = NetGameDialog(game_row, game_col, win_lane, self,
self.game_client, False, ip)
self.setHidden(True)
ngd.exec_()
self.close()
def __init__(self, parent=None):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle("Server's list")
self.setFixedSize(440,250)
self.filled_rows = 0
self.game_client = GameClient(self)
self.tablewidget=QtGui.QTableWidget(1,4,self)
self.tablewidget.setFixedSize(440,250)
self.tablewidget.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
HeaderIp=QtGui.QTableWidgetItem("IP")
HeaderRow=QtGui.QTableWidgetItem("Row")
HeaderCol=QtGui.QTableWidgetItem("Col")
HeaderConnect=QtGui.QTableWidgetItem("Win line")
self.tablewidget.setHorizontalHeaderItem(0,HeaderIp)
self.tablewidget.setHorizontalHeaderItem(1,HeaderRow)
self.tablewidget.setHorizontalHeaderItem(2,HeaderCol)
self.tablewidget.setHorizontalHeaderItem(3,HeaderConnect)
cell_clicked = self.tablewidget.cellDoubleClicked
cell_clicked.connect(self.server_choosed)
self.game_client.writeMsg(["FindGame"])
def __init__(self):
mapFile = 'images/world.tif'
#self.view = WorldView(controller=self, mapFile=mapFile, mapSize=self.mapSize)
self.view = WorldView(controller=self)
self.map = Map(mapFile, screenSize=self.view.screenSize)
self.view.map = self.map
self.landmark = None
self.landmarks = None
self.score = 0
self.maximumDistance = 1000
self.timer = None
self.worstGuess = None
self.client = GameClient()
self.deferred = defer.Deferred()
self.setRounds()
self.crops = {'world':(-180.0, 90.0, 180.0, -90.0),
'us':(-125, 52, -65, 22),
'europe':(-25, 72, 51, 34)
}
class ScriptManager(Singleton):
def __init__(self):
self.game_client = None
def initialize(self, core_manager):
logger.info("ScriptManager::initialize")
self.game_client = GameClient()
self.game_client.initialize(core_manager)
def exit(self):
if self.game_client is not None:
self.game_client.exit()
self.game_client = None
def update(self, delta):
self.game_client.update(delta)
def initialize(self, core_manager):
logger.info("ScriptManager::initialize")
self.game_client = GameClient()
self.game_client.initialize(core_manager)
def __init__(self):
self.yourturn = False
self.player = Player.WHITE
self.pending_drawings = None
self.widgets = None
self.window = None
self.drawingarea = None
self.toolbuttonShowHint = None
self.background = None
self.white = None
self.black = None
self.hint = None
self.scaledbackground = None
self.scaledwhite = None
self.scaledblack = None
self.scaledhint = None
self.width = None
self.height = None
self.size = None
self.ratio = None
self.cellsize = None
self.shift_x = None
self.shift_y = None
self.shift_border = None
self.selection_row = None
self.selection_column = None
self.selection_valid = False
self.request = GameClient()
self.request.indication = self
# Load widgets from Glade file
self.widgets = gtk.glade.XML("interface.glade")
# Shorcuts for exhaustive use of widgets
self.window = self.widgets.get_widget("windowMain")
self.drawingarea = self.widgets.get_widget("drawingarea")
self.toolbuttonShowHint = self.widgets.get_widget("toolbuttonShowHint")
# Show main window
# self.window.maximize()
self.window.show()
# Initialize
self.pending_drawings = list()
self.drawingarea.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
self.load_resources()
self.resize_drawing_area(None, None)
self.update_status_bar()
self.connected = False
# Connect signals to slots
dic = {
"on_imagemenuitemConnect_activate": self.show_dialog_connect,
"on_imagemenuitemDisconnect_activate": self.disconnect,
"on_imagemenuitemAbout_activate": self.show_dialog_about,
"on_toolbuttonConnect_clicked": self.show_dialog_connect,
"on_toolbuttonDisconnect_clicked": self.disconnect,
"on_windowMain_destroy": self.quit,
"on_imagemenuitemQuit_activate": self.quit,
"on_buttonAboutClose_clicked": self.hide_dialog_about,
"on_buttonConnectCancel_clicked": self.hide_dialog_connect,
"on_buttonConnectOk_clicked": self.connect,
"on_drawingarea_expose_event": self.draw,
"on_drawingarea_size_allocate": self.resize_drawing_area,
"on_drawingarea_button_press_event": self.clicked,
"on_drawingarea_motion_notify_event": self.moved,
"on_toolbuttonShowHint_toggled": self.draw,
}
self.widgets.signal_autoconnect(dic)
self.widgets.get_widget("dialogAbout").connect("delete-event", lambda w, e: w.hide() or True)
self.widgets.get_widget("dialogConnect").connect("delete-event", lambda w, e: w.hide() or True)
self.widgets.get_widget("dialogConnecting").connect("delete-event", lambda w, e: w.hide() or True)
self.widgets.get_widget("dialogDisconnection").connect("delete-event", lambda w, e: w.hide() or True)
self.set_ui_disconnected_state()
class ReversiGUI(IGameClientInd):
def __init__(self):
self.yourturn = False
self.player = Player.WHITE
self.pending_drawings = None
self.widgets = None
self.window = None
self.drawingarea = None
self.toolbuttonShowHint = None
self.background = None
self.white = None
self.black = None
self.hint = None
self.scaledbackground = None
self.scaledwhite = None
self.scaledblack = None
self.scaledhint = None
self.width = None
self.height = None
self.size = None
self.ratio = None
self.cellsize = None
self.shift_x = None
self.shift_y = None
self.shift_border = None
self.selection_row = None
self.selection_column = None
self.selection_valid = False
self.request = GameClient()
self.request.indication = self
# Load widgets from Glade file
self.widgets = gtk.glade.XML("interface.glade")
# Shorcuts for exhaustive use of widgets
self.window = self.widgets.get_widget("windowMain")
self.drawingarea = self.widgets.get_widget("drawingarea")
self.toolbuttonShowHint = self.widgets.get_widget("toolbuttonShowHint")
# Show main window
# self.window.maximize()
self.window.show()
# Initialize
self.pending_drawings = list()
self.drawingarea.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
self.load_resources()
self.resize_drawing_area(None, None)
self.update_status_bar()
self.connected = False
# Connect signals to slots
dic = {
"on_imagemenuitemConnect_activate": self.show_dialog_connect,
"on_imagemenuitemDisconnect_activate": self.disconnect,
"on_imagemenuitemAbout_activate": self.show_dialog_about,
"on_toolbuttonConnect_clicked": self.show_dialog_connect,
"on_toolbuttonDisconnect_clicked": self.disconnect,
"on_windowMain_destroy": self.quit,
"on_imagemenuitemQuit_activate": self.quit,
"on_buttonAboutClose_clicked": self.hide_dialog_about,
"on_buttonConnectCancel_clicked": self.hide_dialog_connect,
"on_buttonConnectOk_clicked": self.connect,
"on_drawingarea_expose_event": self.draw,
"on_drawingarea_size_allocate": self.resize_drawing_area,
"on_drawingarea_button_press_event": self.clicked,
"on_drawingarea_motion_notify_event": self.moved,
"on_toolbuttonShowHint_toggled": self.draw,
}
self.widgets.signal_autoconnect(dic)
self.widgets.get_widget("dialogAbout").connect("delete-event", lambda w, e: w.hide() or True)
self.widgets.get_widget("dialogConnect").connect("delete-event", lambda w, e: w.hide() or True)
self.widgets.get_widget("dialogConnecting").connect("delete-event", lambda w, e: w.hide() or True)
self.widgets.get_widget("dialogDisconnection").connect("delete-event", lambda w, e: w.hide() or True)
self.set_ui_disconnected_state()
def set_request(self, request):
self.request = request
def run(self):
gtk.threads_enter()
gtk.main()
gtk.threads_leave()
def quit(self, widget):
self.request.shutdown_req()
gtk.main_quit()
def show_dialog_connect(self, widget):
self.widgets.get_widget("dialogConnect").show()
def hide_dialog_connect(self, widget):
self.widgets.get_widget("dialogConnect").hide()
def show_dialog_about(self, widget):
self.widgets.get_widget("dialogAbout").show()
def hide_dialog_about(self, widget):
self.widgets.get_widget("dialogAbout").hide()
def connect(self, widget):
ip = self.widgets.get_widget("entryIp").get_text()
port = self.widgets.get_widget("spinbuttonPort").get_value_as_int()
if self.request.connect_req(ip, port):
self.widgets.get_widget("dialogConnect").hide()
response = self.widgets.get_widget("dialogConnecting").run()
if response == gtk.RESPONSE_CANCEL:
response = self.widgets.get_widget("dialogConnecting").hide()
self.request.disconnect_req()
self.request.shutdown_req()
self.set_ui_disconnected_state()
self.draw()
def disconnect(self, widget):
self.set_ui_disconnected_state()
self.request.disconnect_req()
self.request.shutdown_req()
def load_resources(self):
self.background = gtk.gdk.pixbuf_new_from_file("res/background.png")
self.white = gtk.gdk.pixbuf_new_from_file("res/white.png")
self.black = gtk.gdk.pixbuf_new_from_file("res/black.png")
self.hint = gtk.gdk.pixbuf_new_from_file("res/hint.png")
# Scales images every time the area is resized and stores some variables to be used in draw method
def resize_drawing_area(self, widgets, events):
self.width, self.height = self.drawingarea.window.get_size()
self.size = max(1, min(self.width, self.height))
self.ratio = self.size / float(self.background.get_width())
self.cellsize = self.white.get_width() * self.ratio
self.scaledbackground = self.background.scale_simple(
int(round(self.size)), int(round(self.size)), gtk.gdk.INTERP_BILINEAR
)
self.scaledwhite = self.white.scale_simple(
int(round(self.cellsize)), int(round(self.cellsize)), gtk.gdk.INTERP_BILINEAR
)
self.scaledblack = self.black.scale_simple(
int(round(self.cellsize)), int(round(self.cellsize)), gtk.gdk.INTERP_BILINEAR
)
self.scaledhint = self.hint.scale_simple(
int(round(self.cellsize)), int(round(self.cellsize)), gtk.gdk.INTERP_BILINEAR
)
self.shift_x = abs(self.width - self.scaledbackground.get_width()) / 2.0
self.shift_y = abs(self.height - self.scaledbackground.get_height()) / 2.0
self.shift_border = 96 * self.ratio # 96px is the width of the border built-in the image
def draw(self, widget=None, events=None):
self.drawingarea.window.draw_pixbuf(
None, self.scaledbackground, 0, 0, int(round(self.shift_x)), int(round(self.shift_y))
)
for i in range(self.request.board_model.get_size()):
for j in range(self.request.board_model.get_size()):
player = self.request.board_model.get(i, j)
if player == Player.WHITE:
self.draw_cell(i, j, self.scaledwhite)
elif player == Player.BLACK:
self.draw_cell(i, j, self.scaledblack)
elif (
self.yourturn
and self.toolbuttonShowHint.get_active()
and GameLogic.is_valid_position(self.request.board_model, i, j, self.player)
):
self.draw_cell(i, j, self.scaledhint)
if (
self.yourturn
and self.selection_row is not None
and self.selection_column is not None
and self.selection_valid
):
self.drawingarea.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
self.draw_cell(
self.selection_row,
self.selection_column,
self.scaledwhite if self.player == Player.WHITE else self.scaledblack,
)
else:
self.drawingarea.window.set_cursor(None)
def draw_cell(self, row, column, image):
self.drawingarea.window.draw_pixbuf(
None,
image,
0,
0,
int(round(self.shift_x + self.shift_border + column * self.cellsize)),
int(round(self.shift_y + self.shift_border + row * self.cellsize)),
)
def moved(self, widget, event):
if self.connected is False:
return
if len(self.pending_drawings) > 0:
return
previous_row = self.selection_row
previous_column = self.selection_column
previous_valid = self.selection_valid
noshift_x = event.x - self.shift_x - self.shift_border
noshift_y = event.y - self.shift_y - self.shift_border
if (
0 <= noshift_x
and noshift_x < self.size - 2 * self.shift_border
and 0 <= noshift_y
and noshift_y < self.size - 2 * self.shift_border
):
self.selection_column = int((noshift_x / self.cellsize) % 8.0)
self.selection_row = int((noshift_y / self.cellsize) % 8.0)
self.selection_valid = (
self.request.board_model.get(self.selection_row, self.selection_column) == Player.EMPTY
)
# GameLogic.is_valid_position(self.request.board_model, self.selection_row, self.selection_column, self.player)
else:
self.selection_column = None
self.selection_row = None
self.selection_valid = False
if previous_valid != self.selection_valid or (
(previous_row != self.selection_row or previous_column != self.selection_column) and self.selection_valid
):
if self.selection_valid and previous_valid is False:
self.drawingarea.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
self.draw_cell(
self.selection_row,
self.selection_column,
self.scaledwhite if self.player == Player.WHITE else self.scaledblack,
)
else:
self.draw()
def clicked(self, widget, event):
if self.selection_row is not None and self.selection_column is not None:
self.request.place_req(self.selection_row, self.selection_column)
self.yourturn = False
self.update_status_bar()
def draw_affected_positions(self):
if len(self.pending_drawings) == 0:
self.update_status_bar()
if self.toolbuttonShowHint.get_active():
self.draw()
return False
else:
player, [row, column] = self.pending_drawings.pop(0)
print "pending", row, column
self.draw_cell(row, column, self.scaledwhite if player == Player.WHITE else self.scaledblack)
return True
def update_status_bar(self):
white_count, black_count = self.request.board_model.count_disks()
if self.player == Player.WHITE:
self.widgets.get_widget("labelWhiteCount").set_text("You (" + str(white_count) + " disks)")
self.widgets.get_widget("labelBlackCount").set_text("Opponent (" + str(black_count) + " disks)")
else:
self.widgets.get_widget("labelWhiteCount").set_text("Opponent (" + str(white_count) + " disks)")
self.widgets.get_widget("labelBlackCount").set_text("You (" + str(black_count) + " disks)")
self.widgets.get_widget("labelTurn").set_text("Your turn" if self.yourturn else "Opponent's turn")
def update_board(self, player, changed_positions):
# self.pending_drawings += changed_positions
self.pending_drawings += [[player, position] for position in changed_positions]
print self.pending_drawings
gobject.timeout_add(100, self.draw_affected_positions)
self.drawingarea.window.set_cursor(None)
self.selection_row = None
self.selection_column = None
self.selection_valid = False
def set_ui_disconnected_state(self):
self.connected = False
self.widgets.get_widget("toolbuttonConnect").set_sensitive(True)
self.widgets.get_widget("toolbuttonDisconnect").set_sensitive(False)
self.widgets.get_widget("imagemenuitemConnect").set_sensitive(True)
self.widgets.get_widget("imagemenuitemDisconnect").set_sensitive(False)
self.widgets.get_widget("imagemenuitemDisconnect").set_sensitive(False)
self.widgets.get_widget("toolbuttonShowHint").set_sensitive(False)
self.widgets.get_widget("toolbuttonShowHint").set_active(False)
def connection_ok(self, player):
self.player = player
self.connected = True
self.widgets.get_widget("dialogConnecting").hide()
self.widgets.get_widget("toolbuttonConnect").set_sensitive(False)
self.widgets.get_widget("toolbuttonDisconnect").set_sensitive(True)
self.widgets.get_widget("imagemenuitemConnect").set_sensitive(False)
self.widgets.get_widget("imagemenuitemDisconnect").set_sensitive(True)
self.widgets.get_widget("toolbuttonShowHint").set_sensitive(True)
self.update_status_bar()
def updated_board(self, player, changed_positions):
self.update_board(player, changed_positions)
def winner(self, winner):
self.set_ui_disconnected_state()
self.request.disconnect_req()
self.request.shutdown_req()
winner_dialog = None
if winner == Player.EMPTY:
winner_dialog = gtk.MessageDialog(
parent=None,
flags=gtk.DIALOG_MODAL,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_OK,
message_format="Draw",
)
else:
if self.player == winner:
winner_dialog = gtk.MessageDialog(
parent=None,
flags=gtk.DIALOG_MODAL,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_OK,
message_format="You won!",
)
else:
winner_dialog = gtk.MessageDialog(
parent=None,
flags=gtk.DIALOG_MODAL,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_OK,
message_format="You lost",
)
winner_dialog.connect("response", lambda widget, response_id: winner_dialog.hide())
winner_dialog.show()
def turn(self):
self.yourturn = True
self.update_status_bar()
def place_error(self):
self.drawingarea.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.X_CURSOR))
gobject.timeout_add(500, lambda: self.drawingarea.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.X_CURSOR)))
def disconnection(self):
self.widgets.get_widget("dialogConnecting").hide()
if self.connected:
self.connected = False
self.set_ui_disconnected_state()
dialog = gtk.MessageDialog(
parent=None,
flags=gtk.DIALOG_MODAL,
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_OK,
message_format="Disconnected from server",
)
dialog.connect("response", lambda widget, response_id: dialog.destroy() or True)
dialog.show()
# IGameClientInd implementation
def connection_ok_ind(self, player):
gobject.idle_add(self.connection_ok, player)
def updated_board_ind(self, player, changed_positions):
print "updated_board_ind", player, changed_positions
gobject.idle_add(self.updated_board, player, changed_positions)
def winner_ind(self, winner):
gobject.idle_add(self.winner, winner)
def turn_ind(self):
gobject.idle_add(self.turn)
def place_error_ind(self):
gobject.idle_add(self.place_error)
def disconnection_ind(self):
gobject.idle_add(self.disconnection)
class NetGameDialog(QtGui.QDialog):
def __init__(self, rows, cols, win_lane, parent=None, sock=None, create=True, IP=""):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle("The Network Game")
self.buttons = []
self.char = ""
self.game_client = None
if sock == None:
self.game_client = GameClient(self)
else:
self.game_client = sock
self.game_client.dialog = self
self.game_desk = GameDesk(rows, cols, win_lane)
self.grid = QtGui.QGridLayout()
self.grid.setSpacing(0)
for row in range(0, rows):
for col in range(0, cols):
button = GameButton(row, col)
button.setEnabled(False)
button.clicked.connect(self.gameButtonClicked)
self.buttons.append(button)
self.grid.addWidget(button, row, col)
self.setLayout(self.grid)
if create:
msg = ["CreateGame", str(rows), str(cols), str(win_lane)]
self.game_client.writeMsg(msg)
else:
msg = ["ConnectToGame", IP]
self.game_client.writeMsg(msg)
def myTurn(self, char):
self.char = char
for b in self.buttons:
b.setEnabled(True)
reply = QtGui.QMessageBox.information(self, "Message", "Your turn!", QtGui.QMessageBox.Yes)
def gameButtonClicked(self):
for b in self.buttons:
b.setEnabled(False)
sender = self.sender()
x = sender.pos_x
y = sender.pos_y
self.makeTurn(x, y, self.char, sender, True)
msg = ["NewTurn", str(x), str(y), self.char]
self.game_client.writeMsg(msg)
def makeTurn(self, x, y, char, button=None, my_turn=False):
x=int(x)
y=int(y)
if button == None:
for b in self.buttons:
#print b.pos_x,b.pos_y
#print x,y
if int(b.pos_x) == int(x) and int(b.pos_y) == int(y):
button = b
label = QtGui.QLabel(char)
label.setFixedSize(25, 25)
label.setAlignment(QtCore.Qt.AlignCenter)
if char == "X":
label.setStyleSheet("QLabel{color: green}")
else:
label.setStyleSheet("QLabel{color: red}")
font = label.font()
font.setPointSize(20)
font.setBold(True)
label.setFont(font)
button.close()
self.grid.addWidget(label, x, y, QtCore.Qt.AlignCenter)
if self.game_desk.newTurn(x, y, char):
reply = QtGui.QMessageBox.information(self, "Message", (char + " WON!"), QtGui.QMessageBox.Yes)
#self.game_client.my_sock.disconnect()
self.close()
if not my_turn:
if char == "X":
self.myTurn("O")
else:
self.myTurn("X")
def PlayTheGame():
print("PLAY TIME")
GameClient()
def connect(host, port): global client client = GameClient(host, port)
class Geography:
def __init__(self):
mapFile = 'images/world.tif'
#self.view = WorldView(controller=self, mapFile=mapFile, mapSize=self.mapSize)
self.view = WorldView(controller=self)
self.map = Map(mapFile, screenSize=self.view.screenSize)
self.view.map = self.map
self.landmark = None
self.landmarks = None
self.score = 0
self.maximumDistance = 1000
self.timer = None
self.worstGuess = None
self.client = GameClient()
self.deferred = defer.Deferred()
self.setRounds()
self.crops = {'world':(-180.0, 90.0, 180.0, -90.0),
'us':(-125, 52, -65, 22),
'europe':(-25, 72, 51, 34)
}
def setRounds(self):
self.gameOver = False
self.rounds = ['africa', 'world capitals', 'world', 'us', 'europe']
self.roundNumber = 0
def start(self):
self.nextRound("Choose the position of the given city. If you miss by more than %i km, the round is over" % self.maximumDistance)
reactor.run()
def quit(self):
reactor.stop()
def mouseEvent(self, event):
if self.landmarks == None or len(self.landmarks) == 0 or self.landmark == None:
print 'do nothing'
elif not self.timeLoop.running:
self.nextRound("Sorry, you didn't guess in time")
elif self.timeLoop.running:
print 'running'
self.timeLoop.stop()
answer = (event.x, event.y)
distance = self.map.getDistance(answer, self.landmark)
if self.worstGuess is None:
self.worstGuess = distance
elif distance > self.worstGuess:
self.worstGuess = distance
self.view.deleteLines()
self.view.drawLines('blue', (event.x, event.y))
x, y = self.map.mapToScreen(self.landmark['lat'], self.landmark['long'])
self.view.drawLines('red', (x, y))
self.view.drawCircle('red', (x, y), 25)
self.view.answer.set("Distance: %d km" % int(distance))
if distance > self.maximumDistance:
self.nextRound("Sorry, you missed by more than %i km" % self.maximumDistance)
else:
self.view.nextRound.set('%i questions left' % len(self.landmarks))
time = self.time
# calculate score
score = self.calculateScore(time, distance)
self.score += score
self.view.scoreText.set("Total Score: %i" % int(self.score))
self.view.showMessage("Score: %i Total: %i" % (int(score), int(self.score)))
self.getQuestion()
def nextRound(self, message):
if len(self.rounds) > 0:
self.landmarks = None
round = self.rounds.pop()
crop = self.crops[round]
self.map.crop(crop)
self.view.makeImage()
self.roundNumber += 1
message = message + "\n\nRound %i\n%s: The 50 most populus cities" % (self.roundNumber, round.capitalize())
try:
self.getLandmarks(round)
except ConnectionError:
self.view.showMessage("Sorry, the stupid game server is not running. Quitting game NOW!")
self.quit()
self.view.showMessage(message)
self.getQuestion()
else:
self.gameOver = True
self.view.showMessage("Game over, now attempting to post your score to the server")
try:
self.postScore()
except ConnectionError:
self.view.showMessage("Sorry, the stupid game server is not running. Quitting game NOW!")
self.quit()
def getQuestion(self):
if self.landmarks == None:
pass
#self.landmarks = self.getLandmarks('world')
#self.getQuestion()
elif len(self.landmarks) > 0:
self.view.deleteLines()
self.getLandmark()
self.view.question.set("%s, %s" % (self.landmark['name'], self.landmark['country']))
self.view.answer.set("")
self.time = 5
self.timeLoop = task.LoopingCall(self.updateTime)
self.timeLoop.start(0.1)
else:
self.nextRound("Good job, you got all 50!")
def updateTime(self):
if self.time <= 0:
self.timeLoop.stop()
else:
self.time -= 0.1
self.view.updateProgressbar(self.time)
def restart(self):
""" """
if self.gameOver:
self.numQuestions = 20
self.score = 0
self.view.deleteLines()
self.view.answer.set("")
self.view.scoreText.set('')
self.view.question.set('')
self.gameOver = False
def postScore(self):
name = self.view.nameInput.get()
if name == '':
name = 'anonymous'
data = "%s %i %.1f" % (name, int(self.score), float(self.worstGuess))
listOfScores = self.client.addScore(data)
scores = "High Scores: \n"
scores += listOfScores
self.view.scoresText.set(scores)
self.view.showScores(scores)
def getLandmarks(self, difficulty):
try:
self.landmarks = self.client.getLandmarks(difficulty)
except ConnectionError:
self.view.showMessage("Sorry, the stupid game server is not running. Quitting game NOW!")
self.quit()
return self.deferred
def getLandmark(self):
self.landmark = self.landmarks.pop()
def calculateScore(self, time, distance):
if distance > 2500:
return 0.0
score = 1000 - pow(distance, 1.2)
timeBonus = 100 * (5 - time)
if score < 0:
score = 0
score = score + timeBonus
#self.view.updateNextRoundBar(score)
return score
class MyTable(QtGui.QDialog):
def __init__(self, parent=None):
QtGui.QDialog.__init__(self, parent)
self.setWindowTitle("Server's list")
self.setFixedSize(440,250)
self.filled_rows = 0
self.game_client = GameClient(self)
self.tablewidget=QtGui.QTableWidget(1,4,self)
self.tablewidget.setFixedSize(440,250)
self.tablewidget.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
HeaderIp=QtGui.QTableWidgetItem("IP")
HeaderRow=QtGui.QTableWidgetItem("Row")
HeaderCol=QtGui.QTableWidgetItem("Col")
HeaderConnect=QtGui.QTableWidgetItem("Win line")
self.tablewidget.setHorizontalHeaderItem(0,HeaderIp)
self.tablewidget.setHorizontalHeaderItem(1,HeaderRow)
self.tablewidget.setHorizontalHeaderItem(2,HeaderCol)
self.tablewidget.setHorizontalHeaderItem(3,HeaderConnect)
cell_clicked = self.tablewidget.cellDoubleClicked
cell_clicked.connect(self.server_choosed)
self.game_client.writeMsg(["FindGame"])
def fillTable(self, msg):
print msg
for game in msg:
parse_game = game.split('|')
ip = QtGui.QTableWidgetItem(parse_game[0])
row = QtGui.QTableWidgetItem(parse_game[1])
col = QtGui.QTableWidgetItem(parse_game[2])
win_line = QtGui.QTableWidgetItem(parse_game[3])
self.tablewidget.setItem(self.filled_rows, 0, ip)
self.tablewidget.setItem(self.filled_rows, 1, row)
self.tablewidget.setItem(self.filled_rows, 2, col)
self.tablewidget.setItem(self.filled_rows, 3, win_line)
self.filled_rows +=1
self.tablewidget.setRowCount(self.tablewidget.rowCount()+1)
def server_choosed(self, row, col):
ip = self.tablewidget.item(row, 0).text()
game_row = int(self.tablewidget.item(row, 1).text())
game_col = int(self.tablewidget.item(row, 2).text())
win_lane = int(self.tablewidget.item(row, 3).text())
ngd = NetGameDialog(game_row,
game_col,
win_lane,
self,
self.game_client,
False,
ip)
self.setHidden(True)
ngd.exec_()
self.close()
print("Player One: Type 1 for Manual Player, 2 for Random Player, 3 for AB Pruning, 4 for MiniMax, 5 for Monte Carlo")
self.player1 = int(raw_input("Enter number here: "))
print("Player Two: Type 1 for Manual Player, 2 for Random Player, 3 for AB Pruning, 4 for MiniMax, 5 for Monte Carlo")
self.player2 = int(raw_input("Enter number here: "))
self.playAmount = int(raw_input("How many times would you like to play?: "))
self.names = ["ManualPlayer","Random","AlphaBeta","MiniMax","MonteCarlo"]
def getStats(self):
print("Player One won " + str(self.p1Count) + " time(s).")
print("Player Two won " + str(self.p2Count) + " time(s).")
print("There were " + str(self.drawCount) + " draws.")
if __name__ == "__main__":
g = GameClientRunner()
for index in range(g.playAmount):
gc = GameClient(g.player1, g.player2)
winner = gc.playGame()
if(winner == 1):
g.p1Count += 1
elif(winner == -1):
g.p2Count += 1
else:
g.drawCount += 1
print(index)
performancePlotter.plotMatchup((g.p1Count,g.p2Count,g.drawCount,g.names[g.player1-1],g.names[g.player2-1]))
g.getStats()
import random
import time
import pygame
from GameClient import GameClient
pygame.init()
pygame.display.set_caption("Snake")
random.seed(time.time())
game = GameClient()
game.play()
pygame.quit()
