tabletop-frog/src/ttfrog/db/schema/character.py

from sqlalchemy import ForeignKey, Text, UniqueConstraint
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.orm import Mapped, mapped_column, relationship

from ttfrog.db.base import BaseObject, SavingThrowsMixin, SkillsMixin, SlugMixin
from ttfrog.db.schema.classes import CharacterClass, ClassAttribute
from ttfrog.db.schema.modifiers import Modifier, ModifierMixin, Stat

__all__ = [
    "Ancestry",
    "AncestryTrait",
    "AncestryTraitMap",
    "CharacterClassMap",
    "CharacterClassAttributeMap",
    "Character",
    "Modifier",
]


def class_map_creator(fields):
    if isinstance(fields, CharacterClassMap):
        return fields
    return CharacterClassMap(**fields)


def attr_map_creator(fields):
    if isinstance(fields, CharacterClassAttributeMap):
        return fields
    return CharacterClassAttributeMap(**fields)


class AncestryTraitMap(BaseObject):
    __tablename__ = "trait_map"
    __table_args__ = (UniqueConstraint("ancestry_id", "ancestry_trait_id"),)
    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
    ancestry_id: Mapped[int] = mapped_column(ForeignKey("ancestry.id"))
    ancestry_trait_id: Mapped[int] = mapped_column(ForeignKey("ancestry_trait.id"), init=False)
    trait: Mapped["AncestryTrait"] = relationship(uselist=False, lazy="immediate")
    level: Mapped[int] = mapped_column(nullable=False, info={"min": 1, "max": 20})


class Ancestry(BaseObject, ModifierMixin):
    """
    A character ancestry ("race"), which has zero or more AncestryTraits and Modifiers.
    """

    __tablename__ = "ancestry"
    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
    name: Mapped[str] = mapped_column(unique=True, nullable=False)

    creature_type: Mapped[str] = mapped_column(nullable=False, default="humanoid")
    size: Mapped[str] = mapped_column(nullable=False, default="medium")
    walk_speed: Mapped[int] = mapped_column(nullable=False, default=30, info={"min": 0, "max": 99})

    _fly_speed: Mapped[int] = mapped_column(init=False, nullable=True, info={"min": 0, "max": 99})
    _climb_speed: Mapped[int] = mapped_column(init=False, nullable=True, info={"min": 0, "max": 99})
    _swim_speed: Mapped[int] = mapped_column(init=False, nullable=True, info={"min": 0, "max": 99})

    _traits = relationship(
        "AncestryTraitMap", init=False, uselist=True, cascade="all,delete,delete-orphan", lazy="immediate"
    )

    @property
    def traits(self):
        return [mapping.trait for mapping in self._traits]

    @property
    def speed(self):
        return self.walk_speed

    @property
    def climb_speed(self):
        return self._climb_speed or int(self.speed / 2)

    @property
    def swim_speed(self):
        return self._swim_speed or int(self.speed / 2)

    def add_trait(self, trait, level=1):
        if not self._traits or trait not in self._traits:
            mapping = AncestryTraitMap(ancestry_id=self.id, trait=trait, level=level)
            if not self._traits:
                self._traits = [mapping]
            else:
                self._traits.append(mapping)
            return True
        return False

    def __repr__(self):
        return self.name


class AncestryTrait(BaseObject, ModifierMixin):
    """
    A trait granted to a character via its Ancestry.
    """

    __tablename__ = "ancestry_trait"
    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
    name: Mapped[str] = mapped_column(nullable=False)
    description: Mapped[Text] = mapped_column(Text, default="")

    def __repr__(self):
        return self.name


class CharacterClassMap(BaseObject):
    __tablename__ = "class_map"
    __table_args__ = (UniqueConstraint("character_id", "character_class_id"),)
    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
    character: Mapped["Character"] = relationship(uselist=False, viewonly=True)
    character_class: Mapped["CharacterClass"] = relationship(lazy="immediate")

    character_id: Mapped[int] = mapped_column(ForeignKey("character.id"), init=False, nullable=False)
    character_class_id: Mapped[int] = mapped_column(ForeignKey("character_class.id"), init=False, nullable=False)

    level: Mapped[int] = mapped_column(nullable=False, info={"min": 1, "max": 20}, default=1)

    def __repr__(self):
        return f"{self.character.name}, {self.character_class.name}, level {self.level}"


class CharacterClassAttributeMap(BaseObject):
    __tablename__ = "character_class_attribute_map"
    __table_args__ = (UniqueConstraint("character_id", "class_attribute_id"),)
    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
    character_id: Mapped[int] = mapped_column(ForeignKey("character.id"), nullable=False)
    class_attribute_id: Mapped[int] = mapped_column(ForeignKey("class_attribute.id"), nullable=False)
    option_id: Mapped[int] = mapped_column(ForeignKey("class_attribute_option.id"), nullable=False)

    class_attribute: Mapped["ClassAttribute"] = relationship(lazy="immediate")
    option = relationship("ClassAttributeOption", lazy="immediate")

    character_class = relationship(
        "CharacterClass",
        secondary="class_map",
        primaryjoin="CharacterClassAttributeMap.character_id == CharacterClassMap.character_id",
        secondaryjoin="CharacterClass.id == CharacterClassMap.character_class_id",
        viewonly=True,
        uselist=False,
    )


