feat: Missing Tournament System Implementation

[KevinMB0220]

Issue: Missing Tournament System Implementation

Description:

The tournament system is completely unimplemented despite being referenced in multiple places throughout the codebase. The tournament models exist but all tournament-related functions are empty, preventing any competitive gameplay features.

Problems Identified:

1. Empty Tournament Functions: All tournament functions in core system are completely empty
2. Missing Tournament Models: Tournament models exist but are not properly integrated
3. No Tournament Logic: No tournament creation, joining, or management logic
4. Missing Tournament Rewards: No reward distribution system for tournaments
5. No Tournament Validation: No validation for tournament eligibility or rules

Code Issues Found:

// In CoreActions - Line 113: Completely empty
fn create_tournament(ref self: ContractState) {}

// In CoreActions - Line 114: Completely empty  
fn join_tournament(ref self: ContractState) {}

// In PlayerActions - Line 342: Empty implementation
fn register_guild(ref self: ContractState, session_id: felt252) {
    self.validate_session_for_action(session_id);
    // TODO: Implement guild registration logic
}

Specific Problems:

1. No Competitive Play: Players can't participate in tournaments
2. Missing Guild System: Guild registration is unimplemented
3. No Tournament Rewards: No way to distribute prizes or rewards
4. Missing Tournament Types: No different tournament formats (1v1, team, etc.)
5. No Tournament Scheduling: No way to schedule or manage tournament timing

Impact:

• Medium Priority: Missing core competitive gameplay features
• No player engagement through tournaments
• Missing social features (guilds)
• No reward distribution system
• Reduced game longevity without competitive elements

Recommended Solutions:

1. Implement Tournament Creation:

   fn create_tournament(ref self: ContractState, tournament_type: felt252, entry_fee: u256, max_participants: u32) {
       let caller = get_caller_address();
       let mut world = self.world_default();
       let contract: Contract = world.read_model(COA_CONTRACTS);
       
       // Validate admin permissions
       assert(caller == contract.admin, 'Only admin can create tournaments');
       
       // Create tournament
       let tournament_id = self.generate_tournament_id();
       let tournament = Tournament {
           id: tournament_id,
           creator: caller,
           tournament_type,
           entry_fee,
           max_participants,
           current_participants: 0,
           status: TournamentStatus::Open,
           created_at: get_block_timestamp(),
           start_time: 0, // To be set when tournament starts
           prize_pool: 0,
       };
       
       world.write_model(@tournament);
       world.emit_event(@TournamentCreated { tournament_id, creator: caller });
   }

2. Implement Tournament Joining:

   fn join_tournament(ref self: ContractState, tournament_id: u256) {
       let caller = get_caller_address();
       let mut world = self.world_default();
       
       // Get tournament
       let mut tournament: Tournament = world.read_model(tournament_id);
       
       // Validate tournament is open
       assert(tournament.status == TournamentStatus::Open, 'Tournament not open');
       assert(tournament.current_participants < tournament.max_participants, 'Tournament full');
       
       // Check player has enough credits for entry fee
       let player: Player = world.read_model(caller);
       assert(player.get_credits(contract.erc1155) >= tournament.entry_fee, 'Insufficient credits');
       
       // Deduct entry fee and add to prize pool
       player.mint_credits(tournament.entry_fee, contract.erc1155); // Deduct credits
       tournament.prize_pool += tournament.entry_fee;
       tournament.current_participants += 1;
       
       // Add player to tournament
       let participant = TournamentParticipant {
           tournament_id,
           player: caller,
           joined_at: get_block_timestamp(),
           status: ParticipantStatus::Active,
       };
       
       world.write_model(@tournament);
       world.write_model(@participant);
       world.emit_event(@TournamentJoined { tournament_id, player: caller });
   }

3. Implement Guild System:

   fn register_guild(ref self: ContractState, session_id: felt252, guild_name: felt252) {
       self.validate_session_for_action(session_id);
       let caller = get_caller_address();
       let mut world = self.world_default();
       
       // Check if player is already in a guild
       let existing_guild: Guild = world.read_model(caller);
       assert(existing_guild.id == 0, 'Player already in guild');
       
       // Create guild
       let guild_id = self.generate_guild_id();
       let guild = Guild {
           id: guild_id,
           name: guild_name,
           leader: caller,
           members: array![caller],
           created_at: get_block_timestamp(),
           level: 1,
           experience: 0,
       };
       
       // Add player to guild
       let guild_member = GuildMember {
           guild_id,
           player: caller,
           role: GuildRole::Leader,
           joined_at: get_block_timestamp(),
       };
       
       world.write_model(@guild);
       world.write_model(@guild_member);
       world.emit_event(@GuildCreated { guild_id, leader: caller, name: guild_name });
   }

4. Add Tournament Management:

   fn start_tournament(ref self: ContractState, tournament_id: u256) {
       let caller = get_caller_address();
       let mut world = self.world_default();
       
       let mut tournament: Tournament = world.read_model(tournament_id);
       assert(tournament.creator == caller, 'Only creator can start tournament');
       assert(tournament.status == TournamentStatus::Open, 'Tournament not open');
       assert(tournament.current_participants >= 2, 'Not enough participants');
       
       tournament.status = TournamentStatus::Active;
       tournament.start_time = get_block_timestamp();
       
       world.write_model(@tournament);
       world.emit_event(@TournamentStarted { tournament_id });
   }

5. Implement Reward Distribution:

   fn distribute_tournament_rewards(ref self: ContractState, tournament_id: u256, winners: Array<ContractAddress>) {
       let mut world = self.world_default();
       let tournament: Tournament = world.read_model(tournament_id);
       
       let prize_per_winner = tournament.prize_pool / winners.len();
       
       let mut i = 0;
       while i < winners.len() {
           let winner = *winners.at(i);
           let mut player: Player = world.read_model(winner);
           player.mint_credits(prize_per_winner, contract.erc1155);
           world.write_model(@player);
           i += 1;
       };
       
       world.emit_event(@TournamentRewardsDistributed { tournament_id, winners, total_prize: tournament.prize_pool });
   }

Files Affected:

• src/systems/core.cairo - Core system tournament functions
• src/systems/player.cairo - Player system guild functions
• src/models/tournament.cairo - Tournament models and data structures
• Missing: Tournament system implementation file

[anonfedora]

GM, I'm proficient in Rust, Cairo, dojo, I'm able to implement the features and their tests.

Recommended by OnlyDust for high-quality and dependable contributions.

[KevinMB0220]

GM, I'm proficient in Rust, Cairo, dojo, I'm able to implement the features and their tests.

Recommended by OnlyDust for high-quality and dependable contributions.

Hi @anonfedora i have Rust issues here https://github.com/OFFER-HUB/offer-hub/issues

[anonfedora]

GM, I'm proficient in Rust, Cairo, dojo, I'm able to implement the features and their tests.
Recommended by OnlyDust for high-quality and dependable contributions.

Hi @anonfedora i have Rust issues here https://github.com/OFFER-HUB/offer-hub/issues

Alright ser, will also apply now