def show_visible_exists():
show_room(None)
out(
FToken.wrap('<br>Mögliche Werte für einen neue Ausgang:',
FToken.text))
occ_dirs = [a.direction for a in exist_list]
directions = [
(" - ".join([FToken.wrap("{0}".format(a[0]), FToken.enum), a[1]]))
for a in Room.DIRECTION_NAMES.items() if a[0] not in occ_dirs
]
out(
FToken.wrap('<br>{}<br>'.format("<br>".join(directions)),
FToken.text))
def set_avatar_name(cmd: str, ask: Callable[[str], None], store: Callable[[str], None]):
if not cmd:
text = (
'Denk Dir jetzt bitte einen Namen für Deinen neuen Charakter aus.<br>'
'<br>'
'Der Name sollte mindestens drei und höchstens 15 Buchstaben lang sein.<br>'
'Bedenke: Nachträglich kann Dein Name nicht mehr geändert werden!<br>'
'Wie möchtest Du in diesem Spiel heissen?<br>'
'Name:')
ask(text)
elif cmd in ['neu', 'admin']:
raise Exception(FToken.wrap('Dieser Name ist nicht zulässig.<br><br>', FToken.error))
elif len(cmd) < 3:
raise Exception(FToken.wrap('%s ist zu kurz.<br>' % cmd, FToken.error))
else:
store(cmd)
def get_by_name(name: str) -> Avatar:
from ..repository import AvatarModel
try:
name = name.strip().title()
entity = AvatarModel.get(AvatarModel.name == name)
return Avatar(entity)
except AvatarModel.DoesNotExist as e:
raise Exception(
FToken.wrap("Avatar %s existiert nicht" % name, FToken.error))
def show_room(cmd: str, get_avatar: Callable[[None], Avatar],
get_room: Callable[[int, int], Room],
get_exists: Callable[[int, int],
List[Exit]], out: Callable[[str], None]):
avatar = get_avatar()
room = get_room(avatar.id, avatar.position)
name = room.name if not room.zone else room.name + ' - ' + room.zone
out(
FToken.wrap('{} ({})'.format(name, room.id), FToken.room_name) +
'<br>')
out(FToken.line)
out(FToken.wrap('{}<br>'.format(room.description), FToken.room_desc))
exists = [a.title for a in get_exists(avatar.id, room.id)]
if exists:
out(FToken.wrap('<br>Sichtbare Ausgänge:<br>', FToken.exit_title))
for ex in exists:
out(FToken.wrap(' {}<br>'.format(ex), FToken.exit_object))
def set_avatar_password(cmd: str, ask: Callable[[str], None], store: Callable[[str], None]):
if not cmd:
text = (
'Wähle ein Passwort:<br>'
'Dein Passwort muss wenigstens 6 Zeichen lang sein.<br>'
'Bitte gib jetzt ein Passwort an:<br>')
ask(text)
elif len(cmd) < 6:
raise Exception(FToken.wrap('Dein Passwort ist zu kurz.<br><br>', FToken.error))
else:
store(cmd)
def create_exit(cmd: str, get_avatar: Callable[[None], Avatar],
show_room: Callable[[None], None],
get_room: Callable[[int, int],
Room], get_exists: Callable[[int, int],
List[Exit]],
store: Callable[[int, int], None], out: Callable[[str], None]):
avatar = get_avatar()
room = get_room(avatar.id, avatar.position)
exist_list = get_exists(avatar.id, room.id)
def show_visible_exists():
show_room(None)
out(
FToken.wrap('<br>Mögliche Werte für einen neue Ausgang:',
FToken.text))
occ_dirs = [a.direction for a in exist_list]
directions = [
(" - ".join([FToken.wrap("{0}".format(a[0]), FToken.enum), a[1]]))
for a in Room.DIRECTION_NAMES.items() if a[0] not in occ_dirs
]
out(
FToken.wrap('<br>{}<br>'.format("<br>".join(directions)),
FToken.text))
if not cmd:
show_visible_exists()
else:
if not cmd in Room.DIRECTIONS:
show_visible_exists()
out(FToken.wrap('<br>Unbekannter Ausgang', FToken.error))
return
directions = [a.direction for a in exist_list]
if cmd in directions:
show_visible_exists()
out(
FToken.wrap('<br>Ausgang "{0}" existiert bereits'.format(cmd),
FToken.error))
return
store(avatar.id, room.id, cmd)
def run(cmd: str,
show_room: Callable[[str], None],
move_avatar: Callable[[str], None],
out: Callable[[str], None]):
cmd = cmd.lower()
if cmd in Room.DIRECTIONS:
move_avatar(cmd)
elif not cmd or cmd == 'schau':
show_room(cmd)
else:
show_room('')
out(FToken.wrap('<br>Das kenne ich nicht!', FToken.error))
def get_by_id(avatar_id: str) -> Avatar:
from ..repository import AvatarModel
try:
try:
entity = AvatarModel.get(AvatarModel.id == avatar_id)
return Avatar(entity)
except AvatarModel.DoesNotExist as e:
return None
except Exception as ex:
raise Exception(
FToken.wrap("Der Avatar mit der ID %s existiert nicht" % avatar_id,
FToken.error))
def set_avatar_sex(cmd: str, ask: Callable[[str], None], store: Callable[[str], None]):
if not cmd:
text = 'Bist du männlich oder weiblich?<br>'
ask(text)
elif cmd not in ['m', 'w', 'männlich', 'weiblich']:
raise Exception(FToken.wrap('Die Eingabe war ungültig.<br><br>', FToken.error))
else:
if cmd == 'm':
cmd = 'männlich'
if cmd == 'w':
cmd = 'weiblich'
store(cmd)
def store_password(password: str, get_avatar_id: Callable[[None], None],
stored: Callable[[str], None], out: Callable[[str], None]):
from ..repository import AvatarModel
try:
avatar = AvatarModel.get(AvatarModel.id == get_avatar_id())
avatar.password = password
AvatarModel.save(avatar)
out('Password wurde festgelegt.<br><br>')
stored('')
except AvatarModel.DoesNotExist as e:
raise Exception(
FToken.wrap("Der Avatar konnte nicht gefunden werden.<br><br>",
FToken.error))
def store_sex(sex: str, stored: Callable[[str], None],
get_avatar_id: Callable[[None], None], out: Callable[[str],
None]):
from ..repository import AvatarModel
try:
avatar = AvatarModel.get(AvatarModel.id == get_avatar_id())
avatar.sex = sex
AvatarModel.save(avatar)
out('%s wurde festgelegt.<br><br>' % sex.title())
stored('')
except AvatarModel.DoesNotExist as e:
raise Exception(
FToken.wrap("Der Avatar konnte nicht gefunden werden.<br><br>",
FToken.error))
def set_avatar_race(cmd: str, ask: Callable[[str], None], store: Callable[[str], None]):
if not cmd:
def races_to_text():
return "<br>".join([str(a[0]) + ". " + a[1] for a in Race.races])
text = (
'Welcher Rasse möchtest du in dieser Welt angehören?<br>'
'Eine Rasse kann jederzeit gewechselt werden.<br>'
'Derzeit stehen folgende Rassen zur Auswahl:<br><br>'
'%s<br><br>'
'Durch Eingabe einer Ziffer wählst Du die Rasse aus.<br>' % races_to_text())
ask(text)
elif cmd not in [a[0] for a in Race.races]:
raise Exception(FToken.wrap('Die Eingabe war ungültig.<br><br>', FToken.error))
else:
store(Race.races[int(cmd) - 1][1])
def store_name(name: str, stored: Callable[[str], None],
set_avatar_id: Callable[[int], None], out: Callable[[str],
None]):
from ..repository import AvatarModel
name = name.strip().title()
try:
AvatarModel.get(AvatarModel.name == name)
raise Exception(
FToken.wrap(
"Ein Avatar mit dem Namen %s existiert bereits.<br><br>" %
name, FToken.error))
except AvatarModel.DoesNotExist as e:
avatar = Avatar(
AvatarModel.create(name=name,
race=Avatar.DEFAULT_RACE,
guild=Avatar.DEFAULT_GUILD))
set_avatar_id(avatar.id)
out('Ein Avatar mit den Namen %s wurde erstellt...<br><br>' % name)
stored('')