upgrade test

src/actions.cairo

@@ -9,7 +9,7 @@ mod kingdom_lord_controller {
     use kingdom_lord::helpers::tuple::{TupleFour, TupleSix};
     use kingdom_lord::models::building::{
         Building, BuildingUpgradeRequirementImpl, BuildingUpgradeTimeRequirementImpl,
-        BuildingUpgradeResource, CityBuilding, new_city_building
+        BuildingUpgradeResource, CityBuilding, new_city_building, CityBuildingGetLevelImpl
     };
     use starknet::ContractAddress;
     use kingdom_lord::interface::{IKingdomLord, Error};
@@ -121,17 +121,14 @@ mod kingdom_lord_controller {
         }
 
         fn start_upgrade(ref self: ContractState, building_id: u64) -> Result<u64, Error> {
-            let BuildingUpgradeResource{wood: req_wood,
-            brick: req_brick,
-            steel: req_steel,
-            cereal: req_cereal } =
-                self
-                .upgrade_requirement(building_id);
+            let BuildingUpgradeResource{
+                    wood: req_wood,
+                    brick: req_brick,
+                    steel: req_steel,
+                    cereal: req_cereal 
+                } = self.upgrade_requirement(building_id);
             let (wood, brick, steel, cereal) = self.get_resource();
-            if wood >= req_wood
-                && brick >= req_brick
-                && steel >= req_steel
-                && cereal >= req_cereal {
+            if wood >= req_wood && brick >= req_brick && steel >= req_steel && cereal >= req_cereal {
                 let (mined_wood, mined_brick, mined_steel, mined_cereal) = self.mine();
                 self.warehouse.add_resource(mined_wood, mined_brick, mined_steel);
                 self.barn.add_cereal(mined_cereal);
@@ -151,8 +148,19 @@ mod kingdom_lord_controller {
         fn finish_upgrade(
             ref self: ContractState, upgrade_id: u64
         ) -> Result<UnderUpgrading, Error> {
-            panic!("gg")
-
+            let res = self.city_hall.finish_upgrade(upgrade_id);
+            match res {
+                Result::Ok(under_upgrade) => {
+                    let world = self.world_dispatcher.read();
+                    let player = get_caller_address();
+                    let building_id: u64 = under_upgrade.target.into();
+                    let mut building = get!(world, (player, building_id), (CityBuilding));
+                    building.level_up();
+                    set!(world, (building));
+                },
+                Result::Err(err) => {}
+            }
+            res
         }
 
         fn get_under_upgrading(self: @ContractState) -> Array<UnderUpgrading> {
@@ -163,6 +171,22 @@ mod kingdom_lord_controller {
             self.city_hall.get_complete_upgrading()
         }
 
+        fn get_buildings_levels(self: @ContractState) -> Array<Level>{
+            let world = self.world_dispatcher.read();
+            let player = get_caller_address();
+            let mut res = array![];
+            let mut index = 0_u64;
+            loop{
+                if index == 18{
+                    break;
+                }
+                let building = get!(world, (player, index), (CityBuilding));
+                res.append(building.get_level());
+                index += 1;
+            };
+            res
+        }
+
         fn upgrade_requirement(self: @ContractState, building_id: u64) -> BuildingUpgradeResource {
             let world = self.world_dispatcher.read();
             let player = get_caller_address();
@@ -184,38 +208,5 @@ mod kingdom_lord_controller {
             let building = get!(world, (player, building_id), (CityBuilding));
             building.get_next_level()
         }
-    // fn upgrade(self: @ContractState, building_id: u64){
-    //     let building_id: BuildingId = building_id.into();
-    //     match building_id {
-    //         BuildingId::WoodBuilding(id) => {
-    //             let building = self.outer_city.get_wood_building_by_index(id);
-    //             building.get_next_level()
-    //         },
-    //         BuildingId::SteelBuilding(id) => {
-    //             let building = self.outer_city.get_steel_building_by_index(id);
-    //             building.get_next_level()
-    //         },
-    //         BuildingId::BrickBuilding(id) => {
-    //             let building = self.outer_city.get_brick_building_by_index(id);
-    //             building.get_next_level()
-    //         },
-    //         BuildingId::CerealBuilding(id) => {
-    //             let building = self.outer_city.get_cereal_building_by_index(id);
-    //             building.get_next_level()
-    //         },
-    //         BuildingId::CityHall => { 1_u64.into() },
-    //         BuildingId::Fence => { 1_u64.into() },
-    //         BuildingId::GatheringPoint => { 1_u64.into() },
-    //         BuildingId::SoldierCamp => { 1_u64.into() },
-    //         BuildingId::HouseCamp => { 1_u64.into() },
-    //         BuildingId::ResearchCenter => { 1_u64.into() },
-    //         BuildingId::HeroCamp => { 1_u64.into() },
-    //         BuildingId::Warehouse => { 1_u64.into() },
-    //         BuildingId::Barn => { 1_u64.into() },
-    //         BuildingId::Market => { 1_u64.into() },
-    //         BuildingId::Embassy => { 1_u64.into() },
-    //         BuildingId::SkyTower => { 1_u64.into() },
-    //     }
-    // }
     }
 }

src/components/city_hall.cairo

@@ -1,7 +1,7 @@
 use starknet::ContractAddress;
 use core::starknet::info::get_block_number;
 use super::super::models::resource::{Cereal, Resource};
-use super::super::models::building::{BuildingId};
+use super::super::models::building::{BuildingId, BuildingUpgradeTimeRequirementImpl, CityBuilding};
 use super::super::helpers::tuple::TupleSix;
 use super::super::models::level::Level;
 
@@ -23,8 +23,9 @@ mod city_hall_component {
     use dojo::world::{
         IWorldProvider, IWorldProviderDispatcher, IWorldDispatcher, IWorldDispatcherTrait
     };
-    use super::{BuildingId, UnderUpgrading, Level};
+    use super::{BuildingId, UnderUpgrading, Level, BuildingUpgradeTimeRequirementImpl, CityBuilding};
     use kingdom_lord::interface::Error;
+    use kingdom_lord::helpers::contract_address::FmtContractAddr;
 
 
     #[storage]
@@ -53,7 +54,7 @@ mod city_hall_component {
                 }
                 let under_construction: UnderUpgrading = self.Construction_Lists.read(index.into());
                 if under_construction.address == caller
-                    && under_construction.end_block_number < current_block_number {
+                    && under_construction.end_block_number > current_block_number {
                     constructions.append(under_construction);
                     under_construction_count -= 1;
                 }
@@ -77,7 +78,7 @@ mod city_hall_component {
                 }
                 let under_construction: UnderUpgrading = self.Construction_Lists.read(index.into());
                 if under_construction.address == caller
-                    && under_construction.end_block_number >= current_block_number {
+                    && under_construction.end_block_number <= current_block_number {
                     constructions.append(under_construction);
                     under_construction_count -= 1;
                 }
@@ -96,13 +97,16 @@ mod city_hall_component {
             let index = self.max_construction_index.read();
             let next_index = index + 1;
             let mut under_construction_count = self.under_construction_count.read();
+            let id: u64 = building_id.into();
+            let building = get!(self.get_contract().world(), (get_caller_address(), id), (CityBuilding));
+            let require_time = building.time_required();
             let under_construction = UnderUpgrading {
                 address: caller_address,
                 upgrade_id: next_index,
                 level,
                 target: building_id,
                 start_block_number: current_block_number,
-                end_block_number: current_block_number + 3
+                end_block_number: current_block_number + require_time
             };
             self.max_construction_index.write(next_index);
             self.under_construction_count.write(under_construction_count + 1);
@@ -115,7 +119,7 @@ mod city_hall_component {
         ) -> Result<UnderUpgrading, Error> {
             let current_block_number = get_block_number();
             let under_construction: UnderUpgrading = self.Construction_Lists.read(upgrade_id);
-            if under_construction.end_block_number < current_block_number {
+            if under_construction.end_block_number <= current_block_number {
                 let mut under_construction_count = self.under_construction_count.read();
                 self.under_construction_count.write(under_construction_count - 1);
                 Result::Ok(under_construction)

src/components/outer_city.cairo

@@ -5,7 +5,6 @@ use super::super::models::resource::{Resource, Wood, Brick, Steel, Cereal};
 use super::super::models::growth::{GrowthRate};
 use super::super::models::level::{Level, GetLevel};
 use core::Serde;
-use core::fmt::{Debug, Formatter, Error};
 
 #[starknet::interface]
 trait OuterCityTrait<TState> {

src/helpers/contrat_address.cairo → src/helpers/contract_address.cairo

@@ -1,4 +1,5 @@
-
+use core::fmt::{Debug, Formatter, Error};
+use starknet::ContractAddress;
 impl FmtContractAddr of Debug<ContractAddress>{
      fn fmt(self: @ContractAddress, ref f: Formatter) -> Result<(), Error>{
         let felt: felt252 = self.clone().into();

src/interface.cairo

@@ -4,7 +4,7 @@ use kingdom_lord::models::growth::{GrowthRate};
 use kingdom_lord::models::level::Level;
 use kingdom_lord::components::city_hall::city_hall_component::{UnderUpgrading};
 
-#[derive(Debug, Serde, Drop, Copy)]
+#[derive(Debug, Serde, Drop, Copy, PartialEq)]
 enum Error{
     ResourceNotEnough,
     UpgradeNotFinished
@@ -14,10 +14,10 @@ trait IKingdomLord<TState>{
     fn spawn(ref self: TState);
     fn get_resource(self: @TState) -> (Resource<Wood>, Resource<Brick>, Resource<Steel>, Resource<Cereal>);
     fn get_growth_rate(self: @TState) -> (GrowthRate<Wood>, GrowthRate<Brick>, GrowthRate<Steel>, GrowthRate<Cereal>);
-    fn start_upgrade(ref self: TState, building_id: u64) -> Result<u64, Error>;
-    fn finish_upgrade(ref self: TState, upgrade_id: u64) -> Result<UnderUpgrading, Error>;
     fn get_under_upgrading(self: @TState) -> Array<UnderUpgrading>;
     fn get_complete_upgrading(self: @TState) -> Array<UnderUpgrading>;
+    fn get_buildings_levels(self: @TState) -> Array<Level>;
+    fn start_upgrade(ref self: TState, building_id: u64) -> Result<u64, Error>;
+    fn finish_upgrade(ref self: TState, upgrade_id: u64) -> Result<UnderUpgrading, Error>;
     fn upgrade_requirement(self: @TState, building_id: u64) -> BuildingUpgradeResource;
-    // fn next_level(self: @TState, building_id: u64) -> Level;
 }

src/lib.cairo

@@ -18,9 +18,11 @@ mod components {
 mod helpers {
     mod tuple;
     mod array;
+    mod contract_address;
 }
 
 mod tests {
     mod test_spawn;
+    mod test_upgrade;
     mod utils;
 }

src/models/level.cairo

@@ -1,4 +1,4 @@
-#[derive(Drop, Serde, Introspect, Copy, Default, Debug, starknet::Store)]
+#[derive(Drop, Serde, Introspect, Copy, Default, Debug, starknet::Store, PartialEq)]
 struct Level{
     level: u64,
 }

src/tests/test_spawn.cairo

@@ -1,6 +1,7 @@
 #[cfg(test)]
 mod tests {
-    use starknet::class_hash::Felt252TryIntoClassHash;
+    use kingdom_lord::interface::IKingdomLordDispatcherTrait;
+use starknet::class_hash::Felt252TryIntoClassHash;
     use starknet::get_caller_address;
     use starknet::testing::set_caller_address;
 
@@ -32,5 +33,33 @@ mod tests {
         assert(brick_growth_rate.into() == 10_u64, 'brick growth rate should be 10');
         assert(cereal_growth_rate.into() == 10_u64, 'cereal growth rate should be 10');
 
+        let under_upgrade = context.kingdom_lord.get_under_upgrading();
+        assert(under_upgrade.len() == 0_u32, 'under_upgrade should be 0');
+
+        let complete_upgrade = context.kingdom_lord.get_complete_upgrading();
+        assert(complete_upgrade.len() == 0_u32, 'complete_upgrade should be 0');
+
+        // 0 is wood building with 1 level
+        let upgrade_requirement = context.kingdom_lord.upgrade_requirement(0);
+        assert(upgrade_requirement.wood == 200_u64.into(), 'require wood should be 200');
+        assert(upgrade_requirement.brick == 200_u64.into(), 'require brick should be 200');
+        assert(upgrade_requirement.steel == 200_u64.into(), 'require steel should be 200');
+        assert(upgrade_requirement.cereal == 200_u64.into(), 'require cereal should be 200');
+
+        // 1 is wood building with 0 level
+        let upgrade_requirement = context.kingdom_lord.upgrade_requirement(1);
+        assert(upgrade_requirement.wood == 100_u64.into(), 'require wood should be 100');
+        assert(upgrade_requirement.brick == 100_u64.into(), 'require brick should be 100');
+        assert(upgrade_requirement.steel == 100_u64.into(), 'require steel should be 100');
+        assert(upgrade_requirement.cereal == 100_u64.into(), 'require cereal should be 100');
+
+        let levels = context.kingdom_lord.get_buildings_levels();
+        assert(*levels.at(0) == 1_u64.into(), '0 should be 1');
+        assert(*levels.at(1) == 0_u64.into(), '1 should be 0');
+        assert(*levels.at(2) == 0_u64.into(), '2 should be 0');
+        assert(*levels.at(3) == 0_u64.into(), '3 should be 0');
+        assert(*levels.at(4) == 1_u64.into(), '4 should be 1');
+
+
     }
 }

src/tests/test_upgrade.cairo

@@ -0,0 +1,62 @@
+#[cfg(test)]
+mod tests {
+    use core::result::ResultTrait;
+use kingdom_lord::interface::IKingdomLordDispatcherTrait;
+    use starknet::class_hash::Felt252TryIntoClassHash;
+    use starknet::get_caller_address;
+    use starknet::testing::{set_caller_address, set_block_number};
+
+    // import world dispatcher
+    use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait};
+
+    // import test utils
+    use dojo::test_utils::{spawn_test_world, deploy_contract};
+    use kingdom_lord::tests::utils::setup_world;
+    use kingdom_lord::interface::{IKingdomLord, IKingdomLordDispatcher, IKingdomLordLibraryDispatcherImpl, Error};
+
+    #[test]
+    #[available_gas(300000000000)]
+    fn test_upgrade() {
+        // deploy world with models
+        let context = setup_world();
+
+        context.kingdom_lord.spawn();
+
+        let err = context.kingdom_lord.start_upgrade(0_u64).unwrap_err();
+        assert(err == Error::ResourceNotEnough, 'not enough resource');
+
+        set_block_number(25);
+        let upgrade_id = context.kingdom_lord.start_upgrade(0_u64).unwrap();
+        assert(upgrade_id == 1, 'first upgrade id is 1');
+
+        set_block_number(30);
+        let under_upgrade = context.kingdom_lord.get_under_upgrading();
+
+        let upgrade = under_upgrade.at(0);
+
+        assert(under_upgrade.len() == 1, 'under_upgrade should be 1');
+        assert(*upgrade.upgrade_id == 1, 'upgrade id should be 1');
+        assert(*upgrade.start_block_number == 25, 'end block should be 25');
+        println!("{}", *upgrade.end_block_number);
+        assert(*upgrade.end_block_number == 31, 'end block should be 31');
+
+        let finishe_upgrade = context.kingdom_lord.get_complete_upgrading();
+        assert(finishe_upgrade.len() == 0, 'finished should be 0');
+
+
+        set_block_number(31);
+
+        let finishe_upgrade = context.kingdom_lord.get_complete_upgrading();
+        assert(finishe_upgrade.len() == 1, 'finished should be 0');
+
+        let upgrade = under_upgrade.at(0);
+        assert(*upgrade.upgrade_id == 1, 'upgrade id should be 1');
+
+        context.kingdom_lord.finish_upgrade(1_u64).unwrap();
+
+        let (wood_growth_rate, steel_growth_rate, brick_growth_rate, cereal_growth_rate) = context.kingdom_lord.get_growth_rate();
+        assert(wood_growth_rate.into() == 20_u64, 'wood growth rate should be 10');
+        let levels = context.kingdom_lord.get_buildings_levels();
+        assert(*levels.at(0) == 2_u64.into(), '0 should be 2');
+    }
+}