refactor: using components

Scarb.lock

@@ -3,8 +3,8 @@ version = 1
 
 [[package]]
 name = "dojo"
-version = "0.5.0"
-source = "git+https://github.com/dojoengine/dojo#79278a62f66895cbe3bfaf822e3703309f8847b5"
+version = "0.5.1"
+source = "git+https://github.com/dojoengine/dojo#118ed84f7b5cb9e4e0c1963fca88b71a222ae50d"
 dependencies = [
  "dojo_plugin",
 ]

Scarb.toml

@@ -7,7 +7,7 @@ version = "0.5.0"
 sierra-replace-ids = true
 
 [dependencies]
-dojo = { git = "https://github.com/dojoengine/dojo", version = "0.5.0" }
+dojo = { git = "https://github.com/dojoengine/dojo", version = "0.5.1" }
 openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", tag = "v0.8.0" }
 
 [[target.dojo]]

src/actions.cairo

@@ -0,0 +1,89 @@
+use kingdom_lord::models::resource::{Wood, Brick, Steel, Cereal};
+use starknet::ContractAddress;
+
+const MAX_STORAGE: u64 = 100000;
+const GROWTH_RATE: u64 = 10;
+
+
+#[starknet::interface]
+trait SpawnTrait<TState>{
+    fn spawn(ref self: TState);
+}
+
+// dojo decorator
+#[dojo::contract]
+mod kingdom_lord_controller {
+    use kingdom_lord::components::barn::{barn_component, Barn};
+    use kingdom_lord::components::warehouse::{warehouse_component, Warehouse};
+    use kingdom_lord::components::outer_city::{outer_city_component, OuterCity};
+    use starknet::get_caller_address;
+    use core::starknet::info::get_block_number;
+    use super::{MAX_STORAGE, GROWTH_RATE, SpawnTrait};
+
+
+    component!(path: barn_component, storage: barn, event: BarnEvent);
+    component!(path: warehouse_component, storage: warehouse, event: WarehouseEvent);
+    component!(path: outer_city_component, storage: outer_city, event: OuterCityEvent);
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        barn: barn_component::Storage,
+        #[substorage(v0)]
+        warehouse: warehouse_component::Storage,
+        #[substorage(v0)]
+        outer_city: outer_city_component::Storage
+    }
+
+
+    #[event]
+    #[derive(Copy, Drop, starknet::Event)]
+    enum Event {
+        BarnEvent: barn_component::Event,
+        WarehouseEvent: warehouse_component::Event,
+        OuterCityEvent: outer_city_component::Event
+    }
+
+    #[abi(embed_v0)]
+    impl KLBarnImpl = barn_component::BarnImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl KLWarehouseImpl = warehouse_component::WarehouseImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl KLOuterCityImpl = outer_city_component::OuterCityTraitImpl<ContractState>;
+
+
+    #[abi(embed_v0)]
+    impl GameSpawnImpl of SpawnTrait<ContractState> {
+        fn spawn(ref self: ContractState) {
+            let world = self.world_dispatcher.read();
+
+            let player = get_caller_address();
+
+            let block = get_block_number();
+
+            set!(
+                world,
+                (
+                    Warehouse {
+                        player,
+                        wood: 0_u64.into(),
+                        steel: 0_u64.into(),
+                        bricks: 0_u64.into(),
+                        max_storage: MAX_STORAGE
+                    },
+                    Barn { player, cereal: 0_u64.into(), max_storage: MAX_STORAGE },
+                    OuterCity {
+                        player,
+                        last_mined_block: block,
+                        wood_field: Default::default(),
+                        brick_field: Default::default(),
+                        steel_field: Default::default(),
+                        cereal_field: Default::default()
+                    }
+                )
+            );
+        }
+    }
+}

src/components/barn.cairo

