Adding the model and system tournament blueprint

src/lib.cairo

@@ -5,6 +5,7 @@ mod systems {
     mod spawn;
     mod world_setup;
     mod bag;
+    mod tournament;
 }
 
 mod models {
@@ -26,9 +27,11 @@ mod models {
     mod achievement_rarity;
     mod achievement_type;
     mod achievements;
+    mod tournament;
 }
 
 mod tests {
     mod test_battle;
     mod test_bag;
+    mod test_tournament;
 }

src/models/tournament.cairo

@@ -0,0 +1,23 @@
+use super::player::Player;
+
+#[derive(Serde, Copy, Drop, Introspect, PartialEq)]
+pub enum TournamentStatus {
+    Pending,
+    Ongoing,
+    Completed,
+}
+
+
+#[derive(Drop, Serde)]
+#[dojo::model]
+pub struct Tournament {
+    #[key]
+    pub tournament_id: u32,
+    pub name: felt252,
+    pub status: TournamentStatus,
+    pub entry_fee: u32,
+    pub max_participants: u32,
+    pub current_participants: Array<Player>,
+    pub prize_pool: u32,
+}
+

src/systems/tournament.cairo

@@ -0,0 +1,59 @@
+use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
+use bytebeasts::{models::{player::Player, tournament::Tournament, tournament::TournamentStatus},};
+
+#[dojo::interface]
+trait ITournamentAction {
+    fn create_tournament(
+        ref world: IWorldDispatcher,
+        tournament_id: u32,
+        name: felt252,
+        status: TournamentStatus,
+        entry_fee: u32,
+        max_participants: u32,
+        current_participants: Array<Player>,
+        prize_pool: u32
+    );
+    // fn register_player(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
+    // fn start_tournament(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
+    // fn complete_torunament(ref world: IWorldDispatcher, tournament_id: u32, player_id: u32);
+    fn get_tournament(world: @IWorldDispatcher, tournament_id: u32) -> Tournament;
+}
+
+
+#[dojo::contract]
+mod tournament_system {
+    use super::ITournamentAction;
+    use bytebeasts::{
+        models::{player::Player, tournament::Tournament, tournament::TournamentStatus},
+    };
+
+    #[abi(embed_v0)]
+    impl TournamentActionImpl of ITournamentAction<ContractState> {
+        fn create_tournament(
+            ref world: IWorldDispatcher,
+            tournament_id: u32,
+            name: felt252,
+            status: TournamentStatus,
+            entry_fee: u32,
+            max_participants: u32,
+            current_participants: Array<Player>,
+            prize_pool: u32
+        ) {
+            let tournament = Tournament {
+                tournament_id: tournament_id,
+                name: name,
+                status: status,
+                entry_fee: entry_fee,
+                max_participants: max_participants,
+                current_participants: current_participants,
+                prize_pool: prize_pool
+            };
+            set!(world, (tournament))
+        }
+
+        fn get_tournament(world: @IWorldDispatcher, tournament_id: u32) -> Tournament {
+            let tournament_from_world = get!(world, tournament_id, (Tournament));
+            tournament_from_world
+        }
+    }
+}

src/tests/test_tournament.cairo

@@ -0,0 +1,61 @@
+#[cfg(test)]
+mod tests {
+    use starknet::ContractAddress;
+
+    use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
+    use dojo::utils::test::{spawn_test_world, deploy_contract};
+
+    use bytebeasts::{
+        systems::{
+            tournament::{
+                tournament_system, ITournamentActionDispatcher, ITournamentActionDispatcherTrait
+            }
+        },
+    };
+
+    use bytebeasts::{
+        models::tournament::{{Tournament, tournament}}, models::tournament::TournamentStatus,
+        models::player::{{Player, player}},
+    };
+
+
+    // Helper function
+    // This function create the world and define the required models
+    #[test]
+    fn setup_world() -> (IWorldDispatcher, ITournamentActionDispatcher) {
+        let mut models = array![tournament::TEST_CLASS_HASH];
+
+        let world = spawn_test_world("bytebeasts", models);
+
+        let contract_address = world
+            .deploy_contract('salt', tournament_system::TEST_CLASS_HASH.try_into().unwrap());
+
+        let tournament_system = ITournamentActionDispatcher { contract_address };
+
+        world.grant_writer(dojo::utils::bytearray_hash(@"bytebeasts"), contract_address);
+
+        (world, tournament_system)
+    }
+
+    #[test]
+    fn test_create_tournament() {
+        let (_, tournament_system) = setup_world();
+        let mut players = ArrayTrait::new();
+
+        let player_ash = Player {
+            player_id: 1,
+            player_name: 'Ash',
+            beast_1: 1, // Beast 1 assigned
+            beast_2: 0, // No beast assigned
+            beast_3: 0, // No beast assigned
+            beast_4: 0, // No beast assigned
+            potions: 1
+        };
+        players.append(player_ash);
+
+        tournament_system
+            .create_tournament(1, 'tournament', TournamentStatus::Pending, 1, 2, players, 1);
+        let tournament = tournament_system.get_tournament(1);
+        assert!(tournament.name == 'tournament', "The tournament name is wrong!");
+    }
+}