feat: implement create_profile() and create_tornament()

src/interfaces/ISnooknet.cairo

@@ -1,16 +1,28 @@
 use dojo_starter::model::game_model::{Game};
-
+use dojo_starter::model::tournament_model::TournamentReward;
 
 use starknet::{ContractAddress};
 
 // define the interface
 #[starknet::interface]
 pub trait ISnooknet<T> {
     // fn register(ref self: T, username: felt252, is_anonymous: bool);
+    fn create_player(ref self: T);
     fn create_match(ref self: T, opponent: ContractAddress, stake_amount: u256) -> u256;
     fn create_new_game_id(ref self: T) -> u256;
     fn end_match(ref self: T, game_id: u256, winner: ContractAddress);
     fn retrieve_game(ref self: T, game_id: u256) -> Game;
+
+    fn create_tournament(
+        ref self: T,
+        name: felt252,
+        max_players: u8,
+        start_date: u64,
+        end_date: u64,
+        rewards: Array<TournamentReward>,
+    ) -> u256;
+    fn join_tournament(ref self: T, tournament_id: u256);
+    fn end_tournament(ref self: T, tournament_id: u256);
     // fn mint_nft(ref self: T, asset_type: AssetType, rarity: Rarity) -> u256;
 // fn lease_nft(ref self: T, asset_id: u256, leasee: ContractAddress);
 // fn submit_proposal(ref self: T, proposal_id: u256);

src/lib.cairo

@@ -4,6 +4,8 @@ pub mod systems {
 
 pub mod model {
     pub mod game_model;
+    pub mod player_model;
+    pub mod tournament_model;
 }
 
 pub mod interfaces {

src/model/player_model.cairo

@@ -0,0 +1,135 @@
+use starknet::ContractAddress;
+
+#[derive(Copy, Drop, Serde, Debug)]
+#[dojo::model]
+pub struct Player {
+    #[key]
+    pub contract_address: ContractAddress,
+    pub leaderboard_position: u64,
+    pub xp: u256,
+    pub elo_rating: u256,
+    pub games_won: u64,
+    pub games_lost: u64,
+    pub nft_coins_available: u256,
+    pub level: u32,
+}
+
+pub trait PlayerTrait {
+    // Create and return a new player
+    fn new(
+        contract_address: ContractAddress,
+        leaderboard_position: u64,
+        xp: u256,
+        elo_rating: u256,
+        games_won: u64,
+        games_lost: u64,
+        nft_coins_available: u256,
+        level: u32,
+    ) -> Player;
+}
+
+impl PlayerImpl of PlayerTrait {
+    fn new(
+        contract_address: ContractAddress,
+        leaderboard_position: u64,
+        xp: u256,
+        elo_rating: u256,
+        games_won: u64,
+        games_lost: u64,
+        nft_coins_available: u256,
+        level: u32,
+    ) -> Player {
+        Player {
+            contract_address,
+            leaderboard_position,
+            xp,
+            elo_rating,
+            games_won,
+            games_lost,
+            nft_coins_available,
+            level,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{PlayerImpl};
+    use starknet::contract_address::contract_address_const;
+
+    #[test]
+    #[available_gas(999999)]
+    fn test_player_creation() {
+        let contract_address = contract_address_const::<'player_1'>();
+        let leaderboard_position = 1_u64;
+        let xp = 100_u256;
+        let elo_rating = 1500_u256;
+        let games_won = 5_u64;
+        let games_lost = 2_u64;
+        let nft_coins_available = 10_u256;
+        let level = 1_u32;
+
+        let player = PlayerImpl::new(
+            contract_address,
+            leaderboard_position,
+            xp,
+            elo_rating,
+            games_won,
+            games_lost,
+            nft_coins_available,
+            level,
+        );
+
+        assert(player.contract_address == contract_address, 'Contract address mismatch');
+        assert(
+            player.leaderboard_position == leaderboard_position, 'Leaderboard position mismatch',
+        );
+        assert(player.xp == xp, 'XP mismatch');
+        assert(player.elo_rating == elo_rating, 'Elo rating mismatch');
+        assert(player.games_won == games_won, 'Games won mismatch');
+        assert(player.games_lost == games_lost, 'Games lost mismatch');
+        assert(player.nft_coins_available == nft_coins_available, 'NFT coins mismatch');
+        assert(player.level == level, 'Level mismatch');
+    }
+
+    #[test]
+    #[available_gas(999999)]
+    fn test_player_with_zero_values() {
+        let contract_address = contract_address_const::<'player_1'>();
+        let player = PlayerImpl::new(
+            contract_address, 0_u64, 0_u256, 0_u256, 0_u64, 0_u64, 0_u256, 0_u32,
+        );
+
+        assert(player.contract_address == contract_address, 'Contract address mismatch');
+        assert(player.leaderboard_position == 0_u64, 'Incorrect leaderboard position');
+        assert(player.xp == 0_u256, 'XP should be 0');
+        assert(player.elo_rating == 0_u256, 'Elo rating should be 0');
+        assert(player.games_won == 0_u64, 'Games won should be 0');
+        assert(player.games_lost == 0_u64, 'Games lost should be 0');
+        assert(player.nft_coins_available == 0_u256, 'NFT coins should be 0');
+        assert(player.level == 0_u32, 'Level should be 0');
+    }
+
+    #[test]
+    #[available_gas(999999)]
+    fn test_player_with_max_values() {
+        let contract_address = contract_address_const::<'player_1'>();
+        let max_u64 = 18446744073709551615_u64;
+        let max_u256 = 340282366920938463463374607431768211455_u256;
+        let max_u32 = 4294967295_u32;
+
+        let player = PlayerImpl::new(
+            contract_address, max_u64, max_u256, max_u256, max_u64, max_u64, max_u256, max_u32,
+        );
+
+        assert(player.contract_address == contract_address, 'Contract address mismatch');
+        assert(player.leaderboard_position == max_u64, 'Incorrect leaderboard position');
+        assert(player.xp == max_u256, 'XP should be max');
+        assert(player.elo_rating == max_u256, 'Elo rating should be max');
+        assert(player.games_won == max_u64, 'Games won should be max');
+        assert(player.games_lost == max_u64, 'Games lost should be max');
+        assert(player.nft_coins_available == max_u256, 'NFT coins should be max');
+        assert(player.level == max_u32, 'Level should be max');
+    }
+}
+

src/model/tournament_model.cairo

@@ -0,0 +1,151 @@
+use starknet::{ContractAddress};
+
+#[derive(Serde, Copy, Drop, Introspect)]
+#[dojo::model]
+pub struct TournamentCounter {
+    #[key]
+    pub id: felt252,
+    pub current_val: u256,
+}
+
+#[derive(Copy, Drop, Serde, Debug, Introspect, PartialEq)]
+pub enum TournamentStatus {
+    Pending,
+    Active,
+    Ended,
+}
+
+#[derive(Drop, Serde, Debug, Introspect)]
+pub struct TournamentReward {
+    pub position: u8,
+    pub amount: u256,
+    pub token_type: felt252,
+}
+
+#[derive(Drop, Serde, Debug)]
+#[dojo::model]
+pub struct Tournament {
+    #[key]
+    pub id: u256,
+    pub name: felt252,
+    pub organizer: ContractAddress,
+    pub max_players: u8,
+    pub current_players: u8,
+    pub start_date: u64,
+    pub end_date: u64,
+    pub status: TournamentStatus,
+    pub rewards: Array<TournamentReward>,
+}
+
+pub trait TournamentTrait {
+    fn new(
+        id: u256,
+        name: felt252,
+        organizer: ContractAddress,
+        max_players: u8,
+        start_date: u64,
+        end_date: u64,
+        rewards: Array<TournamentReward>,
+    ) -> Tournament;
+}
+
+impl TournamentImpl of TournamentTrait {
+    fn new(
+        id: u256,
+        name: felt252,
+        organizer: ContractAddress,
+        max_players: u8,
+        start_date: u64,
+        end_date: u64,
+        rewards: Array<TournamentReward>,
+    ) -> Tournament {
+        Tournament {
+            id,
+            name,
+            organizer,
+            max_players,
+            current_players: 0,
+            start_date,
+            end_date,
+            status: TournamentStatus::Pending,
+            rewards,
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::{TournamentImpl, TournamentStatus, TournamentReward};
+    use starknet::contract_address::contract_address_const;
+
+    #[test]
+    #[available_gas(999999)]
+    fn test_tournament_creation() {
+        let id = 1_u256;
+        let name = 'Test Tournament';
+        let organizer = contract_address_const::<'organizer'>();
+        let max_players = 8_u8;
+        let start_date = 1000_u64;
+        let end_date = 2000_u64;
+
+        let mut rewards = ArrayTrait::new();
+        rewards.append(TournamentReward { position: 1_u8, amount: 1000_u256, token_type: 'ETH' });
+        rewards.append(TournamentReward { position: 2_u8, amount: 500_u256, token_type: 'ETH' });
+
+        let tournament = TournamentImpl::new(
+            id, name, organizer, max_players, start_date, end_date, rewards,
+        );
+
+        assert(tournament.id == id, 'ID mismatch');
+        assert(tournament.name == name, 'Name mismatch');
+        assert(tournament.organizer == organizer, 'Organizer mismatch');
+        assert(tournament.max_players == max_players, 'Max players mismatch');
+        assert(tournament.current_players == 0, 'Current players should be empty');
+        assert(tournament.start_date == start_date, 'Start date mismatch');
+        assert(tournament.end_date == end_date, 'End date mismatch');
+        assert(tournament.status == TournamentStatus::Pending, 'Status should be Pending');
+        assert(tournament.rewards.len() == 2, 'Rewards length mismatch');
+    }
+
+    #[test]
+    #[available_gas(999999)]
+    fn test_tournament_with_empty_rewards() {
+        let id = 2_u256;
+        let name = 'Empty Rewards Tournament';
+        let organizer = contract_address_const::<'organizer'>();
+        let max_players = 4_u8;
+        let start_date = 1000_u64;
+        let end_date = 2000_u64;
+        let rewards = ArrayTrait::new();
+
+        let tournament = TournamentImpl::new(
+            id, name, organizer, max_players, start_date, end_date, rewards,
+        );
+
+        assert(tournament.id == id, 'ID mismatch');
+        assert(tournament.rewards.len() == 0, 'Rewards should be empty');
+    }
+
+    #[test]
+    #[available_gas(999999)]
+    fn test_tournament_with_max_values() {
+        let id = 340282366920938463463374607431768211455_u256; // max u256
+        let name = 'Max Values Tournament';
+        let organizer = contract_address_const::<'organizer'>();
+        let max_players = 255_u8; // max u8
+        let start_date = 18446744073709551615_u64; // max u64
+        let end_date = 18446744073709551615_u64;
+        let rewards = ArrayTrait::new();
+
+        let tournament = TournamentImpl::new(
+            id, name, organizer, max_players, start_date, end_date, rewards,
+        );
+
+        assert(tournament.id == id, 'ID mismatch');
+        assert(tournament.max_players == max_players, 'Max players mismatch');
+        assert(tournament.start_date == start_date, 'Start date mismatch');
+        assert(tournament.end_date == end_date, 'End date mismatch');
+    }
+}
+