@@ -0,0 +1,60 @@
+use starknet::ContractAddress;
+use super::super::models::resource::{Cereal, Resource};
+
+#[derive(Model, Copy, Drop, Serde)]
+struct Barn{
+    #[key]
+    player: ContractAddress,
+    cereal: Resource<Cereal>,
+    max_storage: u64
+}
+
+trait BarnExtension{
+    fn get_cereal(self: @Barn) -> Resource<Cereal>;
+    fn add_cereal(ref self: Barn, cereal: Resource<Cereal>);
+}
+
+impl BarnTraitImpl of BarnExtension{
+    fn get_cereal(self: @Barn) -> Resource<Cereal>{
+        self.cereal.clone()
+    }
+
+    fn add_cereal(ref self: Barn, cereal: Resource<Cereal>){
+        self.cereal += cereal;
+    }
+}
+
+#[starknet::interface]
+trait BarnTrait<TState>{
+    fn get_cereal(self: @TState) -> Resource<Cereal>;
+    fn add_cereal(self: @TState, cereal: Resource<Cereal>);
+}
+
+#[starknet::component]
+mod barn_component{
+    use starknet::{get_contract_address};
+    use core::starknet::info::get_block_number;
+    use dojo::world::{
+        IWorldProvider, IWorldProviderDispatcher, IWorldDispatcher, IWorldDispatcherTrait
+    };
+    use super::{Barn, Cereal, Resource, BarnExtension, BarnTrait};
+
+    #[storage]
+    struct Storage {}
+
+    #[embeddable_as(BarnImpl)]
+    impl BarnTraitImpl<
+        TContractState, +HasComponent<TContractState>, +IWorldProvider<TContractState>
+    > of BarnTrait<ComponentState<TContractState>>{
+        fn get_cereal(self: @ComponentState<TContractState>) -> Resource<Cereal>{
+            let barn = get!(self.get_contract().world(), get_contract_address(), (Barn));
+            barn.get_cereal()
+        }
+        fn add_cereal(self: @ComponentState<TContractState>, cereal: Resource<Cereal>){
+            let world = self.get_contract().world();
+            let mut barn = get!(world, get_contract_address(), (Barn));
+            barn.add_cereal(cereal);
+            set!(world, (barn))
+        }
+    }
+}

src/components/outer_city.cairo

@@ -0,0 +1,93 @@
+use starknet::ContractAddress;
+use starknet::get_contract_address;
+use super::super::models::building::{WoodBuilding, BrickBuilding, SteelBuilding, CerealBuilding};
+use super::super::models::resource::{Resource, Wood, Brick, Steel, Cereal};
+use super::super::models::level::{Level, GetLevel};
+use super::super::helpers::tuple::{TupleFour, TupleSix, TupleSize6Drop, TupleSize6Serde};
+use core::Serde;
+
+
+type OuterCityLevelMap = ((Level, Level, Level, Level), (Level, Level, Level, Level), (Level, Level, Level, Level), (Level, Level, Level, Level, Level, Level));
+
+#[derive(Model, Copy, Drop, Serde)]
+struct OuterCity {
+    #[key]
+    player: ContractAddress,
+    last_mined_block: u64,
+    wood_field: TupleFour<WoodBuilding>,
+    brick_field: TupleFour<BrickBuilding>,
+    steel_field: TupleFour<SteelBuilding>,
+    cereal_field: TupleSix<CerealBuilding>,
+}
+
+#[starknet::interface]
+trait OuterCityTrait<TState> {
+    fn get_minable_resource(self: @TState)-> (Resource<Wood>, Resource<Brick>, Resource<Steel>, Resource<Cereal>);
+    fn get_growth_rate(self: @TState) -> (u64, u64, u64, u64);
+    fn get_last_mined_block(self: @TState) -> u64;
+    fn get_outer_city_building_level(self: @TState) -> OuterCityLevelMap;
+}
+
+
+
+#[starknet::component]
+mod outer_city_component {
+    use starknet::{get_contract_address};
+    use core::starknet::info::get_block_number;
+    use dojo::world::{
+        IWorldProvider, IWorldProviderDispatcher, IWorldDispatcher, IWorldDispatcherTrait
+    };
+    use super::{WoodBuilding, BrickBuilding, SteelBuilding, CerealBuilding};
+    use super::{Resource, Wood, Brick, Steel, Cereal};
+    use super::super::super::models::building::{Minable};
+    use super::super::super::models::growth::Growth;
+    use super::{TupleSize6Serde, TupleSize6Drop};
+    use super::{OuterCityTrait, OuterCity};
+    use super::{OuterCityLevelMap, GetLevel};
+
+    #[storage]
+    struct Storage {}
+
+
+    #[embeddable_as(OuterCityTraitImpl)]
+    impl OuterCityImpl<
+        TContractState, +HasComponent<TContractState>, +IWorldProvider<TContractState>
+    > of OuterCityTrait<ComponentState<TContractState>> {
+        fn get_minable_resource(self: @ComponentState<TContractState>)-> (Resource<Wood>, Resource<Brick>, Resource<Steel>, Resource<Cereal>){
+            let outer_city = get!(self.get_contract().world(), get_contract_address(), (OuterCity));
+            let current_block_number = get_block_number();
+            let wood:u64 = outer_city.wood_field.get_minable(outer_city.last_mined_block, current_block_number);
+            let brick:u64 = outer_city.brick_field.get_minable(outer_city.last_mined_block, current_block_number);
+            let steel:u64 = outer_city.steel_field.get_minable(outer_city.last_mined_block, current_block_number);
+            let cereal:u64 = outer_city.cereal_field.get_minable(outer_city.last_mined_block, current_block_number);
+            (
+                Resource::<Wood>{amount: wood},
+                Resource::<Brick>{amount: brick},
+                Resource::<Steel>{amount: steel},
+                Resource::<Cereal>{amount: cereal}
+            )
+        }
+
+        fn get_growth_rate(self: @ComponentState<TContractState>) -> (u64, u64, u64, u64){
+            let outer_city = get!(self.get_contract().world(), get_contract_address(), (OuterCity));
+            let wood_growth_rate = outer_city.wood_field.get_growth_rate();
+            let brick_growth_rate = outer_city.brick_field.get_growth_rate();
+            let steel_growth_rate = outer_city.steel_field.get_growth_rate();
+            let cereal_growth_rate = outer_city.cereal_field.get_growth_rate();
+            (wood_growth_rate, brick_growth_rate, steel_growth_rate, cereal_growth_rate)
+        }
+
+        fn get_last_mined_block(self: @ComponentState<TContractState>) -> u64{
+            get!(self.get_contract().world(), get_contract_address(), (OuterCity)).last_mined_block
+        }
+
+        fn get_outer_city_building_level(self: @ComponentState<TContractState>) -> OuterCityLevelMap{
+            let outer_city = get!(self.get_contract().world(), get_contract_address(), (OuterCity));
+            let wood_level = outer_city.wood_field.get_level();
+            let brick_level = outer_city.brick_field.get_level();
+            let steel_level = outer_city.steel_field.get_level();
+            let cereal_level = outer_city.cereal_field.get_level();
+            (wood_level, brick_level, steel_level, cereal_level)
+        }
+    }
+}

