✨ Ability to kick an inactive player, banish play action

Author: bal7hazar

src/models/game.cairo

@@ -24,6 +24,8 @@ struct Game {
     player_count: u8,
     nonce: u32,
     price: u256,
+    clock: u64,
+    penality: u64,
 }
 
 #[derive(Drop, PartialEq)]
@@ -55,12 +57,14 @@ mod errors {
 #[generate_trait]
 impl GameImpl of GameTrait {
     #[inline(always)]
-    fn new(id: u32, host: felt252, price: u256) -> Game {
+    fn new(id: u32, host: felt252, price: u256, penality: u64) -> Game {
         // [Check] Host is valid
         assert(host != 0, errors::GAME_INVALID_HOST);
 
         // [Return] Default game
-        Game { id, host, over: false, seed: 0, player_count: 0, nonce: 0, price }
+        Game {
+            id, host, over: false, seed: 0, player_count: 0, nonce: 0, price, clock: 0, penality
+        }
     }
 
     #[inline(always)]
@@ -296,7 +300,17 @@ impl GameAssert of AssertTrait {
 impl ZeroableGame of Zeroable<Game> {
     #[inline(always)]
     fn zero() -> Game {
-        Game { id: 0, host: 0, over: false, seed: 0, player_count: 0, nonce: 0, price: 0, }
+        Game {
+            id: 0,
+            host: 0,
+            over: false,
+            seed: 0,
+            player_count: 0,
+            nonce: 0,
+            price: 0,
+            clock: 0,
+            penality: 0
+        }
     }
 
     #[inline(always)]
@@ -324,6 +338,7 @@ mod tests {
 
     const ID: u32 = 0;
     const PRICE: u256 = 1_000_000_000_000_000_000;
+    const PENALITY: u64 = 60;
     const SEED: felt252 = 'SEED';
     const PLAYER_COUNT: u8 = 4;
     const HOST: felt252 = 'HOST';
@@ -332,7 +347,7 @@ mod tests {
     #[test]
     #[available_gas(100_000)]
     fn test_game_new() {
-        let game = GameTrait::new(ID, HOST, PRICE);
+        let game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         assert(game.host == HOST, 'Game: wrong account');
         assert(game.id == ID, 'Game: wrong id');
         assert(game.over == false, 'Game: wrong over');
@@ -344,7 +359,7 @@ mod tests {
     #[test]
     #[available_gas(100_000)]
     fn test_game_join() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.join();
         let index = game.join();
         assert(game.player_count == 2, 'Game: wrong count');
@@ -363,7 +378,7 @@ mod tests {
     #[available_gas(100_000)]
     #[should_panic(expected: ('Game: is over',))]
     fn test_game_join_revert_is_over() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.over = true;
         game.join();
     }
@@ -372,7 +387,7 @@ mod tests {
     #[available_gas(100_000)]
     #[should_panic(expected: ('Game: has started',))]
     fn test_game_join_revert_has_started() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.seed = 1;
         game.join();
     }
@@ -381,7 +396,7 @@ mod tests {
     #[available_gas(150_000)]
     #[should_panic(expected: ('Game: is full',))]
     fn test_game_join_revert_no_remaining_slots() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         let mut index = MAXIMUM_PLAYER_COUNT + 1;
         loop {
             if index == 0 {
@@ -395,7 +410,7 @@ mod tests {
     #[test]
     #[available_gas(100_000)]
     fn test_game_leave() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.join();
         let index = game.leave(PLAYER);
         assert(game.player_count == 0, 'Game: wrong count');
@@ -406,7 +421,7 @@ mod tests {
     #[available_gas(100_000)]
     #[should_panic(expected: ('Game: user is the host',))]
     fn test_game_leave_host_revert_host() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.join();
         game.leave(HOST);
         assert(game.over, 'Game: wrong status');
@@ -416,7 +431,7 @@ mod tests {
     #[available_gas(100_000)]
     #[should_panic(expected: ('Game: is empty',))]
     fn test_game_leave_revert_does_not_exist() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.join();
         game.player_count = 0;
         game.leave(PLAYER);
@@ -426,7 +441,7 @@ mod tests {
     #[available_gas(100_000)]
     #[should_panic(expected: ('Game: is over',))]
     fn test_game_leave_revert_over() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.join();
         game.over = true;
         game.leave(PLAYER);
@@ -436,7 +451,7 @@ mod tests {
     #[available_gas(100_000)]
     #[should_panic(expected: ('Game: has started',))]
     fn test_game_leave_revert_has_started() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.seed = 1;
         game.join();
         game.leave(PLAYER);
@@ -446,7 +461,7 @@ mod tests {
     #[available_gas(100_000)]
     #[should_panic(expected: ('Game: is empty',))]
     fn test_game_leave_revert_is_empty() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.join();
         game.leave(PLAYER);
         game.leave(PLAYER);
@@ -455,7 +470,7 @@ mod tests {
     #[test]
     #[available_gas(200_000)]
     fn test_game_delete_host() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.join();
         game.delete(HOST);
         assert(game.is_zero(), 'Game: not zero');
@@ -464,7 +479,7 @@ mod tests {
     #[test]
     #[available_gas(200_000)]
     fn test_game_start() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         let mut index = PLAYER_COUNT;
         loop {
             if index == 0 {
@@ -482,7 +497,7 @@ mod tests {
     #[available_gas(200_000)]
     #[should_panic(expected: ('Game: too few players',))]
     fn test_game_start_revert_too_few_players() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.player_count = 0;
         let players = array![HOST, PLAYER];
         game.start(players);
@@ -492,7 +507,7 @@ mod tests {
     #[available_gas(200_000)]
     #[should_panic(expected: ('Game: is over',))]
     fn test_game_start_revert_is_over() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.over = true;
         let players = array![HOST, PLAYER];
         game.start(players);
@@ -502,7 +517,7 @@ mod tests {
     #[available_gas(200_000)]
     #[should_panic(expected: ('Game: has started',))]
     fn test_game_start_revert_has_started() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.seed = 1;
         let players = array![HOST, PLAYER];
         game.start(players);
@@ -511,7 +526,7 @@ mod tests {
     #[test]
     #[available_gas(1_000_000)]
     fn test_game_get_player_index() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.player_count = 6;
         assert(game.player() == 0, 'Game: wrong player index 0+0');
         game.nonce += 1;
@@ -534,7 +549,7 @@ mod tests {
     #[test]
     #[available_gas(100_000)]
     fn test_game_get_next_player_index() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.player_count = 6;
         assert(game.player() == 0, 'Game: wrong player index 0+0');
         assert(game.next_player() == 1, 'Game: wrong next player 0+0');
@@ -546,7 +561,7 @@ mod tests {
     #[test]
     #[available_gas(100_000)]
     fn test_game_get_turn_index() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         assert(game.turn().into() == 0_u32, 'Game: wrong turn index 0');
         game.nonce += 1;
         assert(game.turn().into() == 1_u32, 'Game: wrong turn index 1');
@@ -560,7 +575,7 @@ mod tests {
     #[test]
     #[available_gas(100_000)]
     fn test_game_pass() {
-        let mut game = GameTrait::new(ID, HOST, PRICE);
+        let mut game = GameTrait::new(ID, HOST, PRICE, PENALITY);
         game.player_count = 6;
         game.pass();
         assert(game.player() == 1, 'Game: wrong player');

src/models/player.cairo

@@ -49,6 +49,11 @@ impl PlayerImpl of PlayerTrait {
         self.conqueror = false;
         self.rank = 0;
     }
+
+    #[inline(always)]
+    fn is_dead(ref self: Player) -> bool {
+        self.rank > 0
+    }
 }
 
 #[generate_trait]

src/systems/host.cairo

@@ -11,7 +11,11 @@ use dojo::world::IWorldDispatcher;
 #[starknet::interface]
 trait IHost<TContractState> {
     fn create(
-        self: @TContractState, world: IWorldDispatcher, player_name: felt252, price: u256
+        self: @TContractState,
+        world: IWorldDispatcher,
+        player_name: felt252,
+        price: u256,
+        penality: u64
     ) -> u32;
     fn join(self: @TContractState, world: IWorldDispatcher, game_id: u32, player_name: felt252);
     fn leave(self: @TContractState, world: IWorldDispatcher, game_id: u32);
@@ -82,7 +86,11 @@ mod host {
     #[abi(embed_v0)]
     impl Host of IHost<ContractState> {
         fn create(
-            self: @ContractState, world: IWorldDispatcher, player_name: felt252, price: u256
+            self: @ContractState,
+            world: IWorldDispatcher,
+            player_name: felt252,
+            price: u256,
+            penality: u64
         ) -> u32 {
             // [Setup] Datastore
             let mut store: Store = StoreTrait::new(world);
@@ -93,7 +101,9 @@ mod host {
 
             // [Effect] Game
             let game_id = world.uuid();
-            let mut game = GameTrait::new(id: game_id, host: caller.into(), price: price);
+            let mut game = GameTrait::new(
+                id: game_id, host: caller.into(), price: price, penality: penality
+            );
             let player_index: u32 = game.join().into();
             store.set_game(game);
 

src/systems/play.cairo

@@ -45,6 +45,7 @@ trait IPlay<TContractState> {
         to_index: u8,
         army: u32
     );
+    fn banish(ref self: TContractState, world: IWorldDispatcher, game_id: u32, player_index: u8);
 }
 
 #[starknet::interface]
@@ -58,7 +59,7 @@ trait IERC20<TContractState> {
 mod play {
     // Starknet imports
 
-    use starknet::{get_tx_info, get_caller_address};
+    use starknet::{get_tx_info, get_caller_address, get_block_timestamp};
 
     // Dojo imports
 
@@ -104,6 +105,9 @@ mod play {
         const TRANSFER_INVALID_TURN: felt252 = 'Transfer: invalid turn';
         const TRANSFER_INVALID_PLAYER: felt252 = 'Transfer: invalid player';
         const TRANSFER_INVALID_OWNER: felt252 = 'Transfer: invalid owner';
+        const BANISH_NO_PENALITY_SET: felt252 = 'Banish: no penality set';
+        const BANISH_INVALID_PLAYER: felt252 = 'Banish: invalid player';
+        const BANISH_INVALID_CONDITION: felt252 = 'Banish: invalid condition';
     }
 
     #[storage]
@@ -252,18 +256,25 @@ mod play {
             // [Setup] Datastore
             let mut store: Store = StoreTrait::new(world);
 
-            // [Check] Caller is player
+            // [Check] Caller is player or player is dead
             let caller = get_caller_address();
             let mut game: Game = store.game(game_id);
             let mut player = store.current_player(game);
-            assert(player.address == caller.into(), errors::FINISH_INVALID_PLAYER);
+            assert(
+                player.address == caller.into() || player.is_dead(), errors::FINISH_INVALID_PLAYER
+            );
 
             // [Check] Player supply is empty
-            let mut player = store.current_player(game);
-            assert(player.supply == 0, errors::FINISH_INVALID_SUPPLY);
+            assert(player.supply == 0 || player.is_dead(), errors::FINISH_INVALID_SUPPLY);
+
+            // [Command] Update game turn according to the player status
+            if player.is_dead() {
+                game.pass();
+            } else {
+                game.increment();
+            }
 
-            // [Command] Update next player supply if next turn is supply
-            game.increment();
+            // [Effect] Update next player supply if next turn is supply
             if game.turn() == Turn::Supply {
                 // [Compute] Draw card if conqueror
                 if player.conqueror {
@@ -291,7 +302,7 @@ mod play {
                     };
 
                     // [Check] Player rank is not 0 means the player is dead, move to next player
-                    if next_player.rank > 0 {
+                    if next_player.is_dead() {
                         // [Effect] Move to next player
                         game.pass();
                         continue;
@@ -321,9 +332,36 @@ mod play {
             };
 
             // [Effect] Update game
+            let time = get_block_timestamp();
+            game.clock = time;
             store.set_game(game);
         }
 
+        fn banish(
+            ref self: ContractState, world: IWorldDispatcher, game_id: u32, player_index: u8
+        ) {
+            // [Setup] Datastore
+            let mut store: Store = StoreTrait::new(world);
+
+            // [Check] Game penamity is valid
+            let game: Game = store.game(game_id);
+            assert(game.penality > 0, errors::BANISH_NO_PENALITY_SET);
+
+            // [Check] Targeted player is the current player
+            let mut current_player = store.current_player(game);
+            let mut player = store.player(game, player_index.into());
+            assert(current_player.address == player.address, errors::BANISH_INVALID_PLAYER);
+
+            // [Check] Player is banishable
+            let mut game: Game = store.game(game_id);
+            let time = get_block_timestamp();
+            assert(time > game.clock + game.penality, errors::BANISH_INVALID_CONDITION);
+
+            // [Effect] Update player
+            player.rank(store.get_next_rank(game));
+            store.set_player(player);
+        }
+
         fn supply(
             ref self: ContractState,
             world: IWorldDispatcher,

src/tests/attack.cairo

@@ -26,6 +26,7 @@ use zconqueror::tests::setup::{setup, setup::{Systems, Context, HOST, PLAYER}};
 const HOST_NAME: felt252 = 'HOST';
 const PLAYER_NAME: felt252 = 'PLAYER';
 const PRICE: u256 = 1_000_000_000_000_000_000;
+const PENALITY: u64 = 60;
 const PLAYER_COUNT: u8 = 2;
 const PLAYER_INDEX: u32 = 0;
 
@@ -37,7 +38,7 @@ fn test_attack() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -93,7 +94,7 @@ fn test_attack_revert_invalid_player() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -135,7 +136,7 @@ fn test_attack_revert_invalid_owner() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());

src/tests/defend.cairo

@@ -26,6 +26,7 @@ use zconqueror::tests::setup::{setup, setup::{Systems, Context, HOST, PLAYER}};
 const HOST_NAME: felt252 = 'HOST';
 const PLAYER_NAME: felt252 = 'PLAYER';
 const PRICE: u256 = 1_000_000_000_000_000_000;
+const PENALITY: u64 = 60;
 const PLAYER_COUNT: u8 = 2;
 const PLAYER_INDEX: u32 = 0;
 
@@ -37,7 +38,7 @@ fn test_defend_win() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -117,7 +118,7 @@ fn test_defend_lose() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -199,7 +200,7 @@ fn test_defend_revert_invalid_order() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -260,7 +261,7 @@ fn test_defend_revert_invalid_player() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -302,7 +303,7 @@ fn test_defend_revert_invalid_owner() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());

src/tests/finish.cairo

@@ -26,6 +26,7 @@ use zconqueror::tests::setup::{setup, setup::{Systems, Context, HOST, PLAYER}};
 const HOST_NAME: felt252 = 'HOST';
 const PLAYER_NAME: felt252 = 'PLAYER';
 const PRICE: u256 = 1_000_000_000_000_000_000;
+const PENALITY: u64 = 60;
 const PLAYER_COUNT: u8 = 2;
 const PLAYER_INDEX: u32 = 0;
 
@@ -37,7 +38,7 @@ fn test_finish_next_player() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -104,7 +105,7 @@ fn test_finish_revert_invalid_supply() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -127,7 +128,7 @@ fn test_finish_revert_invalid_player() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());

src/tests/host.cairo

@@ -27,6 +27,7 @@ const HOST_NAME: felt252 = 'HOST';
 const PLAYER_NAME: felt252 = 'PLAYER';
 const ANYONE_NAME: felt252 = 'ANYONE';
 const PRICE: u256 = 1_000_000_000_000_000_000;
+const PENALITY: u64 = 60;
 const PLAYER_COUNT: u8 = 2;
 
 #[test]
@@ -37,7 +38,7 @@ fn test_host_create_and_join() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -100,7 +101,7 @@ fn test_host_create_and_host_deletes() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     systems.host.delete(world, game_id);
 
     // [Assert] Game
@@ -116,7 +117,7 @@ fn test_host_create_and_player_leaves() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     systems.host.leave(world, game_id);
@@ -134,7 +135,7 @@ fn test_host_create_and_tranfer_and_host_leaves() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -156,7 +157,7 @@ fn test_host_create_and_tranfer_and_kick_host() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -180,7 +181,7 @@ fn test_host_start_then_join_revert_started() {
     let (world, systems, _) = setup::spawn_game();
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -199,7 +200,7 @@ fn test_host_start_then_leave_revert_started() {
     let (world, systems, _) = setup::spawn_game();
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());

src/tests/supply.cairo

@@ -26,6 +26,7 @@ use zconqueror::tests::setup::{setup, setup::{Systems, Context, HOST, PLAYER}};
 const HOST_NAME: felt252 = 'HOST';
 const PLAYER_NAME: felt252 = 'PLAYER';
 const PRICE: u256 = 1_000_000_000_000_000_000;
+const PENALITY: u64 = 60;
 const PLAYER_COUNT: u8 = 2;
 const PLAYER_INDEX: u32 = 0;
 
@@ -36,7 +37,7 @@ fn test_supply() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -79,7 +80,7 @@ fn test_supply_revert_invalid_player() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -104,7 +105,7 @@ fn test_supply_revert_invalid_owner() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());

src/tests/transfer.cairo

@@ -26,6 +26,7 @@ use zconqueror::tests::setup::{setup, setup::{Systems, Context, HOST, PLAYER}};
 const HOST_NAME: felt252 = 'HOST';
 const PLAYER_NAME: felt252 = 'PLAYER';
 const PRICE: u256 = 1_000_000_000_000_000_000;
+const PENALITY: u64 = 60;
 const PLAYER_COUNT: u8 = 2;
 const PLAYER_INDEX: u32 = 0;
 
@@ -37,7 +38,7 @@ fn test_transfer_valid() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -106,7 +107,7 @@ fn test_transfer_revert_invalid_player() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());
@@ -151,7 +152,7 @@ fn test_transfer_revert_invalid_owner() {
     let mut store = StoreTrait::new(world);
 
     // [Create]
-    let game_id = systems.host.create(world, HOST_NAME, PRICE);
+    let game_id = systems.host.create(world, HOST_NAME, PRICE, PENALITY);
     set_contract_address(PLAYER());
     systems.host.join(world, game_id, PLAYER_NAME);
     set_contract_address(HOST());