feat: spawn points

packages/ri/client/src/layers/Headless/api/joinGame.ts

@@ -1,9 +1,8 @@
-import { WorldCoord } from "@latticexyz/phaserx/src/types";
-import { EntityID, hasComponent } from "@latticexyz/recs";
+import { EntityID, EntityIndex, hasComponent } from "@latticexyz/recs";
 import { NetworkLayer } from "../../Network";
 import { ActionSystem } from "../systems";
 
-export function joinGame(network: NetworkLayer, actions: ActionSystem, targetPosition: WorldCoord) {
+export function joinGame(network: NetworkLayer, actions: ActionSystem, spawnEntity: EntityIndex) {
   const {
     components: { Player },
     network: { connectedAddress },
@@ -35,7 +34,7 @@ export function joinGame(network: NetworkLayer, actions: ActionSystem, targetPos
     updates: () => [],
     execute: () => {
       console.log("spawning");
-      network.api.joinGame(targetPosition);
+      network.api.joinGame(world.entities[spawnEntity]);
     },
   });
 }

packages/ri/client/src/layers/Local/systems/SyncSystem/createSyncSystem.ts

@@ -50,4 +50,12 @@ export function createSyncSystem(layer: LocalLayer) {
     () => Selectable,
     () => ({ value: true })
   );
+
+  // Add Selectable to Settlements
+  defineSyncSystem(
+    world,
+    [HasValue(EntityType, { value: EntityTypes.Settlement })],
+    () => Selectable,
+    () => ({ value: true })
+  );
 }

packages/ri/client/src/layers/Network/createNetworkLayer.ts

@@ -111,6 +111,11 @@ export async function createNetworkLayer(config: NetworkLayerConfig) {
       { value: Type.Boolean },
       { id: "Capturable", metadata: { contractId: keccak256("ember.component.capturable") } }
     ),
+    SpawnPoint: defineComponent(
+      world,
+      { value: Type.Boolean },
+      { id: "SpawnPoint", metadata: { contractId: keccak256("ember.component.spawnPoint") } }
+    ),
   };
 
   // Define mappings between contract and client components
@@ -132,6 +137,7 @@ export async function createNetworkLayer(config: NetworkLayerConfig) {
     [keccak256("ember.component.prototypeCopy")]: "PrototypeCopy",
     [keccak256("ember.component.factoryComponent")]: "Factory",
     [keccak256("ember.component.capturable")]: "Capturable",
+    [keccak256("ember.component.spawnPoint")]: "SpawnPoint",
   };
 
   const contractConfig: SetupContractConfig = {
@@ -189,9 +195,9 @@ export async function createNetworkLayer(config: NetworkLayerConfig) {
     );
   }
 
