async def add_shape(sid: int, data: Dict[str, Any]): pr: PlayerRoom = game_state.get(sid) if "temporary" not in data: data["temporary"] = False floor = pr.active_location.floors.select().where( Floor.name == data["shape"]["floor"])[0] layer = floor.layers.where(Layer.name == data["shape"]["layer"])[0] if pr.role != Role.DM and not layer.player_editable: logger.warning( f"{pr.player.name} attempted to add a shape to a dm layer") return if data["temporary"]: game_state.add_temp(sid, data["shape"]["uuid"]) else: with db.atomic(): data["shape"]["layer"] = layer data["shape"]["index"] = layer.shapes.count() # Shape itself shape = Shape.create(**reduce_data_to_model(Shape, data["shape"])) # Subshape type_table = get_table(shape.type_) type_table.create( shape=shape, **type_table.pre_create( **reduce_data_to_model(type_table, data["shape"])), ) # Owners for owner in data["shape"]["owners"]: ShapeOwner.create( shape=shape, user=User.by_name(owner["user"]), edit_access=owner["edit_access"], movement_access=owner["movement_access"], vision_access=owner["vision_access"], ) # Trackers for tracker in data["shape"]["trackers"]: Tracker.create(**reduce_data_to_model(Tracker, tracker), shape=shape) # Auras for aura in data["shape"]["auras"]: Aura.create(**reduce_data_to_model(Aura, aura), shape=shape) for room_player in pr.room.players: is_dm = room_player.role == Role.DM for psid in game_state.get_sids(player=room_player.player, active_location=pr.active_location): if psid == sid: continue if not is_dm and not layer.player_visible: continue if not data["temporary"]: data["shape"] = shape.as_dict(room_player.player, is_dm) await sio.emit("Shape.Add", data["shape"], room=psid, namespace=GAME_NS)
async def add_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] if "temporary" not in data: data["temporary"] = False floor = location.floors.select().where( Floor.name == data["shape"]["floor"])[0] layer = floor.layers.where(Layer.name == data["shape"]["layer"])[0] if room.creator != user and not layer.player_editable: logger.warning(f"{user.name} attempted to add a shape to a dm layer") return if data["temporary"]: state.add_temp(sid, data["shape"]["uuid"]) else: with db.atomic(): data["shape"]["layer"] = layer data["shape"]["index"] = layer.shapes.count() # Shape itself shape = Shape.create(**reduce_data_to_model(Shape, data["shape"])) # Subshape type_table = get_table(shape.type_) type_table.create(shape=shape, **reduce_data_to_model(type_table, data["shape"])) # Owners ShapeOwner.create(shape=shape, user=user) # Trackers for tracker in data["shape"]["trackers"]: Tracker.create(**reduce_data_to_model(Tracker, tracker), shape=shape) # Auras for aura in data["shape"]["auras"]: Aura.create(**reduce_data_to_model(Aura, aura), shape=shape) if layer.player_visible: for room_player in room.players: for psid in state.get_sids(user=room_player.player, room=room): if psid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room_player.player, False) await sio.emit("Shape.Add", data["shape"], room=psid, namespace="/planarally") for csid in state.get_sids(user=room.creator, room=room): if csid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room.creator, True) await sio.emit("Shape.Add", data["shape"], room=csid, namespace="/planarally")
async def create_aura(sid: str, data: AuraDelta): pr: PlayerRoom = game_state.get(sid) shape = get_shape_or_none(pr, data["shape"], "Aura.Create") if shape is None: return model = reduce_data_to_model(Aura, data) aura = Aura.create(**model) aura.save() owners = [*get_owner_sids(pr, shape, skip_sid=sid)] for psid in owners: await sio.emit( "Shape.Options.Aura.Create", data, room=psid, namespace=GAME_NS, ) if aura.visible: for psid in game_state.get_sids( active_location=pr.active_location, skip_sid=sid ): if psid in owners: continue await sio.emit( "Shape.Options.Aura.Create", data, room=psid, namespace=GAME_NS, )
async def update_shape_position(sid: str, data: Dict[str, Any]): pr: PlayerRoom = game_state.get(sid) if data["temporary"] and not has_ownership_temp(data["shape"], pr): logger.warning( f"User {pr.player.name} attempted to move a shape it does not own." ) return shape, layer = await _get_shape(data, pr) # Overwrite the old data with the new data if not data["temporary"]: if not has_ownership(shape, pr): logger.warning( f"User {pr.player.name} attempted to move a shape it does not own." ) return with db.atomic(): # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() if shape.type_ == "polygon": # Subshape type_instance = shape.subtype # no backrefs on these tables type_instance.update_from_dict(data["shape"], ignore_unknown=True) type_instance.save() await sync_shape_update(layer, pr, data, sid, shape)
async def update_shape_position(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] shape, layer = await _get_shape(data, location, user) if not await has_ownership(layer, room, data, user, shape): return # Overwrite the old data with the new data if not data["temporary"]: with db.atomic(): data["shape"]["layer"] = Layer.get(location=location, name=data["shape"]["layer"]) # Shape model = reduce_data_to_model(Shape, data["shape"]) update_model_from_dict(shape, model) shape.save() if shape.type_ == "polygon": # Subshape type_instance = shape.subtype # no backrefs on these tables type_instance.update_from_dict(data["shape"], ignore_unknown=True) type_instance.save() await sync_shape_update(layer, room, data, sid, shape)
async def update_initiative_effect(sid: int, data: Dict[str, Any]): pr: PlayerRoom = game_state.get(sid) if not has_ownership(Shape.get_or_none(uuid=data["actor"]), pr): logger.warning( f"{pr.player.name} attempted to update an initiative effect") return with db.atomic(): effect = InitiativeEffect.get(uuid=data["effect"]["uuid"]) update_model_from_dict( effect, reduce_data_to_model(InitiativeEffect, data["effect"])) effect.save() await sio.emit( "Initiative.Effect.Update", data, room=pr.active_location.get_path(), skip_sid=sid, namespace=GAME_NS, )
async def update_initiative_effect(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] if room.creator != user and not ShapeOwner.get_or_none(shape=shape, user=user): logger.warning(f"{user.name} attempted to update an initiative effect") return with db.atomic(): effect = InitiativeEffect.get(uuid=data["effect"]["uuid"]) update_model_from_dict( effect, reduce_data_to_model(InitiativeEffect, data["effect"])) effect.save() await sio.emit( "Initiative.Effect.Update", data, room=location.get_path(), skip_sid=sid, namespace="/planarally", )
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)
async def update_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] # We're first gonna retrieve the existing server side shape for some validation checks if data["temporary"]: # This stuff is not stored so we cannot do any server side validation /shrug shape = data["shape"] layer = location.layers.where(Layer.name == data["shape"]["layer"])[0] else: # Use the server version of the shape. try: shape = Shape.get(uuid=data["shape"]["uuid"]) except Shape.DoesNotExist: logger.warning(f"Attempt to update unknown shape by {user.name}") return layer = shape.layer # Ownership validatation if room.creator != user: if not layer.player_editable: logger.warning( f"{user.name} attempted to move a shape on a dm layer") return if data["temporary"]: if user.name not in shape["owners"]: logger.warning( f"{user.name} attempted to move asset it does not own") return else: if not ShapeOwner.get_or_none(shape=shape, user=user): logger.warning( f"{user.name} attempted to move asset it does not own") return # Overwrite the old data with the new data if not data["temporary"]: with db.atomic(): data["shape"]["layer"] = Layer.get(location=location, name=data["shape"]["layer"]) # Otherwise backrefs can cause errors as they need to be handled separately update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() type_table = get_table(shape.type_) type_instance = type_table.get(uuid=shape.uuid) # no backrefs on these tables update_model_from_dict(type_instance, data["shape"], ignore_unknown=True) type_instance.save() old_owners = {owner.user.name for owner in shape.owners} new_owners = set(data["shape"]["owners"]) for owner in old_owners ^ new_owners: if owner == "": continue delta_owner = User.by_name(owner) if owner in new_owners: ShapeOwner.create(shape=shape, user=delta_owner) else: ShapeOwner.get(shape=shape, user=delta_owner).delete_instance(True) await send_client_initiatives(room, location, delta_owner) # Send to players if layer.player_visible: for room_player in room.players: for psid in state.get_sids(user=room_player.player, room=room): if psid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room_player.player, False) await sio.emit("Shape.Update", data, room=psid, namespace="/planarally") # Send to DM for csid in state.get_sids(user=room.creator, room=room): if csid == sid: continue if not data["temporary"]: data["shape"] = shape.as_dict(room.creator, True) await sio.emit("Shape.Update", data, room=csid, namespace="/planarally")
async def update_shape(sid: int, data: Dict[str, Any]): pr: PlayerRoom = game_state.get(sid) if data["temporary"] and not has_ownership_temp(data["shape"], pr): logger.warning( f"User {pr.player.name} tried to update a shape it does not own.") return # todo clean up this mess that deals with both temporary and non temporary shapes shape, layer = await _get_shape(data, pr) # Overwrite the old data with the new data if not data["temporary"]: if not has_ownership(shape, pr): logger.warning( f"User {pr.player.name} tried to update a shape it does not own." ) return with db.atomic(): # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() # Subshape type_instance = shape.subtype # no backrefs on these tables type_instance.update_from_dict(data["shape"], ignore_unknown=True) type_instance.save() # Trackers old_trackers = {tracker.uuid for tracker in shape.trackers} new_trackers = { tracker["uuid"] for tracker in data["shape"]["trackers"] } for tracker_id in old_trackers | new_trackers: remove = tracker_id in old_trackers - new_trackers if not remove: tracker = next(tr for tr in data["shape"]["trackers"] if tr["uuid"] == tracker_id) reduced = reduce_data_to_model(Tracker, tracker) reduced["shape"] = shape if tracker_id in new_trackers - old_trackers: Tracker.create(**reduced) continue tracker_db = Tracker.get(uuid=tracker_id) if remove: tracker_db.delete_instance(True) else: update_model_from_dict(tracker_db, reduced) tracker_db.save() # Auras old_auras = {aura.uuid for aura in shape.auras} new_auras = {aura["uuid"] for aura in data["shape"]["auras"]} for aura_id in old_auras | new_auras: remove = aura_id in old_auras - new_auras if not remove: aura = next(au for au in data["shape"]["auras"] if au["uuid"] == aura_id) reduced = reduce_data_to_model(Aura, aura) reduced["shape"] = shape if aura_id in new_auras - old_auras: Aura.create(**reduced) continue aura_db = Aura.get_or_none(uuid=aura_id) if remove: aura_db.delete_instance(True) else: update_model_from_dict(aura_db, reduced) aura_db.save() # Labels for label in data["shape"]["labels"]: label_db = Label.get_or_none(uuid=label["uuid"]) reduced = reduce_data_to_model(Label, label) reduced["user"] = User.by_name(reduced["user"]) if label_db: update_model_from_dict(label_db, reduced) label_db.save() else: Label.create(**reduced) old_labels = { shape_label.label.uuid for shape_label in shape.labels } new_labels = set(label["uuid"] for label in data["shape"]["labels"]) for label in old_labels ^ new_labels: if label == "": continue if label in new_labels: ShapeLabel.create(shape=shape, label=Label.get(uuid=label)) else: ShapeLabel.get(label=Label.get(uuid=label), shape=shape).delete_instance(True) await sync_shape_update(layer, pr, data, sid, shape)
async def update_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] shape, layer = await _get_shape(data, location, user) if not await has_ownership(layer, room, data, user, shape): return # Overwrite the old data with the new data if not data["temporary"]: with db.atomic(): data["shape"]["layer"] = Layer.get(location=location, name=data["shape"]["layer"]) # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() # Subshape type_instance = shape.subtype # no backrefs on these tables type_instance.update_from_dict(data["shape"], ignore_unknown=True) type_instance.save() # Owners old_owners = {owner.user.name for owner in shape.owners} new_owners = set(data["shape"]["owners"]) for owner in old_owners ^ new_owners: if owner == "": continue delta_owner = User.by_name(owner) if owner in new_owners: ShapeOwner.create(shape=shape, user=delta_owner) else: ShapeOwner.get(shape=shape, user=delta_owner).delete_instance(True) await send_client_initiatives(room, location, delta_owner) # Trackers old_trackers = {tracker.uuid for tracker in shape.trackers} new_trackers = { tracker["uuid"] for tracker in data["shape"]["trackers"] } for tracker_id in old_trackers | new_trackers: remove = tracker_id in old_trackers - new_trackers if not remove: tracker = next(tr for tr in data["shape"]["trackers"] if tr["uuid"] == tracker_id) reduced = reduce_data_to_model(Tracker, tracker) reduced["shape"] = shape if tracker_id in new_trackers - old_trackers: Tracker.create(**reduced) continue tracker_db = Tracker.get(uuid=tracker_id) if remove: tracker_db.delete_instance(True) else: update_model_from_dict(tracker_db, reduced) tracker_db.save() # Auras old_auras = {aura.uuid for aura in shape.auras} new_auras = {aura["uuid"] for aura in data["shape"]["auras"]} for aura_id in old_auras | new_auras: remove = aura_id in old_auras - new_auras if not remove: aura = next(au for au in data["shape"]["auras"] if au["uuid"] == aura_id) reduced = reduce_data_to_model(Aura, aura) reduced["shape"] = shape if aura_id in new_auras - old_auras: Aura.create(**reduced) continue aura_db = Aura.get_or_none(uuid=aura_id) if remove: aura_db.delete_instance(True) else: update_model_from_dict(aura_db, reduced) aura_db.save() # Labels for label in data["shape"]["labels"]: label_db = Label.get_or_none(uuid=label["uuid"]) reduced = reduce_data_to_model(Label, label) reduced["user"] = User.by_name(reduced["user"]) if label_db: update_model_from_dict(label_db, reduced) label_db.save() else: Label.create(**reduced) shape_label_db = ShapeLabel.get_or_none(shape=shape, label=label_db) old_labels = { shape_label.label.uuid for shape_label in shape.labels } new_labels = set(label["uuid"] for label in data["shape"]["labels"]) for label in old_labels ^ new_labels: if label == "": continue if label in new_labels: ShapeLabel.create(shape=shape, label=Label.get(uuid=label)) else: ShapeLabel.get(label=Label.get(uuid=label), shape=shape).delete_instance(True) await sync_shape_update(layer, room, data, sid, shape)
async def update_shape(sid, data): sid_data = state.sid_map[sid] user = sid_data["user"] room = sid_data["room"] location = sid_data["location"] shape, layer = await _get_shape(data, location, user) if not await has_ownership(layer, room, data, user, shape): return # Overwrite the old data with the new data if not data["temporary"]: with db.atomic(): data["shape"]["layer"] = Layer.get(location=location, name=data["shape"]["layer"]) # Shape update_model_from_dict(shape, reduce_data_to_model(Shape, data["shape"])) shape.save() # Subshape type_table = get_table(shape.type_) type_instance = type_table.get(uuid=shape.uuid) # no backrefs on these tables update_model_from_dict(type_instance, data["shape"], ignore_unknown=True) type_instance.save() # Owners old_owners = {owner.user.name for owner in shape.owners} new_owners = set(data["shape"]["owners"]) for owner in old_owners ^ new_owners: if owner == "": continue delta_owner = User.by_name(owner) if owner in new_owners: ShapeOwner.create(shape=shape, user=delta_owner) else: ShapeOwner.get(shape=shape, user=delta_owner).delete_instance(True) await send_client_initiatives(room, location, delta_owner) # Trackers for tracker in data["shape"]["trackers"]: tracker_db = Tracker.get_or_none(uuid=tracker["uuid"]) reduced = reduce_data_to_model(Tracker, tracker) reduced["shape"] = shape if tracker_db: update_model_from_dict(tracker_db, reduced) tracker_db.save() else: Tracker.create(**reduced) # Auras for aura in data["shape"]["auras"]: aura_db = Aura.get_or_none(uuid=aura["uuid"]) reduced = reduce_data_to_model(Aura, aura) reduced["shape"] = shape if aura_db: update_model_from_dict(aura_db, reduced) aura_db.save() else: Aura.create(**reduced) await sync_shape_update(layer, room, data, sid, shape)
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)