def get_or_create(self, user, guild, channel, scene, name, archived=False):
engagement = self.find(guild, str(channel.id), str(scene.id), name, archived)
if engagement is None:
engagement = self.create_new(user, guild, str(channel.id), str(scene.id), name, archived)
engagement.character = Character().get_or_create(user, name, guild, engagement, 'Engagement', archived)
engagement.save()
return engagement
def __init__(self,Map = Map(), characters=list()):
super(CharacterEditionWindow,self).__init__()
self.setupUi(self)
#self.land_path = land_Paths
self.Map = Map
self.characters = characters
self.actual_character = None
self.characters_paths = list()
self.images_lst.setMinimumHeight(100)
if len(characters) == 0:
self.characters.append(Character(name="NUEVO PERSONAJE",Map=self.Map))
else:
for e in self.characters:
e.make_new_copy_of_map(self.Map)
self.load_characters_layout()
self.load_characters()
self.assign_events()
SecundaryBtnStyleEnabled = "QPushButton:enabled{background-color:#343a40;border-radius:6px;color:#ffffff;font-family:Verdana;text-decoration:none;}"
PrimaryBtnStyleEnabled = "QPushButton:enabled{background-color:#4e73df;border-radius:6px;color:#ffffff;font-family:Verdana;text-decoration:none;}"
btnStyleDisabled = " QPushButton:disabled{background-color:#949494;border-radius:6px;font-family:Verdana;text-decoration:none; }"
clickEffect = "QPushButton:pressed{border-style:solid;border-width:1px;}"
self.accept_btn.setStyleSheet(btnStyleDisabled + PrimaryBtnStyleEnabled + clickEffect)
self.go_back_btn.setStyleSheet(btnStyleDisabled + SecundaryBtnStyleEnabled + clickEffect)
self.accept_btn.setDisabled(True)
self.name_txt.setPlaceholderText("Nombre de personaje")
self.name_txt.setMaxLength(15)
self.setStyleSheet("font-family:Verdana;")
self.showMaximized()
def get_or_create(self, user, guild, channel, scenario, name, archived=False):
scene = self.find(guild, str(channel.id), str(scenario.id), name, archived)
if scene is None:
scene = self.create_new(user, guild, str(channel.id), str(scenario.id), name, archived)
scene.character = Character().get_or_create(user, name, guild, scene, 'Scene', archived)
scene.save()
return scene
def fetch_player(id=-1, name=""):
command = f"SELECT * FROM players WHERE id = {id} OR name = '{name}'"
cursor.execute(command)
record = cursor.fetchone()
if record:
abilities = {}
inventory = Inventory()
armor = fetch_item(id=record[7])
weapon = fetch_item(id=record[8])
abilities_ids = record[9].split(",")
for ability_id in abilities_ids:
ability_id = int(ability_id)
ability = fetch_ability(id=ability_id)
abilities[ability.name] = ability
items_id = record[10].split(",")
for item_id in items_id:
if item_id != "":
item_id = int(item_id)
inventory.add(fetch_item(id=item_id), {})
player = Character(id=record[0],
name=record[1],
description=record[2],
max_health=record[3],
max_mana=record[5],
abilities=abilities,
inventory=inventory,
armor=armor,
weapon=weapon,
coin=record[13],
position=[record[11], record[12]],
character_type="player")
player.health = record[4]
player.mana = record[6]
return player
return record
def __get_character(self):
with open('tests/fixtures/character.json', 'r') as jd:
json_data = json.loads(jd.read())
with open('tests/fixtures/race_data.json', 'r') as rd:
race_data = json.loads(rd.read())
return Character(json_data, race_data, False)
def get_or_create(self, user, guild, channel, name, archived=False):
session = self.find(guild, str(channel.id), name, archived)
if session is None:
session = self.create_new(user, guild, str(channel.id), name,
archived)
session.character = Character().get_or_create(
user, name, guild, session, 'Session', archived)
session.save()
return session
def get_or_create(self, user, guild, channel, scene, name, archived=False):
zone = self.find(guild, str(channel.id), str(scene.id), name, archived)
if zone is None:
zone = self.create_new(user, guild, str(channel.id), str(scene.id),
name, archived)
zone.character = Character().get_or_create(user, name, guild, zone,
'Zone', archived)
zone.save()
return zone
def get(self):
_id = request.args.get("id")
character = Character()
try:
character.payload = hdb.get(character, _id)
return character.payload
except Exception as error:
gunicorn_logger.error(error)
return "Could not retrieve character", 400
def add_character():
if request.method == 'GET':
return render_template('character_form.html')
elif request.method == 'POST':
new_character = Character(name = request.form['name'],
image=request.form['image'],
rate=request.form['rate'],
fid=request.form['fid'])
new_character.save()
return "gotcha"
def characters(id):
player_characters = []
sql = "SELECT characters.* FROM characters WHERE player_id = %s"
values = [id]
results = run_sql(sql, values)
for result in results:
player = player_repository.select(id)
party = party_repository.select(result['party_id'])
character = Character(result['name'], result['race'], result['archetype'], result['level'], result['armour'], result['magic'], result['weight'], result['perception'], result['insight'], result['immunity'], result['vision'], result['language'], result['aura'], result['enmity'], result['exhaustion'], player, party, result['id'])
player_characters.append(character)
return player_characters
def create_character(req):
try:
if current_user.is_authenticated:
return Errors("Already logedin", 400).to_json()
password = bycrpt.generate_password_hash(
req['password']).decode('utf-8')
admin = Character(name=req['username'], password=password)
admin.save_to_db()
return admin.to_json()
except KeyError:
return Errors("Username Already Taken", 400).to_json()
def get_or_create(self, user, guild, channel, name, archived=False):
scenario = self.find(guild, str(channel.id), name, archived)
if scenario is None:
scenario = self.create_new(user, guild, str(channel.id), name,
archived)
scenario.character = Character().get_or_create(
user, name, guild, scenario, 'Scenario', archived)
scenario.updated_by = str(user.id)
scenario.updated = T.now()
scenario.save()
return scenario
def select(id):
character = None
sql = "SELECT * FROM characters WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
player = player_repository.select(result["player_id"])
party = party_repository.select(result["party_id"])
if result is not None:
character = Character(result['name'], result['race'], result['archetype'], result['level'], result['armour'], result['magic'], result['weight'], result['perception'], result['insight'], result['immunity'], result['vision'], result['language'], result['aura'], result['enmity'], result['exhaustion'], player, party, result['id'])
return character
def post(self):
new_character = Character()
valid = new_character.create(request.json)
if valid:
response = hdb.insert(new_character)
return {
"id": new_character._id,
"status": response,
"character": new_character.payload,
}
else:
return "Could not create Character", 400
def add_character(self):
if len(self.characters) ==5:
return
name = "NUEVO PERSONAJE"
new_C = Character(name=name,Map=self.Map)
self.characters.append(new_C)
add_btn,delete_btn,character_btn = self.get_buttons(new_C)
hlyt = QHBoxLayout()
hlyt.addWidget(add_btn)
hlyt.addWidget(character_btn)
hlyt.addWidget(delete_btn)
self.select_character_lyt.addRow(hlyt)
def select_all():
characters = []
sql = "SELECT * FROM characters"
results = run_sql(sql)
for result in results:
player = player_repository.select(result["player_id"])
party = party_repository.select(result["party_id"])
character = Character(result['name'], result['race'], result['archetype'], result['level'], result['armour'], result['magic'], result['weight'], result['perception'], result['insight'], result['immunity'], result['vision'], result['language'], result['aura'], result['enmity'], result['exhaustion'], player, party, result['id'])
characters.append(character)
return characters
def get_new_members(json):
result = []
for member in json['members']:
member = member['character']
try:
if int(member['level']) == 120:
char = Character(member['name'], member['realm'],
member['guild'], member['level'])
char.save_db()
result.append(member['name'])
except KeyError:
continue
return result
def character():
#send form (GET)
if request.method =="GET":
return render_template("character_form.html")
elif request.method == "POST":
#save (POST)
form = request.form
image = form["image"]
name = form["name"]
rate = form["rate"]
new_character = Character(name=name, image=image, rate=rate)
new_character.save()
return "GOTCHA"
def add_character():
# 1: Gui form (GET)
if request.method == "GET":
return render_template('character_form.html')
elif request.method == "POST":
# 4: Nhan form => luu
form = request.form
name = form["name"]
image = form["image"]
rate = form["rate"]
new_character = Character(name=name, image=image, rate=rate)
new_character.save()
return "Gotcha"
def add_character():
#1 GUI FORM (GET)
if request.method == "GET": #method ko dc co s
return render_template("character_form.html")
elif request.method == "POST":
#4 NHAN FORM => LUU (POST)
form = request.form
name = form["name"]
image = form["image"]
rate = form["rate"]
new_character = Character(name=name, image=image, rate=rate)
new_character.save()
return "Gotcha"
def add_character():
#1. Gui form (GET)
if request.method == "GET":
return render_template("character_form.html")
elif request.method == "POST":
#4. Nhan form => Luu
form = request.form
print(form)
name = form["name"]
image = form["image"]
rate = form["rate"]
new_character = Character(name=name, image=image, rate=rate)
new_character.save()
return "GOTCHA"
def add_character():
#1: gửi form(GET)
if request.method == "GET":
return render_template("character_form.html")
elif request.method == "POST":
#4: nhận form => Lưu (POST)
form = request.form
name = form["name"]
image = form["image"]
rate = form["rate"]
print(name, image, rate)
new_character = Character(name=name, image=image, rate=rate)
new_character.save()
return "Gotcha"
def post(cls):
json_data = request.get_json(force=True)
if not json_data:
return 'No input data provided', 400
# Validate and deserialize input
response = json.dumps(json_data)
data = CharacterSchema.loads(response)
# Avoid printing a DB error to the user
# Checks if the hat does exist
user = Character.query.filter_by(id=data['id'])
exist = Characters_schema.dump(user)
if exist:
return 'Character already exists', 400
# the 1-1 relationship with the hat disable the possibility to create a character with hat = False
if not data['human']:
return 'can not create the character', 400
# Weight and age constraint
if data['weight'] > 80 and data['human'] == True:
if data['age'] < 10:
return 'weight is too big for age', 400
# Age constraint
if data['age'] < 0:
return 'age is not correct', 400
# p and yellow constraint
hat = Hat.query.filter_by(id=data['hat'])
hat = HatSchema.dump(hat)
if (re.search('p', data['name']) or re.search(
'P', data['name'])) and hat[0]['colour'] == "YELLOW":
return 'You have a p in your name, can not have a yellow hat', 400
user = Character(id=data['id'],
name=data['name'],
age=data['age'],
weight=data['weight'],
human=data['human'],
hat=data['hat'])
db.session.add(user)
db.session.commit()
result = CharacterSchema.dump(user)
return result, 201
def get_or_create(self,
user,
guild,
channel,
engagement,
name,
archived=False):
exchange = self.find(guild, str(channel.id), str(engagement.id), name,
archived)
if exchange is None:
exchange = self.create_new(user, guild, str(channel.id),
str(engagement.id), name, archived)
exchange.character = Character().get_or_create(
user, name, guild, exchange, 'Exchange', archived)
exchange.save()
return exchange
def get_average_roster_ilvl():
ilvl = 0
count = 0
chars = []
fchars = []
for member in g['redis'].smembers('roster'):
char = Character(member.split(':')[1], member.split(':')[0], None, 120)
char.refresh(roster=True)
count += 1
ilvl = ilvl + char.ilvl
chars.append(char)
if ilvl == 0:
return 0
for char in chars:
if char.ilvl < ilvl / count:
fchars.append(char.name + '({})'.format(char.ilvl))
return ilvl / count, fchars
def get(self):
self.name = self.request.get('NAME')
self.strength = self.request.get('STR')
self.dexterity = self.request.get('DEX')
self.constitution = self.request.get('CON')
self.intelligence = self.request.get('INT')
self.wisdom = self.request.get('WIS')
self.charisma = self.request.get('CHA')
character = Character()
character.name = self.name
character.base_strength = int(self.strength)
character.base_dexterity = int(self.dexterity)
character.base_constitution = int(self.constitution)
character.base_intelligence = int(self.intelligence)
character.base_wisdom = int(self.wisdom)
character.base_charisma = int(self.charisma)
key = character.put()
self.response.out.write('<h3>{}</h3>'.format(key.urlsafe()))
def create_character_from_json(abilities, all_items, character_dict):
_abilities = {}
for ability_dict in character_dict["abilities"]:
ability = abilities[ability_dict]
_abilities[ability.name] = ability
_armor = character_dict["armor"]
_weapon = character_dict["weapon"]
_inventory = Inventory()
_inventory.remove_all()
char_inventory = character_dict["inventory"]
for item in all_items:
if _inventory.count_all_item() >= len(char_inventory) and type(
_armor) == Armor and type(_weapon) == Weapon:
break
elif item.id == _armor:
_armor = item
continue
elif item.id == _weapon:
_weapon = item
continue
elif item.id in char_inventory:
for _ in range(char_inventory.count(item.id)):
_inventory.add(item, {})
continue
if _inventory.count_all_item() < len(char_inventory):
raise Exception("lost some item")
return Character(id=character_dict["id"],
name=character_dict["name"],
description=character_dict["description"],
max_health=character_dict["max_health"],
max_mana=character_dict["max_mana"],
mana_regen=character_dict["mana_regen"],
abilities=_abilities,
inventory=_inventory,
armor=_armor,
weapon=_weapon,
position=character_dict["position"],
coin=character_dict["coin"],
character_type=character_dict["character_type"])
def post(self):
character_id = request.args.get("character")
try:
character = hdb.get(Character(), character_id)
game = Campaign()
payload = {
"character": character,
"current_hp": character["hp"],
"current_xp": character["xp"],
"currently_equiped": {},
"current_pack": [],
}
gunicorn_logger.warning(payload)
valid = game.create(payload)
if valid:
response = hdb.insert(game)
return {"campaign": game.payload}
else:
return "Could not create campaign: request not valid", 400
except Exception as error:
gunicorn_logger.error(error)
return "Could not create campaign", 400
def create_character(self,
name,
x=0,
y=0,
band=None,
age=0,
player=False,
speed=0.015):
cid = uuid.uuid4()
if player:
self.players[cid] = player
bid = uuid.uuid4()
character = Character(cid, name, age, band, not bool(player), speed,
{}, {}, {})
self.characters[cid] = character
if not band:
band = BandModel(bid, name + "'s Band", character, (x, y), (x, y),
speed, {character.id: character}, {})
character.band = band
self.bands[bid] = Band(model=band)
return character
def get_character(self, character, find_by_id):
if find_by_id:
result = self.firebase_db.get('/',
f'/characters/{character}',
params={'auth': FIREBASE_API_SECRET})
else:
result = self.firebase_db.get('/',
'characters',
params={
'orderBy': '\"character/name\"',
'equalTo': f'\"{character}\"',
'auth': FIREBASE_API_SECRET
})
if not result:
return None
json_data = result[list(result.keys())[0]]
race = json_data['race']['baseName'] if find_by_id else json_data[
'character']['race']['baseName']
race_data = requests.get(RACE_URLS[race]).json()
return Character(json_data, race_data, find_by_id)
