653 lines
27 KiB
Python
653 lines
27 KiB
Python
# -*- coding: utf-8 -*-
|
|
import thread, time, random, traceback, requests, json
|
|
from os.path import exists
|
|
|
|
from PyQt4 import QtGui, QtCore
|
|
|
|
import hardware
|
|
import AOsocket
|
|
import ini
|
|
from game_version import *
|
|
|
|
AOpath = "base/"
|
|
AO2XPpath = "AO2XPbase/"
|
|
#AOpath = "I:/aovanilla1.7.5/client/base/"
|
|
|
|
def decode_ao_str(text):
|
|
return text.replace("<percent>", "%").replace("<pound>", "#").replace("<num>", "#").replace("<and>", "&").replace("<dollar>", "$")
|
|
def encode_ao_str(text):
|
|
return text.replace("%", "<percent>").replace("#", "<pound>").replace("&", "<and>").replace("$", "<dollar>")
|
|
|
|
class PicButton(QtGui.QAbstractButton):
|
|
def __init__(self, pixmap, parent=None):
|
|
super(PicButton, self).__init__(parent)
|
|
self.pixmap = pixmap
|
|
|
|
def paintEvent(self, event):
|
|
painter = QtGui.QPainter(self)
|
|
painter.drawPixmap(event.rect(), self.pixmap)
|
|
|
|
def sizeHint(self):
|
|
return self.pixmap.size()
|
|
|
|
def setPixmap(self, pixmap):
|
|
self.pixmap = pixmap
|
|
|
|
class lobby(QtGui.QWidget):
|
|
gamewindow = None
|
|
tab = 0
|
|
|
|
def __init__(self, parent=None):
|
|
super(lobby, self).__init__(parent)
|
|
self.can_connect = False
|
|
self.svclicked = None
|
|
self.gamewindow = parent
|
|
self.pix_lobby = QtGui.QPixmap(AO2XPpath+'themes/default/lobbybackground.png')
|
|
self.pix_btn_public = QtGui.QPixmap(AO2XPpath+'themes/default/publicservers.png')
|
|
self.pix_btn_favs = QtGui.QPixmap(AO2XPpath+'themes/default/favorites.png')
|
|
self.pix_btn_refresh = QtGui.QPixmap(AO2XPpath+'themes/default/refresh.png')
|
|
self.pix_btn_addfav = QtGui.QPixmap(AO2XPpath+'themes/default/addtofav.png')
|
|
self.pix_btn_connect = QtGui.QPixmap(AO2XPpath+'themes/default/connect.png')
|
|
self.pix_connecting = QtGui.QPixmap(AO2XPpath+'themes/default/loadingbackground.png')
|
|
|
|
self.autoconnect = None
|
|
|
|
if exists(AOpath+'serverlist.txt'):
|
|
with open(AOpath+'serverlist.txt') as file:
|
|
self.favoriteslist = [line.rstrip().split(':') for line in file]
|
|
|
|
autoconnect_id = ini.read_ini_int("AO2XP.ini", "General", "auto connect")
|
|
if autoconnect_id >= 0:
|
|
try:
|
|
self.autoconnect = self.favoriteslist[autoconnect_id]
|
|
except:
|
|
print "[debug] Can't autoconnect to server."
|
|
else:
|
|
self.favoriteslist = []
|
|
#self.favoriteslist = ['127.0.0.1:27017:your server (port 27017)'.split(':'), '127.0.0.1:27016:your server (port 27016)'.split(':'),]
|
|
|
|
self.lobbyimg = QtGui.QLabel(self)
|
|
self.lobbyimg.setPixmap(self.pix_lobby)
|
|
self.lobbyimg.show()
|
|
|
|
self.connectingimg = QtGui.QLabel(self)
|
|
self.connectingimg.setPixmap(self.pix_connecting)
|
|
self.connectingimg.hide()
|
|
|
|
self.clientver = QtGui.QLabel(self)
|
|
self.clientver.setText('AO2XP %s by Headshot' % GAME_VERSION)
|
|
self.clientver.resize(self.clientver.sizeHint())
|
|
self.clientver.move(self.pix_lobby.size().width() - self.clientver.size().width(), 0)
|
|
|
|
self.settingsbtn = QtGui.QPushButton(self)
|
|
self.settingsbtn.setText("Settings")
|
|
self.settingsbtn.resize(self.settingsbtn.sizeHint())
|
|
self.settingsbtn.move(self.clientver.x() - self.settingsbtn.size().width() - 8, 0)
|
|
self.settingsbtn.clicked.connect(self.onSettingsClicked)
|
|
|
|
self.btn_public = PicButton(self.pix_btn_public, self)
|
|
self.btn_public.resize(self.btn_public.sizeHint())
|
|
self.btn_public.move(46, 88)
|
|
self.btn_public.clicked.connect(self.onClicked_public)
|
|
|
|
self.btn_favs = PicButton(self.pix_btn_favs, self)
|
|
self.btn_favs.resize(self.btn_favs.sizeHint())
|
|
self.btn_favs.move(164, 88)
|
|
self.btn_favs.clicked.connect(self.onClicked_favs)
|
|
|
|
self.btn_refresh = PicButton(self.pix_btn_refresh, self)
|
|
self.btn_refresh.resize(self.btn_refresh.sizeHint())
|
|
self.btn_refresh.move(56, 381)
|
|
self.btn_refresh.clicked.connect(self.onClicked_refresh)
|
|
|
|
self.btn_addfav = PicButton(self.pix_btn_addfav, self)
|
|
self.btn_addfav.resize(self.btn_addfav.sizeHint())
|
|
self.btn_addfav.move(194, 381)
|
|
self.btn_addfav.clicked.connect(self.onClicked_addfav)
|
|
|
|
self.btn_connect = PicButton(self.pix_btn_connect, self)
|
|
self.btn_connect.resize(self.btn_connect.sizeHint())
|
|
self.btn_connect.move(332, 381)
|
|
self.btn_connect.clicked.connect(self.onClicked_connect)
|
|
|
|
self.serverlist = QtGui.QListWidget(self)
|
|
self.serverlist.resize(286, 240)
|
|
self.serverlist.move(20, 125)
|
|
p = self.serverlist.viewport().palette()
|
|
p.setColor(self.serverlist.viewport().backgroundRole(), QtGui.QColor(114,114,114))
|
|
self.serverlist.viewport().setPalette(p)
|
|
self.serverlist.itemClicked.connect(self.onClicked_serverlist)
|
|
|
|
self.onlineplayers = QtGui.QLabel(self)
|
|
self.onlineplayers.setStyleSheet('color: white')
|
|
self.onlineplayers.setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignTop)
|
|
self.onlineplayers.setText(random.choice(['hi', 'oh, welcome back', 'hello', 'click on a server to begin', 'yo, how you doing?']))
|
|
self.onlineplayers.move(336, 91)
|
|
self.onlineplayers.resize(173, 16)
|
|
|
|
self.serverinfo = QtGui.QTextEdit(self)
|
|
self.serverinfo.setReadOnly(True)
|
|
p = self.serverinfo.viewport().palette()
|
|
p.setColor(self.serverinfo.viewport().backgroundRole(), QtGui.QColor(0,0,0))
|
|
self.serverinfo.viewport().setPalette(p)
|
|
self.serverinfo.setTextColor(QtGui.QColor("white"))
|
|
self.serverinfo.move(337, 109)
|
|
self.serverinfo.resize(173, 245)
|
|
|
|
self.connectcancel = QtGui.QPushButton(self)
|
|
self.connectcancel.setText('Cancel')
|
|
self.connectcancel.resize(80, 20)
|
|
self.connectcancel.move(220, 220)
|
|
self.connectcancel.clicked.connect(self.onClicked_cancelconnect)
|
|
self.connectcancel.hide()
|
|
|
|
self.actual_serverlist = []
|
|
|
|
self.lobbychatlog = QtGui.QTextEdit(self)
|
|
self.lobbychatlog.setReadOnly(True)
|
|
self.lobbychatlog.setGeometry(2, 445, 513, 198)
|
|
p = self.lobbychatlog.viewport().palette()
|
|
p.setColor(self.lobbychatlog.viewport().backgroundRole(), QtGui.QColor(139,139,139))
|
|
self.lobbychatlog.viewport().setPalette(p)
|
|
self.lobbychatlog.textChanged.connect(self.lobbychatlog_update)
|
|
|
|
self.whitecolor = QtGui.QColor(255, 255, 255)
|
|
|
|
self.font = QtGui.QFont()
|
|
self.font.setFamily(QtCore.QString.fromUtf8('Arial'))
|
|
self.font.setBold(True)
|
|
self.font.setPointSize(14)
|
|
|
|
self.connectprogress = QtGui.QLabel(self)
|
|
self.connectprogress.hide()
|
|
self.connectprogress.setStyleSheet('color: rgb(255, 128, 0);')
|
|
self.connectprogress.setFont(self.font)
|
|
self.connectprogress.setText('Connecting...')
|
|
self.connectprogress.resize(300, 95)
|
|
self.connectprogress.setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignTop)
|
|
self.connectprogress.move(135-20, 92)
|
|
|
|
self.oocname = 'Name'
|
|
self.oocnameinput = QtGui.QLineEdit(self)
|
|
self.oocnameinput.setText(self.oocname)
|
|
self.oocnameinput.move(0, 646)
|
|
self.oocnameinput.resize(91, 19)
|
|
self.oocnameinput.setStyleSheet('background-color: rgb(87, 87, 87);')
|
|
self.oocnameinput.textChanged.connect(self.setoocname)
|
|
|
|
self.lobbychatinput = QtGui.QLineEdit(self)
|
|
self.lobbychatinput.setPlaceholderText("Say something...")
|
|
self.lobbychatinput.move(90, 646)
|
|
self.lobbychatinput.resize(427, 19)
|
|
self.lobbychatinput.setStyleSheet('background-color: rgb(87, 87, 87);')
|
|
self.lobbychatinput.returnPressed.connect(self.lobby_sendchat)
|
|
|
|
self.aoserverinfo = AOServerInfo()
|
|
self.aoserverinfo.moveToGameSignal.connect(self.moveToGame)
|
|
self.aoserverinfo.msgbox_signal.connect(self.showMessageBox)
|
|
self.aoserverinfo.setOnlinePlayers.connect(self.onlineplayers.setText)
|
|
self.aoserverinfo.returnToLobby.connect(self.onClicked_cancelconnect)
|
|
self.aoserverinfo.setConnectProgress.connect(self.connectprogress.setText)
|
|
self.aoserverinfo.readySoon.connect(self.connectcancel.hide)
|
|
self.aoserverinfo.setWindowTitle.connect(self.gamewindow.setWindowTitle)
|
|
self.aoserverinfo.canConnect.connect(self.canConnect)
|
|
|
|
self.masterserver = MasterServer()
|
|
self.masterserver.gotServers.connect(self.onGetServers)
|
|
self.masterserver.gotOOCMsg.connect(self.newOOCMessage)
|
|
self.masterserver.msgbox_signal.connect(self.showMessageBox)
|
|
self.masterserver.start()
|
|
|
|
if self.autoconnect:
|
|
self.aoserverinfo.setIP(self.autoconnect[-1], self.autoconnect[0], self.autoconnect[1], self.autoconnect[2])
|
|
print '[debug]', 'Connecting automatically to ip: ' + self.autoconnect[0] + ', port: ' + str(self.autoconnect[1]) + ", websocket port: " + str(self.autoconnect[2])
|
|
self.aoserverinfo.stop()
|
|
self.aoserverinfo.start()
|
|
|
|
def canConnect(self):
|
|
self.can_connect = True
|
|
if self.autoconnect:
|
|
self.autoconnect = None # We only want to autoconnect on first login after all
|
|
self.onClicked_connect()
|
|
|
|
def onGetServers(self, servers):
|
|
if self.tab == 0: self.serverlist.clear()
|
|
self.actual_serverlist = []
|
|
del servers[0]
|
|
del servers[-1]
|
|
for server in servers:
|
|
name = server["name"]
|
|
desc = server["description"]
|
|
ip = server["ip"]
|
|
port = server["port"]
|
|
ws_port = server["ws_port"] if "ws_port" in server else 0
|
|
|
|
serveritem = QtGui.QListWidgetItem(name)
|
|
if self.tab == 0: self.serverlist.addItem(serveritem)
|
|
self.actual_serverlist.append((ip, port, name, desc, ws_port))
|
|
|
|
def moveToGame(self, stuff):
|
|
tcp, playerlist, charlist, musiclist, background, evidence, areas, features, joinooc, hplist, webAO_bucket = stuff
|
|
self.move_to_game(tcp, playerlist, charlist, musiclist, background, evidence, areas, features, joinooc, hplist, webAO_bucket)
|
|
|
|
def onSettingsClicked(self):
|
|
self.gamewindow.showSettings()
|
|
|
|
def showMessageBox(self, type, title, message):
|
|
if type == 0: #critical
|
|
return QtGui.QMessageBox.critical(self, title, message)
|
|
elif type == 1: #information
|
|
return QtGui.QMessageBox.information(self, title, message)
|
|
elif type == 2: #question
|
|
return QtGui.QMessageBox.question(self, title, message)
|
|
elif type == 3: #warning
|
|
return QtGui.QMessageBox.warning(self, title, message)
|
|
|
|
def onClicked_public(self):
|
|
self.tab = 0
|
|
self.serverlist.clear()
|
|
for sv in self.actual_serverlist:
|
|
self.serverlist.addItem(QtGui.QListWidgetItem(sv[2]))
|
|
|
|
def onClicked_favs(self):
|
|
self.tab = 1
|
|
self.serverlist.clear()
|
|
self.serverinfo.setText("")
|
|
for sv in self.favoriteslist:
|
|
self.serverlist.addItem(QtGui.QListWidgetItem(sv[-1]))
|
|
|
|
def onClicked_refresh(self):
|
|
self.serverlist.clear()
|
|
if self.tab == 0:
|
|
try:
|
|
self.masterserver.ms_tcp.send('ALL#%')
|
|
except:
|
|
self.lobbychatlog.append('failed to refresh server list')
|
|
|
|
elif self.tab == 1:
|
|
if exists(AOpath+'serverlist.txt'):
|
|
with open(AOpath+'serverlist.txt') as file:
|
|
self.favoriteslist = [ line.rstrip().split(':') for line in file ]
|
|
else:
|
|
self.favoriteslist = ['127.0.0.1:27017:your server (port 27017)'.split(':'), '0.0.0.0:27017:serverlist.txt not found on base folder'.split(':')]
|
|
|
|
def onClicked_addfav(self):
|
|
if self.tab == 1 or not self.svclicked:
|
|
if self.tab == 1:
|
|
QtGui.QMessageBox.information(self, "???", "Wait. That's illegal.")
|
|
return
|
|
|
|
for i in range(self.serverlist.count()):
|
|
if self.serverlist.item(i) == self.svclicked:
|
|
ip = self.actual_serverlist[i][0]
|
|
port = str(self.actual_serverlist[i][1])
|
|
name = self.actual_serverlist[i][2]
|
|
ws = self.actual_serverlist[i][-1]
|
|
|
|
for sv in self.favoriteslist:
|
|
if sv[0] == ip and sv[1] == port:
|
|
return QtGui.QMessageBox.information(self, "Error", "This server already exists in your favorites list, named '%s'" % sv[2])
|
|
|
|
self.favoriteslist.append([ip, port, ws, name])
|
|
with open(AOpath+'serverlist.txt', "a") as file:
|
|
file.write("%s:%s:%s:%s\n" % (ip, port, ws, name))
|
|
file.close()
|
|
|
|
def onClicked_connect(self):
|
|
if not self.can_connect:
|
|
return
|
|
self.connectprogress.setText('Connecting...')
|
|
self.connectingimg.show()
|
|
self.connectcancel.show()
|
|
self.connectprogress.show()
|
|
self.btn_public.hide()
|
|
self.btn_favs.hide()
|
|
self.btn_refresh.hide()
|
|
self.btn_addfav.hide()
|
|
self.btn_connect.hide()
|
|
self.serverlist.hide()
|
|
self.onlineplayers.hide()
|
|
self.serverinfo.hide()
|
|
self.clientver.hide()
|
|
self.settingsbtn.hide()
|
|
self.aoserverinfo.tcp.send('askchaa#%')
|
|
|
|
def onClicked_cancelconnect(self):
|
|
self.connectingimg.hide()
|
|
self.connectcancel.hide()
|
|
self.connectprogress.hide()
|
|
self.btn_public.show()
|
|
self.btn_favs.show()
|
|
self.btn_refresh.show()
|
|
self.btn_addfav.show()
|
|
self.btn_connect.show()
|
|
self.serverlist.show()
|
|
self.onlineplayers.show()
|
|
self.serverinfo.show()
|
|
self.clientver.show()
|
|
self.settingsbtn.show()
|
|
|
|
def onClicked_serverlist(self, item):
|
|
self.svclicked = item
|
|
self.can_connect = False
|
|
self.onlineplayers.setText('Retrieving...')
|
|
|
|
text = item.text()
|
|
print '[debug]', 'you clicked %s' % text
|
|
for i in range(self.serverlist.count()):
|
|
if self.serverlist.item(i) == item:
|
|
if self.tab == 0:
|
|
self.serverinfo.setText(self.actual_serverlist[i][3])
|
|
self.aoserverinfo.setIP(text, self.actual_serverlist[i][0], self.actual_serverlist[i][1], self.actual_serverlist[i][-1])
|
|
print '[debug]', 'ind: ' + str(i) + ', ip: ' + self.actual_serverlist[i][0] + ', port: ' + str(self.actual_serverlist[i][1]) + ", websocket port: " + str(self.actual_serverlist[i][-1])
|
|
elif self.tab == 1:
|
|
self.aoserverinfo.setIP(text, self.favoriteslist[i][0], self.favoriteslist[i][1], self.favoriteslist[i][2])
|
|
print '[debug]', 'ind: ' + str(i) + ', ip: ' + self.favoriteslist[i][0] + ', port: ' + str(self.favoriteslist[i][1]) + ", websocket port: " + str(self.favoriteslist[i][2])
|
|
|
|
self.aoserverinfo.stop()
|
|
self.aoserverinfo.start()
|
|
|
|
def move_to_game(self, tcp, playerlist, charlist, musiclist, background, evidence, areas, features=[], oocjoin=[], hplist=[], webAO_bucket=""):
|
|
self.gamewindow.showGame(tcp, playerlist, charlist, musiclist, background, evidence, areas, features, oocjoin, hplist, webAO_bucket)
|
|
|
|
def lobby_sendchat(self):
|
|
#text = self.lobbychatinput.text().toUtf8()
|
|
#self.masterserver.ms_tcp.send('CT#' +self.oocname+ '#' + text + '#%')
|
|
self.lobbychatlog.append("Lobby chat is not supported on the new HTTP-based masterserver.")
|
|
self.lobbychatinput.clear()
|
|
|
|
def setoocname(self):
|
|
self.oocname = self.oocnameinput.text().toUtf8()
|
|
|
|
def lobbychatlog_update(self):
|
|
if self.lobbychatlog.verticalScrollBar().value() == self.lobbychatlog.verticalScrollBar().maximum(): self.lobbychatlog.verticalScrollBar().setValue(self.lobbychatlog.verticalScrollBar().maximum())
|
|
|
|
def newOOCMessage(self, text):
|
|
self.lobbychatlog.append(text)
|
|
|
|
|
|
class MasterServer(QtCore.QThread):
|
|
gotServers = QtCore.pyqtSignal(list)
|
|
gotOOCMsg = QtCore.pyqtSignal(str)
|
|
msgbox_signal = QtCore.pyqtSignal(int, str, str)
|
|
|
|
def __init__(self):
|
|
super(MasterServer, self).__init__()
|
|
|
|
def run(self):
|
|
tempdata = ""
|
|
self.ms_http = requests.get("http://servers.aceattorneyonline.com/servers")
|
|
self.ms_motd = requests.get("http://servers.aceattorneyonline.com/motd")
|
|
|
|
if self.ms_http.ok: self.gotServers.emit(json.loads(self.ms_http.content))
|
|
if self.ms_motd.ok: self.gotOOCMsg.emit(self.ms_motd.content)
|
|
|
|
"""
|
|
try:
|
|
self.ms_tcp.connect(('master.aceattorneyonline.com', 27016))
|
|
except:
|
|
return
|
|
|
|
while True:
|
|
contents = self.ms_tcp.recv(16384)
|
|
if len(contents) == 0:
|
|
print 'masterserver failure'
|
|
return
|
|
|
|
if not contents.endswith("%"):
|
|
tempdata += contents
|
|
continue
|
|
else:
|
|
if tempdata:
|
|
contents = tempdata + contents
|
|
tempdata = ""
|
|
|
|
temp = contents.split('%')
|
|
for msg in temp:
|
|
network = msg.split('#')
|
|
header = network[0]
|
|
|
|
if header == "servercheok":
|
|
self.ms_tcp.send("HI#AO2XP %s#%%ID#AO2XP by Headshot#%s#%%" % (hardware.get_hdid(), GAME_VERSION[1:]))
|
|
self.ms_tcp.send("ALL#%")
|
|
|
|
elif header == 'DOOM':
|
|
print 'banned from masterserver'
|
|
self.msgbox_signal.emit(0, "WHEEZE", "You are exiled from AO")
|
|
self.ms_tcp.close()
|
|
return
|
|
|
|
elif header == 'ALL':
|
|
self.gotServers.emit(network)
|
|
|
|
elif header == 'CT':
|
|
name = decode_ao_str(network[1].decode("utf-8"))
|
|
chatmsg = decode_ao_str(network[2].decode("utf-8"))
|
|
self.gotOOCMsg.emit(name, chatmsg)
|
|
"""
|
|
|
|
class AOServerInfo(QtCore.QThread):
|
|
moveToGameSignal = QtCore.pyqtSignal(list)
|
|
msgbox_signal = QtCore.pyqtSignal(int, str, str)
|
|
setOnlinePlayers = QtCore.pyqtSignal(str)
|
|
setConnectProgress = QtCore.pyqtSignal(str)
|
|
returnToLobby = QtCore.pyqtSignal()
|
|
readySoon = QtCore.pyqtSignal()
|
|
setWindowTitle = QtCore.pyqtSignal(str)
|
|
canConnect = QtCore.pyqtSignal()
|
|
|
|
def __init__(self):
|
|
super(AOServerInfo, self).__init__()
|
|
self.ip = ""
|
|
self.port = 0
|
|
self.ws_port = 0
|
|
self.name = "jm"
|
|
self.webAO_bucket = ""
|
|
self.useWS = False
|
|
self.disconnect = False
|
|
|
|
def setIP(self, name, ip, port, ws_port=0):
|
|
self.ip = ip
|
|
self.port = int(port)
|
|
self.ws_port = int(ws_port)
|
|
self.name = name
|
|
|
|
def stop(self):
|
|
self.disconnect = True
|
|
if self.isRunning():
|
|
self.terminate()
|
|
self.wait()
|
|
|
|
def run(self):
|
|
self.disconnect = False
|
|
self.tcp = AOsocket.AOwebSocket()
|
|
try:
|
|
if self.ws_port == 0: raise Exception # make it jump to except: and use TCP
|
|
print "[debug]", "trying websocket..."
|
|
self.tcp.connect(self.ip, self.ws_port)
|
|
except:
|
|
self.tcp = AOsocket.AOtcpSocket()
|
|
try:
|
|
print "[debug]", "trying TCP..."
|
|
self.tcp.connect(self.ip, self.port)
|
|
except:
|
|
self.setOnlinePlayers.emit("couldn't retrieve players")
|
|
return
|
|
|
|
print "[debug]", "connected! websocket: %s" % self.tcp.isWS
|
|
self.tcp.sock.settimeout(0.1)
|
|
|
|
got_stuff = False
|
|
gotChars = False
|
|
hplist = []
|
|
joinooc = []
|
|
areas = [[], [], [], []]
|
|
features = []
|
|
evidence = []
|
|
playerlist = {}
|
|
pingtimer = 150
|
|
readytick = -1
|
|
|
|
while True:
|
|
if self.disconnect:
|
|
try: self.tcp.close()
|
|
except: pass
|
|
return
|
|
|
|
pingtimer -= 1
|
|
if pingtimer == 0:
|
|
pingtimer = 150
|
|
self.tcp.send('CH#%')
|
|
|
|
if readytick > -1:
|
|
readytick -= 1
|
|
if readytick == 0:
|
|
readytick = -1
|
|
try:
|
|
self.moveToGameSignal.emit([self.tcp, playerlist, charlist, musiclist, background, evidence, areas, features, joinooc, hplist, self.webAO_bucket])
|
|
except Exception as err:
|
|
self.msgbox_signal.emit(0, "Error caught while loading", traceback.format_exc(err))
|
|
self.returnToLobby.emit()
|
|
return
|
|
|
|
self.setWindowTitle.emit("AO2XP: "+self.name)
|
|
return
|
|
|
|
error, totals = self.tcp.recv()
|
|
if error == -2: # timeout
|
|
continue
|
|
elif error == -1: # disconnected
|
|
self.setOnlinePlayers.emit("Something wrong happened" if not got_stuff else "Connection lost")
|
|
return
|
|
|
|
for network in totals:
|
|
header = network[0]
|
|
|
|
if header == 'PN':
|
|
players = int(network[1])
|
|
maxplayers = int(network[2])
|
|
self.canConnect.emit()
|
|
self.setOnlinePlayers.emit('%d/%d players online' % (players, maxplayers))
|
|
self.tcp.send("ASS#%") # get webAO bucket
|
|
got_stuff = True
|
|
|
|
elif header == "decryptor":
|
|
self.tcp.send("HI#AO2XP %s#%%" % hardware.get_hdid())
|
|
|
|
elif header == "ASS": # ha ha ha...
|
|
self.webAO_bucket = network[1]
|
|
print self.webAO_bucket
|
|
|
|
elif header == "ID":
|
|
self.tcp.send("ID#AO2XP#%s#%%" % "2.11.0") # need to send this to tsuserver3 servers in order to get feature list (FL)
|
|
|
|
elif header == "FL":
|
|
features = network[1:]
|
|
print features
|
|
|
|
elif header == 'BD':
|
|
reason = network[1].decode("utf-8") if len(network) > 1 else "Failed to receive ban reason (old server version?)" # new in AO2 2.6
|
|
self.setOnlinePlayers.emit('Banned')
|
|
self.msgbox_signal.emit(0, "Banned", "Reason:\n"+reason)
|
|
self.tcp.close()
|
|
return
|
|
|
|
elif header == 'SI':
|
|
if self.disconnect:
|
|
continue
|
|
maxchars = int(network[1])
|
|
maxevidence = int(network[2])
|
|
maxmusic = int(network[3])
|
|
self.setConnectProgress.emit('Requesting character list (%d)...' % maxchars)
|
|
self.tcp.send('RC#%')
|
|
print '[client]', '%d characters, %d pieces of evidence and %d songs' % (maxchars, maxevidence, maxmusic)
|
|
|
|
elif header == 'SC':
|
|
if self.disconnect:
|
|
continue
|
|
del network[0]
|
|
gotChars = True
|
|
charlist = [ [char.split('&')[0].decode('utf-8'), 0, "male"] for char in network ]
|
|
|
|
self.setConnectProgress.emit('Requesting music list (%d)...' % maxmusic)
|
|
self.tcp.send('RM#%')
|
|
print '[client]', 'received characters (%d)' % len(charlist)
|
|
|
|
elif header == 'SM':
|
|
if self.disconnect:
|
|
continue
|
|
del network[0]
|
|
|
|
musiclist = [music for music in network]
|
|
|
|
self.setConnectProgress.emit('Finishing...')
|
|
self.tcp.send('RD#%')
|
|
print '[client]', 'received songs (%d)' % len(musiclist)
|
|
|
|
elif header == 'CharsCheck':
|
|
if self.disconnect or not gotChars:
|
|
continue
|
|
del network[0]
|
|
for i in range(len(network)):
|
|
charlist[i][1] = int(network[i])
|
|
|
|
elif header == 'BN':
|
|
if self.disconnect:
|
|
continue
|
|
background = network[1]
|
|
print '[client]', 'courtroom background: %s' % background
|
|
|
|
elif header == 'LE':
|
|
if self.disconnect:
|
|
continue
|
|
del network[0]
|
|
if len(network) > 0:
|
|
evidence = [evi.split("&") for evi in network]
|
|
else:
|
|
evidence = []
|
|
|
|
for evi in evidence:
|
|
while len(evi) < 3: # new AO 2.9 bug where they never correctly escaped evidence name/desc/image on FantaProtocol
|
|
evi += [""]
|
|
evi[0] = decode_ao_str(evi[0].decode("utf-8"))
|
|
evi[1] = decode_ao_str(evi[1].decode("utf-8"))
|
|
evi[2] = decode_ao_str(evi[2].decode("utf-8"))
|
|
print '[client]', 'received evidence'
|
|
|
|
elif header == 'HP':
|
|
if self.disconnect:
|
|
continue
|
|
type = int(network[1])
|
|
health = int(network[2])
|
|
hplist.append([type, health])
|
|
|
|
elif header == "ARUP": #AO2 2.6 new feature: area update
|
|
del network[0]
|
|
type = int(network[0])
|
|
if type == 0: #player count
|
|
areas[type] = [network[i] for i in range(1, len(network))]
|
|
else: #area status, casemakers or locked area
|
|
areas[type] = [network[i] for i in range(1, len(network))]
|
|
|
|
elif header == 'DONE':
|
|
if self.disconnect:
|
|
continue
|
|
self.setConnectProgress.emit('Done, loading...')
|
|
self.readySoon.emit()
|
|
print '[client]', 'finished requesting data, loading game...'
|
|
readytick = 4
|
|
|
|
elif header == 'CT':
|
|
if self.disconnect:
|
|
continue
|
|
name = network[1].decode("utf-8").replace('<dollar>', '$').replace('<percent>', '%').replace('<and>', '&').replace('<num>', '#').replace('<pound>', '#')
|
|
chatmsg = network[2].decode("utf-8").replace('<dollar>', '$').replace('<percent>', '%').replace('<and>', '&').replace('<num>', '#').replace('<pound>', '#')
|
|
joinooc.append("%s: %s" % (name, chatmsg))
|
|
|
|
elif header == 'PU':
|
|
del network[0]
|
|
pid = network[0]
|
|
if not pid in playerlist:
|
|
playerlist[pid] = []
|
|
playerlist[pid].append(network[2].decode('utf-8'))
|
|
|