class Character(BaseObject, SlugMixin, SavingThrowsMixin, SkillsMixin, ModifierMixin):
    __tablename__ = "character"

    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)

    name: Mapped[str] = mapped_column(default="New Character", nullable=False)
    hit_points: Mapped[int] = mapped_column(default=10, nullable=False, info={"min": 0, "max": 999})
    temp_hit_points: Mapped[int] = mapped_column(default=0, nullable=False, info={"min": 0, "max": 999})

    _max_hit_points: Mapped[int] = mapped_column(
        default=10, nullable=False, info={"min": 0, "max": 999, "modifiable": True}
    )
    _armor_class: Mapped[int] = mapped_column(
        default=10, nullable=False, info={"min": 1, "max": 99, "modifiable": True}
    )
    _strength: Mapped[int] = mapped_column(
        nullable=False, default=10, info={"min": 0, "max": 30, "modifiable_class": Stat}
    )
    _dexterity: Mapped[int] = mapped_column(
        nullable=False, default=10, info={"min": 0, "max": 30, "modifiable_class": Stat}
    )
    _constitution: Mapped[int] = mapped_column(
        nullable=False, default=10, info={"min": 0, "max": 30, "modifiable_class": Stat}
    )
    _intelligence: Mapped[int] = mapped_column(
        nullable=False, default=10, info={"min": 0, "max": 30, "modifiable_class": Stat}
    )
    _wisdom: Mapped[int] = mapped_column(
        nullable=False, default=10, info={"min": 0, "max": 30, "modifiable_class": Stat}
    )
    _charisma: Mapped[int] = mapped_column(
        nullable=False, default=10, info={"min": 0, "max": 30, "modifiable_class": Stat}
    )

    _vision: Mapped[int] = mapped_column(default=None, nullable=True, info={"min": 0, "modifiable": True})

    _proficiencies: Mapped[str] = mapped_column(nullable=False, default="")

    class_map = relationship("CharacterClassMap", cascade="all,delete,delete-orphan")
    class_list = association_proxy("class_map", "id", creator=class_map_creator)

    character_class_attribute_map = relationship("CharacterClassAttributeMap", cascade="all,delete,delete-orphan")
    attribute_list = association_proxy("character_class_attribute_map", "id", creator=attr_map_creator)

    ancestry_id: Mapped[int] = mapped_column(ForeignKey("ancestry.id"), nullable=False, default="1")
    ancestry: Mapped["Ancestry"] = relationship(uselist=False, default=None)

    @property
    def modifiers(self):
        unified = {}
        unified.update(**self.ancestry.modifiers)
        for trait in self.traits:
            unified.update(**trait.modifiers)
        unified.update(**super().modifiers)
        return unified

    @property
    def classes(self):
        return dict([(mapping.character_class.name, mapping.character_class) for mapping in self.class_map])

    @property
    def traits(self):
        return self.ancestry.traits

    @property
    def speed(self):
        return self._apply_modifiers("speed", self.ancestry.speed)

    @property
    def climb_speed(self):
        return self._apply_modifiers("climb_speed", self.ancestry._climb_speed)

    @property
    def swim_speed(self):
        return self._apply_modifiers("swim_speed", self.ancestry._swim_speed)

    @property
    def fly_speed(self):
        return self._apply_modifiers("fly_speed", self.ancestry._fly_speed)

    @property
    def size(self):
        return self._apply_modifiers("size", self.ancestry.size)

    @property
    def vision_in_darkness(self):
        return self.apply_modifiers("vision_in_darkness", self.vision if self.vision is not None else 0)

    @property
    def level(self):
        return sum(mapping.level for mapping in self.class_map)

    @property
    def levels(self):
        return dict([(mapping.character_class.name, mapping.level) for mapping in self.class_map])

    @property
    def class_attributes(self):
        return dict([(mapping.class_attribute.name, mapping.option) for mapping in self.character_class_attribute_map])

    def add_class(self, newclass, level=1):
        if level == 0:
            return self.remove_class(newclass)
        level_in_class = [mapping for mapping in self.class_map if mapping.character_class_id == newclass.id]
        if level_in_class:
            level_in_class = level_in_class[0]
            level_in_class.level = level
        else:
            self.class_list.append(CharacterClassMap(character=self, character_class=newclass, level=level))
        for lvl in range(1, level + 1):
            if not newclass.attributes_by_level[lvl]:
                continue
            for attr_name, attr in newclass.attributes_by_level[lvl].items():
                self.add_class_attribute(attr, attr.options[0])

    def remove_class(self, target):
        self.class_map = [m for m in self.class_map if m.character_class != target]
        for mapping in self.character_class_attribute_map:
            if mapping.character_class.id == target.id:
                self.remove_class_attribute(mapping.class_attribute)

    def remove_class_attribute(self, attribute):
        self.character_class_attribute_map = [
            m for m in self.character_class_attribute_map if m.class_attribute.id != attribute.id
        ]

    def add_class_attribute(self, attribute, option):
        for thisclass in self.classes.values():
            current_level = self.levels[thisclass.name]
            current_attributes = thisclass.attributes_by_level.get(current_level, {})
            if attribute.name in current_attributes:
                if attribute.name in self.class_attributes:
                    return True
                self.attribute_list.append(
                    CharacterClassAttributeMap(
                        character_id=self.id,
                        class_attribute_id=attribute.id,
                        option_id=option.id,
                        class_attribute=attribute,
                    )
                )
                return True
        return False