No description
Find a file
2024-09-28 20:13:11 +03:00
assets i did some stuff, honestly it starts to build pretty well if i might sayy 2024-09-28 20:13:11 +03:00
src i did some stuff, honestly it starts to build pretty well if i might sayy 2024-09-28 20:13:11 +03:00
tavern_macros i did some stuff, honestly it starts to build pretty well if i might sayy 2024-09-28 20:13:11 +03:00
.gitignore I DID STUFF, GOD A PROC MACRO AND SHIT 2024-09-22 23:46:51 +03:00
Cargo.lock I DID STUFF, GOD A PROC MACRO AND SHIT 2024-09-22 23:46:51 +03:00
Cargo.toml I DID STUFF, GOD A PROC MACRO AND SHIT 2024-09-22 23:46:51 +03:00
db.md I DID STUFF, GOD A PROC MACRO AND SHIT 2024-09-22 23:46:51 +03:00
readme.md i did some stuff, honestly it starts to build pretty well if i might sayy 2024-09-28 20:13:11 +03:00
reqs.md i did some stuff, honestly it starts to build pretty well if i might sayy 2024-09-28 20:13:11 +03:00
table_data.md I DID STUFF, GOD A PROC MACRO AND SHIT 2024-09-22 23:46:51 +03:00

WTF how do i implement a game???

Things you need from a game

Characters and character sheet: [x] Stats and items: get/set/display [ ] Actions (broken into different tabs, aka: (&self) -> Vec<InteractionDefinition>) [ ] Token status: status icons (with tooltip ffs)/light produced/vision distance(in light level) [ ] Apply Action (&mut self, InteractionResult) -> () Spells and items

[ ]Turn based combat callbakcs: [ ] Start of turn - (&mut self) -> Vec<Message> [ ] End of turn

InteractionDef -> Player uses -> Interaction in chat (with actions) -> Rolls some dice -> Interaction

Shoot arrow def -> player A shoots B (rolls attack) -> I nteraction in chat (with Roll damage button) -> InteractionResult (damage/double/block/heal actions) -> Apply InteractionResult ()

trait Action {}
trait CS<A: Action> {

    fn can_use_action(&self, action: &A) -> bool;
}
struct Game<'dec, 'dea, C: CS<A> + Serialize + Deserialize<'dec>, A: Action + Serialize + Deserialize<'dea>> {
    _a: std::marker::PhantomData<&'dea A>,
    _c: std::marker::PhantomData<&'dec C>,
}
impl<'dec, 'dea, C: CS<A> + Serialize + Deserialize<'dec>, A: Action + Serialize + Deserialize<'dea>> Game<'dec, 'dea, C, A> {
    fn read_spell(s: &'dea str) -> A {
        serde_json::de::from_str::<A>(s).unwrap()
    }
}

#[derive(Serialize, Deserialize)]
struct Spell {
    pub mana: i32,
}
impl Action for Spell {}

#[derive(Serialize, Deserialize)]
struct Sheet;
impl CS<Spell> for Sheet {
    fn can_use_action(&self, action: &Spell) -> bool {
        action.mana > 10
    }
}
fn stupid() {
    let game = Game::<'_, '_, Sheet, Spell>::read_spell("aaaaaaaa");
}

^^^ this looks mad isnt it, but it defines 3 traits, Action, Character sheet and game(which should be a trait actually)

  1. Player connects

  2. Player gets character data (including all the relevant actions and such)

  3. Player acts

  4. Player does action

  5. Action is printed to chat (with rolls and such)

  6. Action button is pressed (optional rolls)

fn use_action(&mut self, entry: &Entry, action: &Action) -> ChatMessage

struct Action {
	pub name: String,
	pub roll_result: i32,
}