src/components/warehouse.cairo

@@ -0,0 +1,76 @@
+use starknet::ContractAddress;
+use super::super::models::resource::{Brick, Wood, Steel, Resource};
+
+#[derive(Model, Copy, Drop, Serde)]
+struct Warehouse {
+    #[key]
+    player: ContractAddress,
+    wood: Resource<Wood>,
+    bricks: Resource<Brick>,
+    steel: Resource<Steel>,
+    max_storage: u64
+}
+
+trait WarehouseExtension {
+    fn get_resource(self:@Warehouse) -> (Resource<Wood>, Resource<Brick>, Resource<Steel>);
+    fn add_resource(ref self:Warehouse, wood: Resource<Wood>, bricks: Resource<Brick>, steel: Resource<Steel>);
+}
+
+impl WarehouseExtensionImpl of WarehouseExtension{
+    fn get_resource(self:@Warehouse) -> (Resource<Wood>, Resource<Brick>, Resource<Steel>) {
+        (self.wood.clone(), self.bricks.clone(), self.steel.clone())
+    }
+
+    fn add_resource(ref self:Warehouse, wood: Resource<Wood>, bricks: Resource<Brick>, steel: Resource<Steel>) {
+        self.wood += wood;
+        self.bricks += bricks;
+        self.steel += steel;
+    }
+}
+
+trait AdminWareHouseTrait {
+    fn set_max_storage(ref self: Warehouse, max_storage: u64);
+}
+
+impl AdminWareHouseImpl of AdminWareHouseTrait{
+    fn set_max_storage(ref self: Warehouse, max_storage: u64) {
+        self.max_storage = max_storage;
+    }
+}
+
+#[starknet::interface]
+trait WarehouseTrait<TState> {
+    fn get_resource(self:@TState) -> (Resource<Wood>, Resource<Brick>, Resource<Steel>);
+    fn add_resource(self:@TState, wood: Resource<Wood>, bricks: Resource<Brick>, steel: Resource<Steel>);
+}
+
+
+#[starknet::component]
+mod warehouse_component{
+    use starknet::{get_contract_address};
+    use core::starknet::info::get_block_number;
+    use dojo::world::{
+        IWorldProvider, IWorldProviderDispatcher, IWorldDispatcher, IWorldDispatcherTrait
+    };
+    use super::{Warehouse, WarehouseTrait, Brick, Wood, Steel, Resource, WarehouseExtension};
+
+    #[storage]
+    struct Storage {}
+
+    #[embeddable_as(WarehouseImpl)]
+    impl WarehouseTraitImpl<
+        TContractState, +HasComponent<TContractState>, +IWorldProvider<TContractState>
+    > of WarehouseTrait<ComponentState<TContractState>>{
+        fn get_resource(self:@ComponentState<TContractState>) -> (Resource<Wood>, Resource<Brick>, Resource<Steel>){
+            let warehouse = get!(self.get_contract().world(), get_contract_address(), (Warehouse));
+            warehouse.get_resource()
+        }
+        fn add_resource(self:@ComponentState<TContractState>, wood: Resource<Wood>, bricks: Resource<Brick>, steel: Resource<Steel>){
+            let world = self.get_contract().world();
+            let mut warehouse: Warehouse = get!(world, get_contract_address(), (Warehouse));
+            warehouse.add_resource(wood, bricks, steel);
+            set!(world, (warehouse))
+        }
+    }
+}
+