def sync_inventory_down(self): db = sqlite3.connect(str(str(get_project_root()) + "/Garmadon.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "SELECT * FROM Inventory WHERE CharID = ?" dbcmd.execute(query, (self.id,)) value = dbcmd.fetchall() self.inventory.clear() for item in value: newitem = {} newitem['ItemLOT'] = item['ItemLOT'] newitem['Quantity'] = item['Quantity'] newitem['IsEquipped'] = item['IsEquipped'] newitem['IsLinked'] = item['IsLinked'] newitem['Slot'] = item['Slot'] newitem['ItemID'] = item['ItemID'] db = sqlite3.connect(str(str(get_project_root()) + "/clientfiles/cdclient.sqlite")) dbcmd = db.cursor() query = "SELECT itemType FROM ItemComponent WHERE id = ?" dbcmd.execute(query, (item['ItemLOT'],)) item_type = dbcmd.fetchall() newitem['Type'] = item_type[0][0] self.inventory.append(newitem) dbcmd.close()
def create_character(self, character): db = sqlite3.connect( str(str(get_project_root()) + "/PikaChewniverse.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "SELECT CharID FROM Characters WHERE UnapprovedName = ?" dbcmd.execute(query, (character['UnapprovedName'], )) unapprovednameexists = dbcmd.fetchone() query = "SELECT CharID FROM Characters WHERE Name = ?" dbcmd.execute(query, (character['Name'], )) nameexists = dbcmd.fetchone() dbcmd.close() if unapprovednameexists is None: if nameexists is None: db = sqlite3.connect( str(str(get_project_root()) + "/PikaChewniverse.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "INSERT INTO Characters (AccountID, ObjectID, Name, UnapprovedName, ShirtColor, ShirtStyle, PantsColor, HairStyle, HairColor, LeftHand, RightHand, Eyebrows, Eyes, Mouth) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" dbcmd.execute(query, ( self.account_id, character['ObjectID'], character['Name'], character['UnapprovedName'], character['ShirtColor'], character['ShirtStyle'], character['PantsColor'], character['HairStyle'], character['HairColor'], character['LeftHand'], character['RightHand'], character['Eyebrows'], character['Eyes'], character['Mouth'], )) db.commit() dbcmd.close() self.sync_characters_down() for char in self.characters: if char.name == character['Name']: self.current_character = char dbcmd = db.cursor() query = "INSERT INTO Stats (CharID) VALUES (?)" dbcmd.execute(query, (char.id, )) db.commit() dbcmd.close() return 0x00 # Note: Success else: return 0x04 # Note: Custom name in use else: return 0x03 # Note: Unapproved name in use
def __init__(self, zone_id): self._zone_id = zone_id config = ConfigParser() config.read(str(get_project_root()) + "/config.ini") self.path = str(get_project_root()) + config[self._zone_id]['LUZ'] self.version = None self.version_control = None self.world_id = None self.zone = Zone()
def add_item(self, item_data): self.sync_inventory_down() db = sqlite3.connect(str(str(get_project_root()) + "/clientfiles/cdclient.sqlite")) dbcmd = db.cursor() query = "SELECT stackSize FROM ItemComponent WHERE id = ?" dbcmd.execute(query, (item_data['ItemLOT'],)) stack_size = dbcmd.fetchall() added = False for item in self.inventory: if item_data['ItemLOT'] == item['ItemLOT'] and item['Quantity'] < stack_size[0]: item['Quantity'] = item['Quantity'] + item_data['Quantity'] db = sqlite3.connect(str(str(get_project_root()) + "/Garmadon.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "UPDATE Inventory SET Quantity = ? WHERE ItemID = ?" dbcmd.execute(query, (item['Quantity'], item['ItemLOT'],)) db.commit() dbcmd.close() added = True break db = sqlite3.connect(str(str(get_project_root()) + "/Garmadon.sqlite")) dbcmd = db.cursor() query = "SELECT InventorySpace FROM Characters WHERE CharID = ?" dbcmd.execute(query, (self.id,)) inventoy_space = dbcmd.fetchone() if len(self.inventory) < inventoy_space[0]: if added is False: db = sqlite3.connect(str(str(get_project_root()) + "/Garmadon.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "INSERT INTO Inventory (CharID, ItemLOT, IsEquipped, IsLinked, Quantity, Slot, ItemID) VALUES (?, ?, ?, ?, ?, ?, ?)" dbcmd.execute(query, ( self.id, item_data['ItemLOT'], item_data['IsEquipped'], item_data['IsLinked'], item_data['Quantity'], len(self.inventory) + 1, random.randrange(100000, 100000000),)) db.commit() dbcmd.close() added = True self.sync_inventory_down() return added
def sync_characters_down(self): db = sqlite3.connect(str(str(get_project_root()) + "/Garmadon.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "SELECT * FROM Characters WHERE AccountID = ?" dbcmd.execute(query, (self.account_id, )) value = dbcmd.fetchall() dbcmd.close() self.characters.clear() if value is not None: for character in value: char = Character() char.account_id = character['AccountID'] char.id = character['CharID'] char.object_id = character['ObjectID'] char.name = character['Name'] char.unapproved_name = character['UnapprovedName'] char.shirt_color = character['ShirtColor'] char.shirt_style = character['ShirtStyle'] char.pants_color = character['PantsColor'] char.hair_style = character['HairStyle'] char.hair_color = character['HairColor'] char.left_hand = character['LeftHand'] char.right_hand = character['RightHand'] char.eyebrows = character['Eyebrows'] char.eyes = character['Eyes'] char.mouth = character['Mouth'] char.last_zone = character['LastZone'] char.health = character['Health'] char.max_health = character['MaxHealth'] char.armor = character['Armor'] char.max_armor = character['MaxArmor'] char.imagination = character['Imagination'] char.max_imagination = character['MaxImagination'] char.inventory_space = character['InventorySpace'] char.u_score = character['UScore'] char.gm_level = character['GMLevel'] char.reputation = character['Reputation'] char.level = character['Level'] dbcmd = db.cursor() query = "SELECT * FROM Stats WHERE CharID = ?" dbcmd.execute(query, (char.id, )) char.stats = dbcmd.fetchone() dbcmd.close() char.sync_inventory_down() self.characters.append(char)
def getAccountFromID(ID): # Template insert (1) try: db = sqlite3.connect(str(get_project_root()) + "/Garmadon.sqlite") cursor = db.cursor() query = "select * from Accounts where id = ?" cursor.execute(query, (ID,)) data = cursor.fetchall() for row in data: id = row[0] Username = row[1] Email = row[2] Password = row[3] SessionKey = row[4] FirstLogin = row[5] Banned = row[6] Admin = row[7] CurrentCharacterID = row[8] jsonData = '''{"ID": id, "Username": Username, "Email": Email, "Password": Password, "SessionKey": SessionKey, "FirstLogin": FirstLogin, "Banned": Banned, "Admin": Admin, "CurrentCharacterID": CurrentCharacterID, "Status": "Success"}''' return jsonData cursor.close() except: return '{"Status": "Fail", "Reason": "Account doesn\'t exist"}'
def get_spawners(self): config = ConfigParser() config.read(str(get_project_root()) + "/config.ini") path = str(get_project_root()) + config[self.zone_id]['LVL'] with open(path + self.file_name, "rb") as lvl: data = lvl.read() luz_len = len(data) stream = ReadStream(data, unlocked=True) header = stream.read(bytes, length=4) stream.read_offset = 0 if header == b"CHNK": while not stream.all_read(): assert stream.read_offset // 8 % 16 == 0 # seems everything is aligned like this? start_pos = stream.read_offset // 8 stream.read(bytes, length=4) # b"CHNK" self.chunk_type = stream.read(c_uint) stream.read(c_ushort) stream.read(c_ushort) self.chunk_length = stream.read(c_uint) data_pos = stream.read(c_uint) stream.read_offset = data_pos * 8 assert stream.read_offset // 8 % 16 == 0 if self.chunk_type == 1000: pass elif self.chunk_type == 2000: pass elif self.chunk_type == 2001: self.parse_2001(stream) elif self.chunk_type == 2002: pass stream.read_offset = ( start_pos + self.chunk_length) * 8 # go to the next CHNK else: self.parse_old_lvl(stream) self.parse_2001(stream)
def set_last_zone(self, zone_id): self.last_zone = zone_id db = sqlite3.connect(str(get_project_root()) + "/Garmadon.sqlite") db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "UPDATE Characters SET LastZone = ? WHERE CharID = ?" dbcmd.execute(query, (zone_id, self.id,)) db.commit() dbcmd.close()
def set_current_character_id(self, charid): self.current_character_id = charid db = sqlite3.connect(str(get_project_root()) + "/Garmadon.sqlite") db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "UPDATE Accounts SET CurrentCharacterID = ? WHERE Username = ?" dbcmd.execute(query, ( charid, self.username, )) db.commit() dbcmd.close()
def set_session_key(self, key): self.session_key = key db = sqlite3.connect(str(get_project_root()) + "/Garmadon.sqlite") db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "UPDATE Accounts SET SessionKey = ? WHERE Username = ?" dbcmd.execute(query, ( key, self.username, )) db.commit() dbcmd.close()
def set_position(self, position, rotation): self.x_pos = position.x self.y_pos = position.y self.z_pos = position.z self.x_rot = rotation.x self.y_rot = rotation.y self.z_rot = rotation.z self.w_rot = rotation.w db = sqlite3.connect(str(get_project_root()) + "/Garmadon.sqlite") db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "UPDATE Characters SET X = ?, Y = ?, Z = ? WHERE CharID = ?" dbcmd.execute(query, (self.x_pos, self.y_pos, self.z_pos, self.id,)) db.commit() dbcmd.close()
def sync_account_values_down(self): db = sqlite3.connect(str(str(get_project_root()) + "/Garmadon.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "SELECT * FROM Accounts WHERE Username = ?" dbcmd.execute(query, (self.temp_username, )) value = dbcmd.fetchone() dbcmd.close() if value is not None: self.account_id = value['id'] self.username = value['Username'] self.email = value['Email'] self.password = value['Password'] self.session_key = value['SessionKey'] self.first_login = value['FirstLogin'] self.is_banned = value['Banned'] self.is_admin = value['Admin'] self.current_character_id = value['CurrentCharacterID']
def getSpecificAccountData(Username, value): # Template insert ("Player", "id") if (getAccountFromUsername(Username)): def switchcase(value): switcher = { "id": 0, "username": 1, "email": 2, "password": 3, "sessionKey": 4, "firstLogin": 5, "banned": 6, "admin": 7, "currentcharacterid": 8 } return switcher.get(value, "Error") def switchcase2(value): switcher = { 0: "ID", 1: "Username", 2: "Email", 3: "Password", 4: "SessionKey", 5: "FirstLogin", 6: "Banned", 7: "Admin", 8: "CurrentCharacterID" } return switcher.get(value, "Error") db = sqlite3.connect(str(get_project_root()) + "/Garmadon.sqlite") cursor = db.cursor() query = "select * from Accounts where Username = ?" cursor.execute(query, (Username,)) data = cursor.fetchall() for row in data: if switchcase(value) == "Error": return '{"Status": "Fail", "Reason": "Data unreachable"}' else: return '''{"Username": Username, switchcase2(switchcase(value)): row[switchcase(value)], "Status": "Success"}''' else: return '{"Status": "Fail", "Reason": "Account doesn\'t exist"}'
def createAccount(Username, Email, Password): # Template insert ("Encry", "*****@*****.**", "password") if (getAccountFromUsername(Username)): return '{"Status": "Fail", "Reason": "Account already exists"}' else: try: db = sqlite3.connect(str(get_project_root()) + "/Garmadon.sqlite") db.row_factory = sqlite3.Row dbcmd = db.cursor() temp = Password.encode('utf-8') hashedPassword = bcrypt.hashpw(temp, bcrypt.gensalt()) query = "INSERT INTO Accounts (Username, Email, Password, SessionKey, FirstLogin, Banned, Admin, CurrentCharacterID) VALUES (?,?,?,?,?,?,?,?)" dbcmd.execute(query, (Username, Email, hashedPassword, None, "1", "0", "1", "1")) db.commit() dbcmd.close() return '{"Status": "Success"}' except: return '{"Status": "Fail", "Reason": "Unknown"}'
def sync_inventory_down(self): db = sqlite3.connect( str(str(get_project_root()) + "/PikaChewniverse.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "SELECT * FROM Inventory WHERE CharID = ?" dbcmd.execute(query, (self.character.id, )) value = dbcmd.fetchall() self.items.clear() for item in value: newitem = Item() newitem.item_lot = item['ItemLOT'] newitem.quantity = item['Quantity'] newitem.is_equipped = item['IsEquipped'] newitem.is_linked = item['IsLinked'] newitem.slot = len(self.items) + 1 newitem.item_id = item['ItemID'] newitem.type = item['Type'] self.items.append(newitem) dbcmd.close()
def get_components(self): db = sqlite3.connect( str(str(get_project_root()) + "/clientfiles/cdclient.sqlite")) dbcmd = db.cursor() query = "SELECT component_type, component_id FROM ComponentsRegistry WHERE id = ?" dbcmd.execute(query, (self.lot, )) object_components = dbcmd.fetchall() for component in network_components: for _ in object_components: if component == _[0]: if component not in non_networked: self.component_ids.append(_) for component in self.component_ids: if component[0] in available_components: pass else: self.is_constructable = False break
def create(self): for component in self.component_ids: if component[0] == 3: simple_physics_dict = { 'HasPosition': True, 'PosX': self.position_x, 'PosY': self.position_y, 'PosZ': self.position_z, 'RotX': self.rotation_x, 'RotY': self.rotation_y, 'RotZ': self.rotation_z, 'RotW': self.rotation_w } simple_physics_dict['HasVelocity'] = False simple_physics_dict['LVelocityX'] = 0 simple_physics_dict['LVelocityY'] = 0 simple_physics_dict['LVelocityZ'] = 0 simple_physics_dict['AVelocityX'] = 0 simple_physics_dict['AVelocityY'] = 0 simple_physics_dict['AVelocityZ'] = 0 self.components.append( SimplePhysics.SimplePhysics( simple_physics_dict=simple_physics_dict)) if component[0] == 40: phantom_physics_dict = { 'HasPosition': True, 'PosX': self.position_x, 'PosY': self.position_y, 'PosZ': self.position_z, 'RotX': self.rotation_x, 'RotY': self.rotation_y, 'RotZ': self.rotation_z, 'RotW': self.rotation_w } self.components.append( PhantomPhysics.PhantomPhysics( phantom_physics_dict=phantom_physics_dict)) if component[0] == 7: destructible_dict = {} stats_dict = {} stats_dict['HasStats'] = False self.components.append( Destructible.Destructible( destructible_dict=destructible_dict)) self.components.append(Stats.Stats(stats_dict=stats_dict)) if component[0] == 17: inventory_dict = {} db = sqlite3.connect( str( str(get_project_root()) + "/clientfiles/cdclient.sqlite")) dbcmd = db.cursor() query = "SELECT itemid, count, equip FROM InventoryComponent WHERE id = ?" dbcmd.execute(query, (component[1], )) items = dbcmd.fetchall() inventory = [] for item in items: itm = {} itm['ItemID'] = random.randrange(0, 10000000) itm['ItemLOT'] = item[0] itm['Quantity'] = item[1] itm['IsEquipped'] = item[2] itm['Slot'] = items.index(item) db = sqlite3.connect( str( str(get_project_root()) + "/clientfiles/cdclient.sqlite")) dbcmd = db.cursor() query = "SELECT itemType FROM ItemComponent WHERE id = ?" dbcmd.execute(query, (itm['ItemLOT'], )) item_type = dbcmd.fetchall() try: itm['Type'] = item_type[0][0] except Exception: itm['Type'] = 0 inventory.append(itm) inventory_dict['HasInventory'] = True inventory_dict['Inventory'] = inventory self.components.append( Inventory.Inventory(inventory_dict=inventory_dict)) if component[0] == 5: db = sqlite3.connect( str( str(get_project_root()) + "/clientfiles/cdclient.sqlite")) dbcmd = db.cursor() query = "SELECT client_script_name FROM ScriptComponent WHERE id = ?" dbcmd.execute(query, (component[1], )) script = dbcmd.fetchone() try: if script[0] is not None: self.is_constructable = False pass else: pass # log(LOGGINGLEVEL.ERROR, "LOT: " + self.spawn_lot + " Has No Script") except Exception: self.is_constructable = False log(LOGGINGLEVEL.ERROR, "LOT: " + str(self.lot) + " No script database entry") if self.is_constructable is True: script_dict = {} self.components.append( Script.Script(script_dict=script_dict)) if component[0] == 9: skill_dict = {} self.components.append(Skill.Skill(skill_dict=skill_dict)) if component[0] == 16: vendor_dict = {} self.components.append(Vendor.Vendor(vendor_dict=vendor_dict)) if component[0] == 2: render_dict = {} self.components.append(Render.Render(render_dict=render_dict)) if component[0] == 107: component107_dict = {} self.components.append( Component107.Component107( component107_dict=component107_dict)) self.server._rep_man.construct(obj=self, new=True, reliability=Reliability.ReliableOrdered)
from Utils.GetProjectRoot import get_project_root import configparser from APIServer import app import ctypes from Logger import * config = configparser.ConfigParser() path = str(get_project_root()) + '/config.ini' config.read(path) def flaskThread(): log(LOGGINGLEVEL.WEBSERVER, (" Server Started")) app.debug = False app.run(config['API']['IP'], int(config['API']['PORT']))
def create(self): id = LWOOBJID().generateobject() obj = Object(object_id=id, lot=int(self.spawn_lot), name="") for component in self.components: if component[0] == 3: simple_physics_dict = { 'HasPosition': True, 'PosX': self.pos_x, 'PosY': self.pos_y, 'PosZ': self.pos_z, 'RotX': self.rot_x, 'RotY': self.rot_y, 'RotZ': self.rot_z, 'RotW': self.rot_w } simple_physics_dict['HasVelocity'] = False simple_physics_dict['LVelocityX'] = 0 simple_physics_dict['LVelocityY'] = 0 simple_physics_dict['LVelocityZ'] = 0 simple_physics_dict['AVelocityX'] = 0 simple_physics_dict['AVelocityY'] = 0 simple_physics_dict['AVelocityZ'] = 0 obj.components.append( SimplePhysics.SimplePhysics( simple_physics_dict=simple_physics_dict)) if component[0] == 40: phantom_physics_dict = { 'HasPosition': True, 'PosX': self.pos_x, 'PosY': self.pos_y, 'PosZ': self.pos_z, 'RotX': self.rot_x, 'RotY': self.rot_y, 'RotZ': self.rot_z, 'RotW': self.rot_w } obj.components.append( PhantomPhysics.PhantomPhysics( phantom_physics_dict=phantom_physics_dict)) if component[0] == 7: destructible_dict = {} stats_dict = {} stats_dict['HasStats'] = False obj.components.append( Destructible.Destructible( destructible_dict=destructible_dict)) obj.components.append(Stats.Stats(stats_dict=stats_dict)) if component[0] == 17: inventory_dict = {} db = sqlite3.connect( str( str(get_project_root()) + "/clientfiles/cdclient.sqlite")) dbcmd = db.cursor() query = "SELECT itemid, count, equip FROM InventoryComponent WHERE id = ?" dbcmd.execute(query, (component[1], )) items = dbcmd.fetchall() inventory = typeinv(character=None) for item in items: itm = Item() itm.item_id = random.randrange(0, 10000000) itm.item_lot = item[0] itm.quantity = item[1] itm.is_equipped = item[2] itm.slot = items.index(item) itm.type = 0 inventory.items.append(itm) inventory_dict['HasInventory'] = True inventory_dict['Inventory'] = inventory obj.components.append( Inventory.Inventory(inventory_dict=inventory_dict)) print(self.spawn_lot) if component[0] == 9: skill_dict = {} obj.components.append(Skill.Skill(skill_dict=skill_dict)) if component[0] == 16: vendor_dict = {} obj.components.append(Vendor.Vendor(vendor_dict=vendor_dict)) if component[0] == 2: render_dict = {} obj.components.append(Render.Render(render_dict=render_dict)) if component[0] == 107: component107_dict = {} obj.components.append( Component107.Component107( component107_dict=component107_dict)) self.server._rep_man.construct(obj, True)
def add_item(self, item_data): self.sync_inventory_down() if item_data['Type'] == 0: if len(self.items) > 0: for item in self.items: if int(item.item_lot) == int(item_data['ItemLOT']): print("Same") item.quantity = item.quantity + item_data['Quantity'] db = sqlite3.connect( str( str(get_project_root()) + "/PikaChewniverse.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "UPDATE Inventory SET Quantity = ? WHERE ItemID = ?" dbcmd.execute(query, ( item.quantity, item.item_id, )) db.commit() dbcmd.close() break elif len(self.items) < self.character.inventory_space: newitem = Item() newitem.item_lot = item_data['ItemLOT'] newitem.quantity = item_data['Quantity'] newitem.is_equipped = item_data['IsEquipped'] newitem.is_linked = item_data['IsLinked'] newitem.slot = len(self.items) + 1 newitem.item_id = item_data['ItemID'] newitem.type = item_data['Type'] self.items.append(newitem) db = sqlite3.connect( str( str(get_project_root()) + "/PikaChewniverse.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "INSERT INTO Inventory (CharID, ItemLOT, IsEquipped, IsLinked, Quantity, Slot, ItemID, Type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)" dbcmd.execute(query, ( self.character.id, newitem.item_lot, newitem.is_equipped, newitem.is_linked, newitem.quantity, newitem.slot, newitem.item_id, newitem.type, )) db.commit() dbcmd.close() break else: newitem = Item() newitem.item_lot = item_data['ItemLOT'] newitem.quantity = item_data['Quantity'] newitem.is_equipped = item_data['IsEquipped'] newitem.is_linked = item_data['IsLinked'] newitem.slot = len(self.items) + 1 newitem.item_id = item_data['ItemID'] newitem.type = item_data['Type'] self.items.append(newitem) db = sqlite3.connect( str(str(get_project_root()) + "/PikaChewniverse.sqlite")) db.row_factory = sqlite3.Row dbcmd = db.cursor() query = "INSERT INTO Inventory (CharID, ItemLOT, IsEquipped, IsLinked, Quantity, Slot, ItemID, Type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)" dbcmd.execute(query, ( self.character.id, newitem.item_lot, newitem.is_equipped, newitem.is_linked, newitem.quantity, newitem.slot, newitem.item_id, newitem.type, )) db.commit() dbcmd.close() del newitem else: print("Type not supported: " + str(item_data['Type'])) self.sync_inventory_down()