-  async function joinGame(position: WorldCoord) {
-    console.log(`Joining game at position ${JSON.stringify(position)}`);
-    return systems["ember.system.playerJoin"].executeTyped(position);
+  async function joinGame(spawnEntity: EntityID) {
+    console.log(`Joining game at position ${spawnEntity}`);
+    return systems["ember.system.playerJoin"].executeTyped(BigNumber.from(spawnEntity));
   }
 
   async function moveEntity(entity: string, path: WorldCoord[]) {

packages/ri/client/src/layers/Renderer/Phaser/systems/SyncSystem/createSyncSystem.ts

@@ -1,4 +1,4 @@
-import { HasValue, Has, defineSyncSystem, getComponentValue, defineSystem, setComponent } from "@latticexyz/recs";
+import { HasValue, Has, defineSyncSystem } from "@latticexyz/recs";
 import { PhaserLayer } from "../../types";
 import { EntityTypes } from "../../../../Network/types";
 import { Animations, Assets } from "../../constants";
@@ -11,18 +11,18 @@ export function createSyncSystem(layer: PhaserLayer) {
     world,
     parentLayers: {
       network: {
-        components: { EntityType, OwnedBy },
+        components: { EntityType },
       },
       local: {
         components: { Selected, LocalPosition },
       },
     },
-    components: { Appearance, SpriteAnimation, Outline, HueTint },
+    components: { Appearance, SpriteAnimation, Outline },
   } = layer;
 
   defineSyncSystem(
     world,
-    [Has(Selected), Has(OwnedBy)],
+    [Has(Selected)],
     () => Outline,
     () => ({ color: 0xfff000 })
   );

packages/ri/client/src/layers/Renderer/React/components/JoinGame.tsx

@@ -1,7 +1,7 @@
 import React from "react";
 import { registerUIComponent } from "../engine";
 import { getAddressColor } from "@latticexyz/std-client";
-import { defineQuery, EntityID, getComponentValueStrict, HasValue } from "@latticexyz/recs";
+import { defineQuery, EntityID, getComponentValue, getComponentValueStrict, Has, HasValue, runQuery } from "@latticexyz/recs";
 import { map, merge } from "rxjs";
 import { computedToStream } from "@latticexyz/utils";
 
@@ -25,26 +25,29 @@ export function registerJoinGame() {
           world,
         },
         local: {
-          singletonEntity,
-          components: { Selection },
+          components: { Selected, LocalPosition },
         },
       } = layers;
 
-      return merge(computedToStream(connectedAddress), Selection.update$, Player.update$).pipe(
+      return merge(computedToStream(connectedAddress), Selected.update$, Player.update$).pipe(
         map(() => connectedAddress.get()),
         map((address) => {
           const playerEntity = world.entityToIndex.get(address as EntityID);
-          const selection = getComponentValueStrict(Selection, singletonEntity);
+
+          const selectedEntity = [...runQuery([Has(Selected)])][0];
+          const position = getComponentValue(LocalPosition, selectedEntity);
+
           return {
             joinGame,
-            selection,
+            selectedEntity,
+            position,
             playerEntity,
             address,
           };
         })
       );
     },
-    ({ joinGame, playerEntity, selection, address }) => {
+    ({ joinGame, playerEntity, selectedEntity, position, address }) => {
       const joined = playerEntity != undefined;
       const playerColor = getAddressColor(address || "");
 
@@ -53,15 +56,13 @@ export function registerJoinGame() {
           {!joined && <h1>Join Game</h1>}
           <p style={{ color: playerColor.toString(16) }}>Address: {address}</p>
           <p>Joined? {joined ? "yes" : "no"}</p>
-          {!joined && (
+          {!joined && selectedEntity != null && (
             <button
-              disabled={!selection}
               onClick={() => {
-                if (!selection) return;
-                joinGame({ x: selection.x, y: selection.y });
+                joinGame(selectedEntity);
               }}
             >
-              Join at Position ({selection?.x},{selection?.y})
+              Join at Position ({position?.x},{position?.y})
             </button>
           )}
         </div>

packages/ri/contracts/deploy.json

@@ -12,6 +12,7 @@
     "MineableComponent",
     "MovableComponent",
     "OwnedByComponent",
+    "SpawnPointComponent",
     "StaminaComponent",
     "UntraversableComponent",
     "PositionComponent",

packages/ri/contracts/src/components/SpawnPointComponent.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity >=0.8.0;
+import "std-contracts/components/BoolComponent.sol";
+
+uint256 constant ID = uint256(keccak256("ember.component.spawnPoint"));
+
+contract SpawnPointComponent is BoolComponent {
+  constructor(address world) BoolComponent(world, ID) {}
+}

packages/ri/contracts/src/prototypes/SettlementPrototype.sol

@@ -14,6 +14,7 @@ import { HealthComponent, Health, ID as HealthComponentID } from "../components/
 import { AttackComponent, Attack, ID as AttackComponentID } from "../components/AttackComponent.sol";
 import { FactoryComponent, Factory, ID as FactoryComponentID } from "../components/FactoryComponent.sol";
 import { CapturableComponent, ID as CapturableComponentID } from "../components/CapturableComponent.sol";
+
 import { ID as SoldierID } from "./SoldierPrototype.sol";
 
 uint256 constant ID = uint256(keccak256("ember.prototype.settlement"));

packages/ri/contracts/src/systems/InitSystem.sol

@@ -4,8 +4,15 @@ import { ISystem } from "solecs/interfaces/ISystem.sol";
 import { IWorld } from "solecs/interfaces/IWorld.sol";
 import { IUint256Component } from "solecs/interfaces/IUint256Component.sol";
 
+import { getAddressById, getComponentById, addressToEntity, getSystemAddressById } from "solecs/utils.sol";
+
+import { LibPrototype } from "../libraries/LibPrototype.sol";
+
+import { PositionComponent, ID as PositionComponentID, Coord } from "../components/PositionComponent.sol";
+import { SpawnPointComponent, ID as SpawnPointComponentID } from "../components/SpawnPointComponent.sol";
+
 import { SoldierPrototype } from "../prototypes/SoldierPrototype.sol";
-import { SettlementPrototype } from "../prototypes/SettlementPrototype.sol";
+import { SettlementPrototype, ID as SettlementID } from "../prototypes/SettlementPrototype.sol";
 
 uint256 constant ID = uint256(keccak256("ember.system.init"));
 
@@ -33,5 +40,23 @@ contract InitSystem is ISystem {
     // Initialize Prototypes
     SoldierPrototype(components);
     SettlementPrototype(components);
+
+    uint256 spawnPoint = world.getUniqueEntityId();
+    LibPrototype.copyPrototype(components, SettlementID, spawnPoint);
+
+    SpawnPointComponent(getAddressById(components, SpawnPointComponentID)).set(spawnPoint);
+    PositionComponent(getAddressById(components, PositionComponentID)).set(spawnPoint, Coord(0, 0));
+
+    spawnPoint = world.getUniqueEntityId();
+    LibPrototype.copyPrototype(components, SettlementID, spawnPoint);
+
+    SpawnPointComponent(getAddressById(components, SpawnPointComponentID)).set(spawnPoint);
+    PositionComponent(getAddressById(components, PositionComponentID)).set(spawnPoint, Coord(20, 10));
+
+    spawnPoint = world.getUniqueEntityId();
+    LibPrototype.copyPrototype(components, SettlementID, spawnPoint);
+
+    SpawnPointComponent(getAddressById(components, SpawnPointComponentID)).set(spawnPoint);
+    PositionComponent(getAddressById(components, PositionComponentID)).set(spawnPoint, Coord(5, 20));
   }
 }

packages/ri/contracts/src/systems/PlayerJoinSystem.sol

@@ -20,6 +20,8 @@ import { StaminaComponent, Stamina, ID as StaminaComponentID } from "../componen
 import { LastActionTurnComponent, ID as LastActionTurnComponentID } from "../components/LastActionTurnComponent.sol";
 import { HealthComponent, Health, ID as HealthComponentID } from "../components/HealthComponent.sol";
 import { AttackComponent, Attack, ID as AttackComponentID } from "../components/AttackComponent.sol";
+import { SpawnPointComponent, ID as SpawnPointComponentID } from "../components/SpawnPointComponent.sol";
+import { LastActionTurnComponent, ID as LastActionTurnComponentID } from "../components/LastActionTurnComponent.sol";
 
 import { ID as SoldierID } from "../prototypes/SoldierPrototype.sol";
 import { ID as SettlementID } from "../prototypes/SettlementPrototype.sol";
@@ -36,51 +38,55 @@ contract PlayerJoinSystem is ISystem {
   }
 
   function requirement(bytes memory arguments) public view returns (bytes memory) {
-    IComponent playerComponent = getComponentById(components, PlayerComponentID);
+    PlayerComponent playerComponent = PlayerComponent(getAddressById(components, PlayerComponentID));
     require(!playerComponent.has(addressToEntity(msg.sender)), "player already spawned");
 
-    Coord memory position = abi.decode(arguments, (Coord));
-    Coord[] memory spawnPositions = new Coord[](5);
-
-    spawnPositions[0] = position;
-    spawnPositions[1] = Coord(position.x + 1, position.y);
-    spawnPositions[2] = Coord(position.x - 1, position.y);
-    spawnPositions[3] = Coord(position.x, position.y + 1);
-    spawnPositions[4] = Coord(position.x, position.y - 1);
+    uint256 spawnEntity = abi.decode(arguments, (uint256));
+    require(
+      SpawnPointComponent(getAddressById(components, SpawnPointComponentID)).has(spawnEntity),
+      "that is not a spawn point"
+    );
 
     PositionComponent positionComponent = PositionComponent(getAddressById(components, PositionComponentID));
-    for (uint256 i; i < spawnPositions.length; i++) {
-      require(positionComponent.getEntitiesWithValue(spawnPositions[i]).length == 0, "spot taken");
-    }
+    require(positionComponent.has(spawnEntity), "spawn has no location");
+    Coord memory spawnPosition = positionComponent.getValue(spawnEntity);
+
+    Coord[] memory unitPositions = new Coord[](4);
+
+    unitPositions[0] = Coord(spawnPosition.x + 1, spawnPosition.y);
+    unitPositions[1] = Coord(spawnPosition.x - 1, spawnPosition.y);
+    unitPositions[2] = Coord(spawnPosition.x, spawnPosition.y + 1);
+    unitPositions[3] = Coord(spawnPosition.x, spawnPosition.y - 1);
 
-    return abi.encode(playerComponent, spawnPositions);
+    return abi.encode(spawnEntity, unitPositions, playerComponent);
   }
 
   function execute(bytes memory arguments) public returns (bytes memory) {
-    (IComponent playerComponent, Coord[] memory spawnPositions) = abi.decode(
+    (uint256 spawnEntity, Coord[] memory unitPositions, PlayerComponent playerComponent) = abi.decode(
       requirement(arguments),
-      (IComponent, Coord[])
+      (uint256, Coord[], PlayerComponent)
     );
 
     // Create player entity
     uint256 playerEntity = addressToEntity(msg.sender);
-    PlayerComponent(address(playerComponent)).set(playerEntity);
-
-    for (uint256 i; i < spawnPositions.length; i++) {
-      if (i == 0) {
-        spawnSettlement(playerEntity, spawnPositions[i]);
-      } else {
-        spawnSoldier(playerEntity, spawnPositions[i]);
-      }
+    playerComponent.set(playerEntity);
+    OwnedByComponent(getAddressById(components, OwnedByComponentID)).set(spawnEntity, playerEntity);
+    LastActionTurnComponent(getAddressById(components, LastActionTurnComponentID)).set(
+      spawnEntity,
+      LibStamina.getCurrentTurn(components)
+    );
+
+    for (uint256 i; i < unitPositions.length; i++) {
+      spawnSoldier(playerEntity, unitPositions[i]);
     }
   }
 
-  function requirementTyped(Coord memory targetPosition) public view returns (bytes memory) {
-    return requirement(abi.encode(targetPosition));
+  function requirementTyped(uint256 spawnEntity) public view returns (bytes memory) {
+    return requirement(abi.encode(spawnEntity));
   }
 
-  function executeTyped(Coord memory targetPosition) public returns (bytes memory) {
-    return execute(abi.encode(targetPosition));
+  function executeTyped(uint256 spawnEntity) public returns (bytes memory) {
+    return execute(abi.encode(spawnEntity));
   }
 
   // ------------------------
@@ -101,19 +107,4 @@ contract PlayerJoinSystem is ISystem {
       LibStamina.getCurrentTurn(components)
     );
   }
-
-  function spawnSettlement(uint256 ownerId, Coord memory position) private {
-    uint256 entity = world.getUniqueEntityId();
-
-    LibPrototype.copyPrototype(components, SettlementID, entity);
-
-    OwnedByComponent(getAddressById(components, OwnedByComponentID)).set(entity, ownerId);
-
-    PositionComponent(getAddressById(components, PositionComponentID)).set(entity, position);
-
-    LastActionTurnComponent(getAddressById(components, LastActionTurnComponentID)).set(
-      entity,
-      LibStamina.getCurrentTurn(components) - 5
-    );
-  }
 }