def ReceiveRequest(self, data):
toSend = Packet().create()
typeID = data.get("PacketData", "ID")
toSend.set("PacketData", "ID", str(typeID))
Packet(toSend).send(self, "PSET", 0x00000000, 0)
def HandleUpdateStats(self, data):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "UpdateStats")
users = int(data.get("PacketData", "u.[]"))
for user in range(users):
owner = int(data.get("PacketData", "u." + str(user) + ".o"))
statsToUpdate = int(data.get("PacketData", "u." + str(user) + ".s.[]"))
for stat in range(statsToUpdate):
key = str(
data.get("PacketData",
"u." + str(user) + ".s." + str(stat) + ".k"))
value = str(
data.get("PacketData",
"u." + str(user) + ".s." + str(stat) + ".v"))
text = str(
data.get("PacketData",
"u." + str(user) + ".s." + str(stat) + ".t"))
if key == 'c_ltm' or key == 'c_slm' or key == 'c_tut':
db.updateStat(owner, "account", key, value, text)
else:
db.updateStat(owner, "persona", key, value, text)
Packet(toSend).send(self, "rank", 0xC0000000, self.CONNOBJ.plasmaPacketID)
def HandleModifySettings(self):
# TODO: Modify settings in database
toSend = Packet().create()
toSend.set("PacketData", "TXN", "ModifySettings")
Packet(toSend).send(self, "xmsg", 0x80000000, self.CONNOBJ.plasmaPacketID)
def HandleSetPresenceStatus(self):
# TODO: Make the Presence Status database
toSend = Packet().create()
toSend.set("PacketData", "TXN", "SetPresenceStatus")
Packet(toSend).send(self, "pres", 0x80000000, self.CONNOBJ.plasmaPacketID)
def ReceivePacket(self, data):
toSend = Packet().create()
allowed = data.get("PacketData", "ALLOWED")
if str(allowed) == "1":
self.CONNOBJ.joiningPlayers += 1
toSend.set("PacketData", "TID", str(data.get("PacketData", "TID")))
Packet(toSend).send(self, "EGRS", 0x00000000, 0)
def dataReceived(self, data):
packet_type = data[:4]
packets = data.split('\n\x00')
dataObjs = []
if len(packets) > 2:
for packet in packets:
fixedPacketType = packet[:4]
fixedPacket = packet[12:]
if len(fixedPacket) == 0:
break
else:
dataObjs.append({
"data":
Packet(fixedPacket + "\n\x00").dataInterpreter(),
"type":
fixedPacketType
})
else:
dataObjs.append({
"data":
Packet(packets[0][12:] + "\n\x00").dataInterpreter(),
"type":
packet_type
})
self.logger.new_message(
"[" + self.ip + ":" + str(self.port) + "]<-- " + repr(data), 3)
for dataObj in dataObjs:
if dataObj['type'] == 'CONN':
CONN.ReceiveRequest(self, dataObj['data'])
elif dataObj['type'] == 'USER':
USER.ReceiveRequest(self, dataObj['data'])
elif dataObj['type'] == 'CGAM':
CGAM.ReceiveRequest(self, dataObj['data'])
elif dataObj['type'] == 'UBRA':
UBRA.ReceivePacket(self, dataObj['data'])
elif dataObj['type'] == 'UGAM':
UGAM.ReceivePacket(self, dataObj['data'])
elif dataObj['type'] == 'UGDE':
UGDE.ReceivePacket(self, dataObj['data'])
elif dataObj['type'] == 'EGRS':
EGRS.ReceivePacket(self, dataObj['data'])
elif dataObj['type'] == 'PENT':
PENT.ReceivePacket(self, dataObj['data'])
elif dataObj['type'] == 'PLVT':
PLVT.ReceiveRequest(self, dataObj['data'])
else:
self.logger_err.new_message(
"[" + self.ip + ":" + str(self.port) +
']<-- Got unknown message type (' + dataObj['type'] + ")",
2)
def ReceiveRequest(self, data):
toSend = Packet().create()
typeID = data.get("PacketData", "ID")
toSend.set("PacketData", "ID", str(typeID))
toSend.set("PacketData", "ENAB", "F")
toSend.set("PacketData", "ADDR", "*****@*****.**")
Packet(toSend).send(self, "EPGT", 0x00000000, 0)
def ReceiveRequest(self, data):
lobbyID = str(data.get("PacketData", "LID"))
gameID = str(data.get("PacketData", "GID"))
toSend = Packet().create()
toSend.set("PacketData", "TID", str(data.get("PacketData", "TID")))
toSend.set("PacketData", "LID", lobbyID)
toSend.set("PacketData", "GID", gameID)
Packet(toSend).send(self, "ECNL", 0x00000000, 0)
def HandleDeleteMessages(self, data):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "DeleteMessages")
messagesToDelete = int(data.get("PacketData", "messageIds.[]"))
messageIds = []
for message in range(messagesToDelete):
messageIds.append(data.get("PacketData", "messageIds." + str(message)))
db.deleteMessages(messageIds)
Packet(toSend).send(self, "xmsg", 0x80000000, self.CONNOBJ.plasmaPacketID)
def dataReceived(self, data):
packet_type = data[:4]
packet_checksum = data.split(data[12:])[0].split(packet_type)[1]
packet_id = Packet(None).getPacketID(packet_checksum[:4])
packet_length = packet_checksum[4:]
packet_data = data.split(packet_type + packet_checksum)[1]
self.logger.new_message(
"[" + self.ip + ":" + str(self.port) + "]<-- " + repr(data), 3)
dataObj = Packet(packet_data).dataInterpreter()
try:
dataEncrypted = dataObj.get("PacketData", "data")
self.packetData += dataEncrypted.replace("%3d", "=")
if len(self.packetData) == int(dataObj.get("PacketData", "size")):
dataObj = Packet(b64decode(self.packetData) +
"\x00").dataInterpreter()
self.packetData = ""
isValidPacket = True
self.CONNOBJ.plasmaPacketID += 1
else:
isValidPacket = False
except:
if packet_id == 0x80000000: # Don't count it
pass
else:
self.CONNOBJ.plasmaPacketID += 1
isValidPacket = True
if Packet(data).verifyPacketLength(packet_length) and isValidPacket:
TXN = dataObj.get("PacketData", "TXN")
if packet_type == "fsys":
fsys.ReceivePacket(self, dataObj, TXN)
elif packet_type == "acct":
acct.ReceivePacket(self, dataObj, TXN)
elif packet_type == "rank":
rank.ReceivePacket(self, dataObj, TXN)
elif packet_type == "pnow":
pnow.ReceiveRequest(self, dataObj, TXN)
else:
self.logger_err.new_message(
"[" + self.ip + ":" + str(self.port) +
']<-- Got unknown message type (' + packet_type + ")", 2)
elif not isValidPacket:
pass
else:
self.CONNOBJ.plasmaPacketID += 1
self.logger_err.new_message(
"Warning: Packet Length is diffirent than the received data length! ("
+ self.ip + ":" + str(self.port) +
"). Ignoring that packet...", 2)
def ReceivePacket(self, data):
if data.get("PacketData", "START") == "1":
self.CONNOBJ.startedUBRAs += 2
else:
orig_tid = int(data.get("PacketData",
"TID")) - self.CONNOBJ.startedUBRAs / 2
for packet in range(self.CONNOBJ.startedUBRAs):
toSend = Packet().create()
toSend.set("PacketData", "TID", str(orig_tid + packet))
Packet(toSend).send(self, "UBRA", 0x00000000, 0)
self.CONNOBJ.startedUBRAs -= 1
def dataReceived(self, data):
packet_type = data[:4]
packet_data = data[12:]
dataObj = Packet(packet_data).dataInterpreter()
self.logger.new_message(
"[" + self.ip + ":" + str(self.port) + "]<-- " + repr(data), 3)
if packet_type == 'CONN':
CONN.ReceiveRequest(self, dataObj)
elif packet_type == 'USER':
USER.ReceiveRequest(self, dataObj)
elif packet_type == 'LLST':
LLST.ReceiveRequest(self, dataObj)
elif packet_type == 'GLST':
GLST.ReceiveRequest(self, dataObj)
elif packet_type == 'EGAM':
EGAM.ReceiveRequest(self, dataObj)
elif packet_type == 'GDAT':
GDAT.ReceiveRequest(self, dataObj)
elif packet_type == 'ECNL':
ECNL.ReceiveRequest(self, dataObj)
else:
self.logger_err.new_message(
"[" + self.ip + ":" + str(self.port) +
']<-- Got unknown message type (' + packet_type + ")", 2)
def ReceiveRequest(self, data, addr):
packets = generatePackets(Packet(data), "ECHO", 0, 0)
if packets > 1: # More than 1 packet
for packet in packets:
if addr is None:
self.transport.write(packet)
self.logger.new_message(
"[" + self.ip + ":" + str(self.port) + ']--> ' +
repr(packet), 3)
else:
self.transport.write(packet, addr)
self.logger.new_message(
"[" + addr[0] + ":" + str(addr[1]) + ']--> ' +
repr(packet), 3)
else:
if addr is None:
self.transport.write(packets[0])
self.logger.new_message(
"[" + self.ip + ":" + str(self.port) + ']--> ' +
repr(packets[0]), 3)
else:
self.transport.write(packets[0], addr)
self.logger.new_message(
"[" + addr[0] + ":" + str(addr[1]) + ']--> ' +
repr(packets[0]), 3)
def HandleStart(self, data):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "Start")
partition = data.get("PacketData", "partition.partition")
toSend.set("PacketData", "id.id", "1")
toSend.set("PacketData", "id.partition", partition)
self.logger.new_message("[Matchmaking] User started matchmaking!", 2)
Packet(toSend).send(self, "pnow", 0xC0000000, self.CONNOBJ.plasmaPacketID)
Status(self, partition)
def HandleNuGetPersonas(self):
""" Get personas associated with account """
userID = self.CONNOBJ.userID
personas = db.getUserPersonas(userID)
toSend = Packet().create()
toSend.set("PacketData", "TXN", "NuGetPersonas")
toSend.set("PacketData", "personas.[]", str(len(personas)))
personaId = 0
for persona in personas:
toSend.set("PacketData", "personas." + str(personaId), persona)
personaId += 1
Packet(toSend).send(self, "acct", 0x80000000, self.CONNOBJ.plasmaPacketID)
def datagramReceived(self, datagram, addr):
packet_type = datagram[:4]
packet_data = datagram[12:]
dataObj = Packet(packet_data).dataInterpreter()
self.logger.new_message("[" + addr[0] + ":" + str(addr[1]) + "]<-- " + repr(datagram), 3)
if packet_type == 'ECHO':
ECHO.ReceiveRequest(self, dataObj, addr)
else:
self.logger_err.new_message("[" + addr[0] + ":" + str(addr[1]) + "][UDP] Received unknown packet type! (" + packet_type + ")", 2)
def HandleGetLockerURL(self):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "GetLockerURL")
url = "http%3a//" + readFromConfig(
"connection", "emulator_ip") + "/fileupload/locker2.jsp"
toSend.set("PacketData", "URL", url)
Packet(toSend).send(self, "acct", 0x80000000, self.CONNOBJ.plasmaPacketID)
def ReceiveRequest(self, data):
toSend = Packet().create()
lkey = data.get("PacketData", "LKEY")
for client in Clients:
if client.personaSessionKey == lkey:
self.CONNOBJ = client
if self.CONNOBJ is None:
self.transport.loseConnection()
else:
toSend.set("PacketData", "TID", str(data.get("PacketData", "TID")))
toSend.set("PacketData", "NAME", self.CONNOBJ.personaName)
Packet(toSend).send(self, "USER", 0x00000000, 0)
def HandleNuGetTos(self):
""" Get Terms of Use """
toSend = Packet().create()
toSend.set("PacketData", "TXN", "GetTos")
toSend.set("PacketData", "version", "20426_17.20426_17")
if exists("Data/termsOfUse/termsOfUse_" + self.CONNOBJ.locale):
with open("Data/termsOfUse/termsOfUse_" +
self.CONNOBJ.locale) as termsOfUseFile:
termsOfUse = termsOfUseFile.read()
else:
with open("Data/termsOfUse/default") as termsOfUseFile:
termsOfUse = termsOfUseFile.read()
termsOfUse = quote(termsOfUse, safe=" ,.'&/()?;®@§[]").replace(
"%3A", "%3a"
).replace(
"%0A", "%0a"
) + "%0a%0a%09NFS Carbon Server Emulator by Xan%0aBased on Battlefield%3a Bad Company 2 Master Server Emulator by B1naryKill3r / Tratos%0ahttps://github.com/Tratos/BFBC2_MasterServer"
toSend.set("PacketData", "tos", termsOfUse)
Packet(toSend).send(self, "acct", 0x80000000, self.CONNOBJ.plasmaPacketID)
def ReceiveRequest(self, data):
toSend = Packet().create()
lkey = data.get("PacketData", "LKEY")
user = ServerUser().getUserBySessionKey(lkey)
if user == 0:
self.transport.loseConnection()
return
#for client in Clients:
# if client.personaSessionKey == lkey:
# self.CONNOBJ = client
# # self.logger_err.new_message("Client:" + client.personaSessionKey)
#
#if self.CONNOBJ is None:
# self.transport.loseConnection()
#else:
toSend.set("PacketData", "NAME", user.Username)
toSend.set("PacketData", "TID", str(data.get("PacketData", "TID")))
Packet(toSend).send(self, "USER", 0x00000000, 0)
def ReceiveRequest(self, data):
""" Create Game """
toSend = Packet().create()
toSend.set("PacketData", "TID", str(data.get("PacketData", "TID")))
self.CONNOBJ.serverData = ConfigParser()
self.CONNOBJ.serverData.optionxform = str
self.CONNOBJ.serverData.add_section("ServerData")
for item in data.items("PacketData"):
if item[0] != "TID":
self.CONNOBJ.serverData.set("ServerData", item[0],
str(item[1]).replace('"', ""))
toSend.set("PacketData", "MAX-PLAYERS",
str(data.get("PacketData", "MAX-PLAYERS")))
toSend.set("PacketData", "EKEY", "AIBSgPFqRDg0TfdXW1zUGa4%3d")
toSend.set("PacketData", "UGID", str(data.get("PacketData", "UGID")))
toSend.set("PacketData", "JOIN", str(data.get("PacketData", "JOIN")))
if len(data.get("PacketData", "SECRET")) != 0:
toSend.set("PacketData", "SECRET", data.get("PacketData", "SECRET"))
else:
toSend.set(
"PacketData", "SECRET",
"4l94N6Y0A3Il3+kb55pVfK6xRjc+Z6sGNuztPeNGwN5CMwC7ZlE/lwel07yciyZ5y3bav7whbzHugPm11NfuBg%3d%3d"
)
toSend.set("PacketData", "LID", "1")
toSend.set("PacketData", "J", str(data.get("PacketData", "JOIN")))
toSend.set("PacketData", "GID", str(self.CONNOBJ.GameID))
Packet(toSend).send(self, "CGAM", 0x00000000, 0)
self.logger.new_message(
"[" + self.ip + ":" + str(self.port) + "] Created new game!", 1)
def HandleGetPingSites(self):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "GetPingSites")
emuIp = readFromConfig("connection", "emulator_ip")
toSend.set("PacketData", "pingSite.[]", "4")
toSend.set("PacketData", "pingSite.0.addr", emuIp)
toSend.set("PacketData", "pingSite.0.type", "0")
toSend.set("PacketData", "pingSite.0.name", "gva")
toSend.set("PacketData", "pingSite.1.addr", emuIp)
toSend.set("PacketData", "pingSite.1.type", "1")
toSend.set("PacketData", "pingSite.1.name", "nrt")
toSend.set("PacketData", "pingSite.2.addr", emuIp)
toSend.set("PacketData", "pingSite.2.type", "2")
toSend.set("PacketData", "pingSite.2.name", "iad")
toSend.set("PacketData", "pingSite.3.addr", emuIp)
toSend.set("PacketData", "pingSite.3.type", "3")
toSend.set("PacketData", "pingSite.3.name", "sjc")
toSend.set("PacketData", "minPingSitesToPing", "0")
Packet(toSend).send(self, "fsys", 0x80000000, self.CONNOBJ.plasmaPacketID)
def HandleHello(self, data):
toSend = Packet().create()
self.CONNOBJ.clientVersion = data.get("PacketData", "clientVersion")
currentTime = strftime('%b-%d-%Y %H:%M:%S UTC')
toSend.set("PacketData", "domainPartition.domain", "eagames")
toSend.set("PacketData", "messengerIp", readFromConfig("connection", "emulator_ip"))
toSend.set("PacketData", "messengerPort", 0) # Unknown data are being send to this port
toSend.set("PacketData", "domainPartition.subDomain", "BFBC2")
toSend.set("PacketData", "TXN", "Hello")
toSend.set("PacketData", "activityTimeoutSecs", 0) # We could let idle clients disconnect here automatically?
toSend.set("PacketData", "curTime", currentTime)
toSend.set("PacketData", "theaterIp", readFromConfig("connection", "emulator_ip"))
toSend.set("PacketData", "theaterPort", readFromConfig("connection", "theater_server_port"))
Packet(toSend).send(self, "fsys", 0x80000000, self.CONNOBJ.plasmaPacketID)
self.CONNOBJ.IsUp = True
SendMemCheck(self)
def SendPing(self):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "Ping")
if self.CONNOBJ.IsUp:
Packet(toSend).send(self, "fsys", 0x80000000, 0)
def SendMemCheck(self):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "MemCheck")
toSend.set("PacketData", "memcheck.[]", 0)
toSend.set("PacketData", "type", 0)
toSend.set("PacketData", "salt", GenerateRandomString(9))
if self.CONNOBJ.IsUp:
Packet(toSend).send(self, "fsys", 0x80000000, 0)
def HandleStatus(self, data): # TODO - figure out more of actual status calls
toSend.set("PacketData", "TXN", "Status")
Packet(toSend).send(self, "pnow", 0x80000000, self.CONNOBJ.plasmaPacketID)
def HandleStart(self, data): # TODO - Add PlayNow matchmaking handling here... Currently stubbed out with predef. values
global globalServerGameIDGen
global globalServerStartID
#global globalServerLobbyIDGen
globalServerGameIDGen += 1
globalServerStartID += 1
#globalServerLobbyIDGen += 1
# TODO - FIGURE OUT HOW THE WEIGHTS AND TABLE SHENANIGANS WORK
# relevant pnow data the game sends in the first request
filter-matchmaking_state = data.get("PacketData", "players.0.props.{filter-matchmaking_state}") # PossibleValues = 0,1 //Off, On
filter-game_type = data.get("PacketData", "players.0.props.{filter-game_type}") # PossibleValues = 0,1,2 //ranked, unranked, co_op
poolMaxPlayers = data.get("PacketData", "players.0.props.{poolMaxPlayers}")
# preferences provided by the asking player
pref-team_play = data.get("PacketData", "players.0.props.{pref-team_play}") # StringPreference / Labels = 0, 1, ABSTAIN //crew, solo
pref-car_tier = data.get("PacketData", "players.0.props.{pref-car_tier}") # StringPreference / Labels = 1, 2, 3, ABSTAIN
pref-game_mode = data.get("PacketData", "players.0.props.{pref-game_mode}") # StringPreference / Labels = 1, 0, 5, 13, 15, 14, ABSTAIN //Labels = circuit, sprint, speedtrap, canyon duel, pursuit_knockout, pursuit_tag, ABSTAIN
pref-player_dnf = data.get("PacketData", "players.0.props.{pref-player_dnf}") # IntegerPreference
pref-max_online_player = data.get("PacketData", "players.0.props.{pref-max_online_player}") # IntegerPreference
pref-n2o = data.get("PacketData", "players.0.props.{pref-n2o}") # StringPreference / Labels = 0, 1, ABSTAIN //off, on
pref-collision_detection = data.get("PacketData", "players.0.props.{pref-collision_detection}") # StringPreference / Labels = 0, 1, ABSTAIN //off, on
pref-race_type_sprint = data.get("PacketData", "players.0.props.{pref-race_type_sprint}")
pref-race_type_pursuit_tag = data.get("PacketData", "players.0.props.{pref-race_type_pursuit_tag}")
pref-race_type_speedtrap = data.get("PacketData", "players.0.props.{pref-race_type_speedtrap}")
pref-race_type_canyon_due = data.get("PacketData", "players.0.props.{pref-race_type_canyon_due}")
pref-race_type_circuit = data.get("PacketData", "players.0.props.{pref-race_type_circuit}")
pref-race_type_knockout = data.get("PacketData", "players.0.props.{pref-race_type_knockout}")
pref-length = data.get("PacketData", "players.0.props.{pref-length}") # StringPreference / Labels = 1, 2, 3, 4, ABSTAIN //short, medium, long, verylong
pref-help_type = data.get("PacketData", "players.0.props.{pref-help_type}") # StringPreference / Labels = 0, 1, 2, 3 //Labels = no_help, help_in_career, help_in_challenge, help_either
pref-skill = data.get("PacketData", "players.0.props.{pref-skill}") # IntegerPreference
pref-location = = data.get("PacketData", "players.0.props.{pref-location}") # StringPreference / Labels = nfs-wc, nfs-ec, nfs-eu
toSend = Packet().create()
toSend.set("PacketData", "TXN", "Start")
toSend.set("PacketData", "id.id", str(globalServerStartID))
toSend.set("PacketData", "id.partition", "/eagames/NFS-2007")
Packet(toSend).send(self, "pnow", 0x80000000, self.CONNOBJ.plasmaPacketID)
# start Status packet here
toSend = Packet().create()
toSend.set("PacketData", "sessionState", "COMPLETE")
toSend.set("PacketData", "props.{avgFit}", "1.0")
toSend.set("PacketData", "props.{games}.[]", "1")
toSend.set("PacketData", "props.{games}.0.gid", str(globalServerGameIDGen))
toSend.set("PacketData", "TXN", "Status")
toSend.set("PacketData", "props.{}", "3") # total count of props?
toSend.set("PacketData", "props.{games}.0.lid", "1") # apparently BFBC2 server supports only 1 lobby?
toSend.set("PacketData", "props.{resultType}", "JOIN") # resultType can also be NOSERVER if none are found
toSend.set("PacketData", "id.id", str(globalServerStartID))
toSend.set("PacketData", "id.partition", "/eagames/NFS-2007")
# setup host client / server
self.CONNOBJ.serverData = ConfigParser()
self.CONNOBJ.serverData.optionxform = str
self.CONNOBJ.serverData.add_section("ServerData")
self.CONNOBJ.serverData.set("ServerData", "LID", "1")
self.CONNOBJ.serverData.set("ServerData", "GID", str(globalServerGameIDGen))
self.CONNOBJ.serverData.set("ServerData", "PORT", "19018") # not sure if this is constant...
self.CONNOBJ.serverData.set("ServerData", "INT-PORT", "19018")
# PREDEFINED VALUES HERE - this is to be read from the PlayNow packet
self.CONNOBJ.serverData.set("ServerData", "UGID", "4e26106f-8c56-48bd-8615-824d41051c9a") # TODO GENERATE THIS
self.CONNOBJ.serverData.set("ServerData", "ACTIVE-PLAYERS", "0")
self.CONNOBJ.serverData.set("ServerData", "MAX-PLAYERS", "8")
self.CONNOBJ.serverData.set("ServerData", "JOINING-PLAYERS", "1")
self.CONNOBJ.serverData.set("ServerData", "NAME", "NA2CarbonPC-02-019")
self.CONNOBJ.serverData.set("ServerData", "TYPE", "G")
self.CONNOBJ.serverData.set("ServerData", "JOIN", "O")
self.CONNOBJ.serverData.set("ServerData", "B-version", "298_prod_server+22012b18")
self.CONNOBJ.serverData.set("ServerData", "B-U-version", "298_prod_server+22012b18")
self.CONNOBJ.serverData.set("ServerData", "B-U-matchmaking_state", "1")
self.CONNOBJ.serverData.set("ServerData", "B-U-team_play", "1")
self.CONNOBJ.serverData.set("ServerData", "B-U-car_tier", "3")
self.CONNOBJ.serverData.set("ServerData", "B-U-game_mode", "1")
self.CONNOBJ.serverData.set("ServerData", "B-U-player_dnf", "12")
self.CONNOBJ.serverData.set("ServerData", "B-U-max_online_player", "8")
self.CONNOBJ.serverData.set("ServerData", "B-U-n2o", "1")
self.CONNOBJ.serverData.set("ServerData", "B-U-track", "")
self.CONNOBJ.serverData.set("ServerData", "B-U-collision_detection", "1")
self.CONNOBJ.serverData.set("ServerData", "B-U-race_type_sprint", "ct.4.2")
self.CONNOBJ.serverData.set("ServerData", "B-U-race_type_pursuit_tag", "qr.6.1")
self.CONNOBJ.serverData.set("ServerData", "B-U-race_type_speedtrap", "mu.2.2")
self.CONNOBJ.serverData.set("ServerData", "B-U-skill", "500")
self.CONNOBJ.serverData.set("ServerData", "B-U-game_type", "1")
self.CONNOBJ.serverData.set("ServerData", "B-U-race_type_canyon_due", "qr.3.3")
self.CONNOBJ.serverData.set("ServerData", "B-U-race_type_circuit", "ex.5.1")
self.CONNOBJ.serverData.set("ServerData", "B-U-race_type_knockout", "qr.5.1")
self.CONNOBJ.serverData.set("ServerData", "B-U-length", "2")
self.CONNOBJ.serverData.set("ServerData", "B-U-help_type", "0")
Packet(toSend).send(self, "pnow", 0x80000000, 0)
def HandleGetStats(self, data):
# TODO: Make the Stats database
toSend = Packet().create()
toSend.set("PacketData", "TXN", "GetStats")
requestedKeysNumber = int(data.get("PacketData", "keys.[]"))
for i in range(requestedKeysNumber):
requestedKey = data.get("PacketData", "keys." + str(i))
toSend.set("PacketData", "stats." + str(i) + ".key", requestedKey)
toSend.set(
"PacketData", "stats." + str(i) + ".value", "0.0"
) # Until i won't do database for stats - it'll always return 0.0
toSend.set("PacketData", "stats.[]", str(requestedKeysNumber))
Packet(toSend).send(self, "rank", 0x80000000, self.CONNOBJ.plasmaPacketID)
def HandleNuAddAccount(self, data):
""" Final add account request (with data like email, password...) """
toSend = Packet().create()
toSend.set("PacketData", "TXN", "NuAddAccount")
name = data.get('PacketData', 'name') # Email
password = data.get('PacketData', 'password') # Password
bd_Day = data.get('PacketData', 'DOBDay')
bd_Month = data.get('PacketData', 'DOBMonth')
bd_Year = data.get('PacketData', 'DOBYear')
birthday = datetime.strptime(bd_Day + " " + bd_Month + " " + bd_Year,
"%d %m %Y")
timeNow = datetime.now()
country = data.get('PacketData', 'countryCode')
if len(name) > 32 or len(
name) < 3: # Entered user name length is out of bounds
toSend.set("PacketData", "errorContainer.[]", "1")
toSend.set("PacketData", "errorCode", "21")
toSend.set(
"PacketData", "localizedMessage",
'The required parameters for this call are missing or invalid')
toSend.set("PacketData", "errorContainer.0.fieldName", "displayName")
if len(name) > 32:
toSend.set("PacketData", "errorContainer.0.fieldError", "3")
toSend.set("PacketData", "errorContainer.0.value", "TOO_LONG")
self.logger_err.new_message(
"[Register] Email " + name + " is too long!", 1)
else:
toSend.set("PacketData", "errorContainer.0.fieldError", "2")
toSend.set("PacketData", "errorContainer.0.value", "TOO_SHORT")
self.logger_err.new_message(
"[Register] Email " + name + " is too short!", 1)
elif db.checkIfEmailTaken(name): # Email is already taken
toSend.set("PacketData", "errorContainer.[]", "0")
toSend.set("PacketData", "errorCode", "160")
toSend.set("PacketData", "localizedMessage",
'That account name is already taken')
self.logger_err.new_message(
"[Register] User with email " + name + " is already registered!",
1)
elif timeNow.year - birthday.year - (
(timeNow.month, timeNow.day) <
(birthday.month, birthday.day)) < 18: # New user is not old enough
toSend.set("PacketData", "errorContainer.[]", "1")
toSend.set("PacketData", "errorContainer.0.fieldName", "dob")
toSend.set("PacketData", "errorContainer.0.fieldError", "15")
toSend.set("PacketData", "errorCode", "21")
self.logger_err.new_message(
"[Register] User with email " + name +
" is too young to register new account!", 1)
elif len(password) > 16:
toSend.set("PacketData", "errorContainer.[]", "1")
toSend.set("PacketData", "errorCode", "21")
toSend.set(
"PacketData", "localizedMessage",
'The required parameters for this call are missing or invalid')
toSend.set("PacketData", "errorContainer.0.fieldName", "displayName")
toSend.set("PacketData", "errorContainer.0.fieldError", "3")
toSend.set("PacketData", "errorContainer.0.value", "TOO_LONG")
self.logger_err.new_message(
"[Register] Password for user " + name + " is too long!", 1)
elif bool(re.match("^[a-zA-Z0-9]+$", password)) is None:
toSend.set("PacketData", "errorContainer.[]", "1")
toSend.set("PacketData", "errorCode", "21")
toSend.set(
"PacketData", "localizedMessage",
'The required parameters for this call are missing or invalid')
toSend.set("PacketData", "errorContainer.0.fieldName", "displayName")
toSend.set("PacketData", "errorContainer.0.fieldError", "6")
toSend.set("PacketData", "errorContainer.0.value", "NOT_ALLOWED")
self.logger_err.new_message(
"[Register] Password for user " + name +
" contains illegal characters!", 1)
else:
db.registerUser(name, password, str(birthday).split(" ")[0], country)
loginData = db.loginUser(name, password)
self.CONNOBJ.userID = loginData['UserID']
db.addPersona(self.CONNOBJ.userID, name)
self.logger.new_message(
"[Register] User " + name + " was registered successfully!", 1)
Packet(toSend).send(self, "acct", 0x80000000, self.CONNOBJ.plasmaPacketID)
def HandleNuLookupUserInfo(self, data):
toSend = Packet().create()
toSend.set("PacketData", "TXN", "NuLookupUserInfo")
personaName = data.get("PacketData", "userInfo.0.userName")
personaData = db.getPersonaInfo(personaName)
if personaData is not False:
toSend.set("PacketData", "userInfo.[]", "1")
toSend.set("PacketData", "userInfo.0.userName",
str(personaData['personaName']))
toSend.set("PacketData", "userInfo.0.namespace", "battlefield")
toSend.set("PacketData", "userInfo.0.userId",
str(personaData['userID']))
toSend.set("PacketData", "userInfo.0.masterUserId",
str(personaData['personaID']))
else:
toSend.set("PacketData", "userInfo.[]", "1")
toSend.set("PacketData", "userInfo.0.userName", personaName)
Packet(toSend).send(self, "acct", 0x80000000, self.CONNOBJ.plasmaPacketID)