async def update_initiative_option(sid: str, data: ServerInitiativeOption):
pr: PlayerRoom = game_state.get(sid)
shape = Shape.get_or_none(uuid=data["shape"])
if not has_ownership(shape, pr):
logger.warning(
f"{pr.player.name} attempted to change initiative of an asset it does not own"
)
return
location_data = Initiative.get_or_none(location=pr.active_location)
if location_data is None:
logger.error(
"Initiative updated for location without initiative tracking")
return
json_data = json.loads(location_data.data)
with db.atomic():
for i, initiative_data in enumerate(json_data):
if initiative_data["shape"] == data["shape"]:
json_data[i][data["option"]] = data["value"]
break
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Option.Set",
data,
skip_sid=sid,
room=pr.active_location.get_path(),
namespace=GAME_NS,
)
async def load_location(sid, location):
sid_data = state.sid_map[sid]
user = sid_data["user"]
room = sid_data["room"]
sid_data["location"] = location
data = {}
data["locations"] = [l.name for l in room.locations]
if user == room.creator:
data["layers"] = [
l.as_dict(user, True) for l in location.layers.order_by(Layer.index)
]
else:
data["layers"] = [
l.as_dict(user, False)
for l in location.layers.order_by(Layer.index).where(Layer.player_visible)
]
client_options = user.as_dict()
client_options.update(
**LocationUserOption.get(user=user, location=location).as_dict()
)
await sio.emit("Board.Set", data, room=sid, namespace="/planarally")
await sio.emit(
"Location.Set", location.as_dict(), room=sid, namespace="/planarally"
)
await sio.emit(
"Client.Options.Set", client_options, room=sid, namespace="/planarally"
)
await sio.emit(
"Notes.Set",
[
note.as_dict()
for note in Note.select().where((Note.user == user) & (Note.room == room))
],
room=sid,
namespace="/planarally",
)
sorted_initiatives = [
init.as_dict()
for init in Initiative.select()
.join(Shape, JOIN.LEFT_OUTER, on=(Initiative.uuid == Shape.uuid))
.join(Layer)
.where((Layer.location == location))
.order_by(Initiative.index)
]
location_data = InitiativeLocationData.get_or_none(location=location)
if location_data:
await send_client_initiatives(room, location, user)
await sio.emit(
"Initiative.Round.Update",
location_data.round,
room=sid,
namespace="/planarally",
)
await sio.emit(
"Initiative.Turn.Set", location_data.turn, room=sid, namespace="/planarally"
)
async def change_initiative_order(sid: str, data: ServerInitiativeOrderChange):
pr: PlayerRoom = game_state.get(sid)
if pr.role != Role.DM:
logger.warning(f"{pr.player.name} attempted to reorder initiatives")
return
old_index = data["oldIndex"]
new_index = data["newIndex"]
with db.atomic():
location_data = Initiative.get(location=pr.active_location)
json_data = json.loads(location_data.data)
if json_data[old_index]["shape"] != data["shape"]:
return
if json_data[new_index].get(
"initiative", 0) != json_data[old_index].get("initiative", 0):
location_data.sort = 2
json_data.insert(new_index, json_data.pop(old_index))
json_data = sort_initiative(json_data, location_data.sort)
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Set",
location_data.as_dict(),
room=pr.active_location.get_path(),
namespace=GAME_NS,
)
async def remove_initiative_effect(sid: str,
data: ServerRemoveInitiativeEffectActor):
pr: PlayerRoom = game_state.get(sid)
if not has_ownership(Shape.get_or_none(uuid=data["shape"]), pr):
logger.warning(
f"{pr.player.name} attempted to remove an initiative effect")
return
location_data = Initiative.get(location=pr.active_location)
with db.atomic():
json_data = json.loads(location_data.data)
for initiative in json_data:
if initiative["shape"] == data["shape"]:
initiative["effects"].pop(data["index"])
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Effect.Remove",
data,
room=pr.active_location.get_path(),
skip_sid=sid,
namespace=GAME_NS,
)
async def remove_initiative(sid: str, data: str):
pr: PlayerRoom = game_state.get(sid)
shape = Shape.get_or_none(uuid=data)
if shape is not None and not has_ownership(shape, pr):
logger.warning(
f"{pr.player.name} attempted to remove initiative of an asset it does not own"
)
return
with db.atomic():
location_data = Initiative.get(location=pr.active_location)
json_data = json.loads(location_data.data)
location_data.data = json.dumps([
initiative for initiative in json_data
if initiative["shape"] != data
])
location_data.save()
await sio.emit(
"Initiative.Remove",
data,
room=pr.active_location.get_path(),
skip_sid=sid,
namespace=GAME_NS,
)
async def set_initiative_sort(sid: str, sort: int):
pr: PlayerRoom = game_state.get(sid)
if pr.role != Role.DM:
logger.warning(f"{pr.player.name} attempted to change initiative sort")
return
with db.atomic():
location_data = Initiative.get(location=pr.active_location)
location_data.sort = sort
json_data = json.loads(location_data.data)
json_data = sort_initiative(json_data, location_data.sort)
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Sort.Set",
room=pr.active_location.get_path(),
namespace=GAME_NS,
)
await sio.emit(
"Initiative.Set",
location_data.as_dict(),
room=pr.active_location.get_path(),
namespace=GAME_NS,
)
async def update_initiative_round(sid: str, data: int):
pr: PlayerRoom = game_state.get(sid)
location_data = Initiative.get(location=pr.active_location)
if pr.role != Role.DM:
json_data = json.loads(location_data.data)
if not has_ownership(
Shape.get_or_none(uuid=json_data[location_data.turn]["shape"]),
pr):
logger.warning(
f"{pr.player.name} attempted to advance the initiative tracker"
)
return
with db.atomic():
location_data.round = data
location_data.save()
await sio.emit(
"Initiative.Round.Update",
data,
room=pr.active_location.get_path(),
skip_sid=sid,
namespace=GAME_NS,
)
async def set_initiative_value(sid: str, data: ServerSetInitiativeValue):
pr: PlayerRoom = game_state.get(sid)
shape = Shape.get_or_none(uuid=data)
if shape is not None and not has_ownership(shape, pr):
logger.warning(
f"{pr.player.name} attempted to remove initiative of an asset it does not own"
)
return
with db.atomic():
location_data = Initiative.get(location=pr.active_location)
json_data = json.loads(location_data.data)
for initiative in json_data:
if initiative["shape"] == data["shape"]:
initiative["initiative"] = data["value"]
break
json_data = sort_initiative(json_data, location_data.sort)
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Set",
location_data.as_dict(),
room=pr.active_location.get_path(),
namespace=GAME_NS,
)
def get_client_initiatives(user, location):
location_data = InitiativeLocationData.get_or_none(location=location)
if location_data is None:
return []
initiatives = Initiative.select().where(
Initiative.location_data == location_data)
if location.room.creator != user:
initiatives = (initiatives.join(
ShapeOwner,
JOIN.LEFT_OUTER,
on=Initiative.uuid == ShapeOwner.shape).where(
(Initiative.visible == True)
| (ShapeOwner.user == user)).distinct())
return [i.as_dict() for i in initiatives.order_by(Initiative.index)]
async def update_initiative_order(sid: int, data: Dict[str, Any]):
pr: PlayerRoom = game_state.get(sid)
if pr.role != Role.DM:
logger.warning(
f"{pr.player.name} attempted to change the initiative order")
return
with db.atomic():
for i, uuid in enumerate(data):
init = Initiative.get(uuid=uuid)
init.index = i
init.save()
await send_client_initiatives(pr)
async def remove_initiative(sid: int, data: Dict[str, Any]):
pr: PlayerRoom = game_state.get(sid)
shape = Shape.get_or_none(uuid=data)
if shape is not None and not has_ownership(shape, pr):
logger.warning(
f"{pr.player.name} attempted to remove initiative of an asset it does not own"
)
return
initiative = Initiative.get_or_none(uuid=data)
location_data = InitiativeLocationData.get_or_none(
location=pr.active_location)
if initiative:
with db.atomic():
Initiative.update(
index=Initiative.index -
1).where((Initiative.location_data == location_data)
& (Initiative.index >= initiative.index))
initiative.delete_instance(True)
await send_client_initiatives(pr)
async def update_initiative_order(sid, data):
sid_data = state.sid_map[sid]
user = sid_data["user"]
room = sid_data["room"]
location = sid_data["location"]
if room.creator != user:
logger.warning(f"{user.name} attempted to change the initiative order")
return
location_data = InitiativeLocationData.get(location=location)
with db.atomic():
for i, uuid in enumerate(data):
init = Initiative.get(uuid=uuid)
init.index = i
init.save()
await send_client_initiatives(room, location)
async def update_initiative_round(sid: str, data: int):
pr: PlayerRoom = game_state.get(sid)
if pr.role != Role.DM:
logger.warning(
f"{pr.player.name} attempted to advance the initiative tracker")
return
location_data = Initiative.get(location=pr.active_location)
with db.atomic():
location_data.round = data
location_data.save()
await sio.emit(
"Initiative.Round.Update",
data,
room=pr.active_location.get_path(),
skip_sid=sid,
namespace=GAME_NS,
)
async def update_initiative_turn(sid: str, turn: int):
pr: PlayerRoom = game_state.get(sid)
location_data: Initiative = Initiative.get(location=pr.active_location)
json_data = json.loads(location_data.data)
if pr.role != Role.DM and not has_ownership(
Shape.get_or_none(uuid=json_data[location_data.turn]["shape"]),
pr):
logger.warning(
f"{pr.player.name} attempted to advance the initiative tracker")
return
with db.atomic():
nextTurn = turn > location_data.turn
location_data.turn = turn
for i, effect in enumerate(json_data[turn]["effects"][-1:]):
try:
turns = int(effect["turns"])
if turns <= 0 and nextTurn:
json_data[turn]["effects"].pop(i)
elif turns > 0 and nextTurn:
effect["turns"] = str(turns - 1)
else:
effect["turns"] = str(turns + 1)
except ValueError:
# For non-number inputs do not update the effect
pass
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Turn.Update",
turn,
room=pr.active_location.get_path(),
skip_sid=sid,
namespace=GAME_NS,
)
async def clear_initiatives(sid: str):
pr: PlayerRoom = game_state.get(sid)
if pr.role != Role.DM:
logger.warning(f"{pr.player.name} attempted to clear all initiatives")
return
with db.atomic():
location_data = Initiative.get(location=pr.active_location)
json_data = json.loads(location_data.data)
for initiative in json_data:
initiative["initiative"] = None
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Clear",
room=pr.active_location.get_path(),
namespace=GAME_NS,
)
async def add_initiative(sid: str, data: ServerInitiativeData):
pr: PlayerRoom = game_state.get(sid)
shape = Shape.get_or_none(uuid=data)
if shape is not None and not has_ownership(shape, pr):
logger.warning(
f"{pr.player.name} attempted to add initiative to an asset it does not own"
)
return
with db.atomic():
location_data, _ = Initiative.get_or_create(
location=pr.active_location,
defaults={
"round": 0,
"turn": 0,
"data": "[]"
})
json_data = json.loads(location_data.data)
for initiative in json_data:
if initiative["shape"] == data["shape"]:
initiative.update(**data)
break
else:
json_data.append(data)
location_data.data = json.dumps(json_data)
location_data.save()
await sio.emit(
"Initiative.Set",
location_data.as_dict(),
room=pr.active_location.get_path(),
namespace=GAME_NS,
)
async def load_location(sid: str, location: Location, *, complete=False):
pr: PlayerRoom = game_state.get(sid)
if pr.active_location != location:
pr.active_location = location
pr.save()
# 1. Load client options
client_options = pr.player.as_dict()
client_options["location_user_options"] = LocationUserOption.get(
user=pr.player, location=location).as_dict()
client_options["default_user_options"] = pr.player.default_options.as_dict(
)
if pr.user_options:
client_options["room_user_options"] = pr.user_options.as_dict()
await sio.emit("Client.Options.Set",
client_options,
room=sid,
namespace=GAME_NS)
# 2. Load room info
if complete:
await sio.emit(
"Room.Info.Set",
{
"name":
pr.room.name,
"creator":
pr.room.creator.name,
"invitationCode":
str(pr.room.invitation_code),
"isLocked":
pr.room.is_locked,
"default_options":
pr.room.default_options.as_dict(),
"players": [{
"id": rp.player.id,
"name": rp.player.name,
"location": rp.active_location.id,
"role": rp.role,
} for rp in pr.room.players],
"publicName":
config.get("General", "public_name", fallback=""),
},
room=sid,
namespace=GAME_NS,
)
# 3. Load location
await sio.emit("Location.Set",
location.as_dict(),
room=sid,
namespace=GAME_NS)
# 4. Load all location settings (DM)
if complete and pr.role == Role.DM:
await sio.emit(
"Locations.Settings.Set",
{
l.id: {} if l.options is None else l.options.as_dict()
for l in pr.room.locations
},
room=sid,
namespace=GAME_NS,
)
# 5. Load Board
locations = [{
"id": l.id,
"name": l.name,
"archived": l.archived
} for l in pr.room.locations.order_by(Location.index)]
await sio.emit("Board.Locations.Set",
locations,
room=sid,
namespace=GAME_NS)
floors = [floor for floor in location.floors.order_by(Floor.index)]
if "active_floor" in client_options["location_user_options"]:
index = next(i for i, f in enumerate(floors) if f.name ==
client_options["location_user_options"]["active_floor"])
lower_floors = floors[index - 1::-1] if index > 0 else []
higher_floors = floors[index + 1:] if index < len(floors) else []
floors = [floors[index], *lower_floors, *higher_floors]
for floor in floors:
await sio.emit(
"Board.Floor.Set",
floor.as_dict(pr.player, pr.role == Role.DM),
room=sid,
namespace=GAME_NS,
)
# 6. Load Initiative
location_data = Initiative.get_or_none(location=location)
if location_data:
await sio.emit("Initiative.Set",
location_data.as_dict(),
room=sid,
namespace=GAME_NS)
# 7. Load labels
if complete:
labels = Label.select().where((Label.user == pr.player)
| (Label.visible == True))
label_filters = LabelSelection.select().where(
(LabelSelection.user == pr.player)
& (LabelSelection.room == pr.room))
await sio.emit(
"Labels.Set",
[l.as_dict() for l in labels],
room=sid,
namespace=GAME_NS,
)
await sio.emit(
"Labels.Filters.Set",
[l.label.uuid for l in label_filters],
room=sid,
namespace=GAME_NS,
)
# 8. Load Notes
await sio.emit(
"Notes.Set",
[
note.as_dict()
for note in Note.select().where((Note.user == pr.player)
& (Note.room == pr.room))
],
room=sid,
namespace=GAME_NS,
)
# 9. Load Markers
await sio.emit(
"Markers.Set",
[
marker.as_string()
for marker in Marker.select(Marker.shape_id).where(
(Marker.user == pr.player) & (Marker.location == location))
],
room=sid,
namespace=GAME_NS,
)
# 10. Load Assets
if complete:
await sio.emit(
"Asset.List.Set",
Asset.get_user_structure(pr.player),
room=sid,
namespace=GAME_NS,
)
async def update_initiative(sid, data):
sid_data = state.sid_map[sid]
user = sid_data["user"]
room = sid_data["room"]
location = sid_data["location"]
shape = Shape.get_or_none(uuid=data["uuid"])
owner = ShapeOwner.get_or_none(shape=shape, user=user) is not None
if room.creator != user and not owner:
logger.warning(
f"{user.name} attempted to change initiative of an asset it does not own"
)
return
used_to_be_visible = False
location_data = InitiativeLocationData.get_or_none(location=location)
if location_data is None:
location_data = InitiativeLocationData.create(location=location,
turn=data["uuid"],
round=1)
initiatives = Initiative.select().where(
Initiative.location_data == location_data)
initiative = Initiative.get_or_none(uuid=data["uuid"])
# Create new initiative
if initiative is None:
with db.atomic():
# Update indices
try:
index = (initiatives.where(
Initiative.initiative >= data["initiative"]).order_by(
-Initiative.index)[0].index + 1)
except IndexError:
index = 0
else:
Initiative.update(
index=Initiative.index +
1).where((Initiative.location_data == location_data)
& (Initiative.index >= index))
# Create model instance
initiative = dict_to_model(Initiative,
reduce_data_to_model(Initiative, data))
initiative.location_data = location_data
initiative.index = index
initiative.save(force_insert=True)
# Remove initiative
elif "initiative" not in data:
with db.atomic():
Initiative.update(
index=Initiative.index -
1).where((Initiative.location_data == location_data)
& (Initiative.index >= initiative.index))
initiative.delete_instance(True)
# Update initiative
else:
used_to_be_visible = initiative.visible
with db.atomic():
if data["initiative"] != initiative.initiative:
# Update indices
old_index = initiative.index
try:
new_index = (initiatives.where(
Initiative.initiative >= data["initiative"]).order_by(
-Initiative.index)[0].index)
except IndexError:
new_index = 0
else:
if new_index < old_index:
new_index += 1
if old_index != new_index:
# SIGN=1 IF old_index > new_index WHICH MEANS the initiative is increased
# SIGN=-1 IF old_index < new_index WHICH MEANS the initiative is decreased
sign = (old_index - new_index) // abs(old_index -
new_index)
indices = [0, old_index, new_index]
update = Initiative.update(
index=Initiative.index +
sign).where((Initiative.location_data == location_data)
& (Initiative.index <= indices[sign])
& (Initiative.index >= indices[-sign]))
update.execute()
data["index"] = new_index
# Update model instance
update_model_from_dict(initiative,
reduce_data_to_model(Initiative, data))
initiative.save()
data["index"] = initiative.index
await send_client_initiatives(room, location)
async def update_initiative(sid: int, data: Dict[str, Any]):
pr: PlayerRoom = game_state.get(sid)
shape = Shape.get_or_none(uuid=data["uuid"])
if not has_ownership(shape, pr):
logger.warning(
f"{pr.player.name} attempted to change initiative of an asset it does not own"
)
return
location_data = InitiativeLocationData.get_or_none(
location=pr.active_location)
if location_data is None:
location_data = InitiativeLocationData.create(
location=pr.active_location, turn=data["uuid"], round=1)
initiatives = Initiative.select().where(
Initiative.location_data == location_data)
initiative = Initiative.get_or_none(uuid=data["uuid"])
# Create new initiative
if initiative is None:
with db.atomic():
# Update indices
try:
index = (initiatives.where(
Initiative.initiative >= data["initiative"]).order_by(
-Initiative.index)[0].index + 1)
except IndexError:
index = 0
else:
Initiative.update(
index=Initiative.index +
1).where((Initiative.location_data == location_data)
& (Initiative.index >= index))
# Create model instance
initiative = dict_to_model(Initiative,
reduce_data_to_model(Initiative, data))
initiative.location_data = location_data
initiative.index = index
initiative.save(force_insert=True)
# Update initiative
else:
with db.atomic():
if data["initiative"] != initiative.initiative:
# Update indices
old_index = initiative.index
try:
new_index = (initiatives.where(
Initiative.initiative >= data["initiative"]).order_by(
-Initiative.index)[0].index)
except IndexError:
new_index = 0
else:
if new_index < old_index:
new_index += 1
if old_index != new_index:
# SIGN=1 IF old_index > new_index WHICH MEANS the initiative is increased
# SIGN=-1 IF old_index < new_index WHICH MEANS the initiative is decreased
sign = (old_index - new_index) // abs(old_index -
new_index)
indices = [0, old_index, new_index]
update = Initiative.update(
index=Initiative.index +
sign).where((Initiative.location_data == location_data)
& (Initiative.index <= indices[sign])
& (Initiative.index >= indices[-sign]))
update.execute()
data["index"] = new_index
# Update model instance
update_model_from_dict(initiative,
reduce_data_to_model(Initiative, data))
initiative.save()
data["index"] = initiative.index
await send_client_initiatives(pr)
