feat: added pit traps and spikes

Author: Picoseconds

src/gameobjects/GameObject.ts

@@ -1,5 +1,7 @@
 import Vec2 from "vec2";
 import { GameObjectType } from './gameobjects';
+import Player from "../moomoo/Player";
+import { Tribe } from "../moomoo/Tribes";
 
 export default class GameObject {
   constructor(
@@ -10,7 +12,8 @@ export default class GameObject {
     public type: GameObjectType = GameObjectType.Tree,
     public realScale: number = scale,
     public data: any = null,
-    public ownerSID: number = -1
+    public ownerSID: number = -1,
+    public health: number = -1
   ) {}
 
   getData() {
@@ -25,4 +28,18 @@ export default class GameObject {
 			this.ownerSID
 		];
   }
+
+  isPlayerGameObject() {
+    return this.type === -1 && typeof this.data === 'number';
+  }
+
+  isEnemy(player: Player, tribes: Tribe[]) {
+    if (this.ownerSID === player.id) return false;
+
+    for (let tribe of tribes) {
+      if (tribe.membersSIDs.includes(player.id) && tribe.membersSIDs.includes(this.ownerSID)) return false;
+    }
+
+    return true;
+  }
 }

src/items/items.ts

@@ -152,11 +152,53 @@ function getGameObjID(item: ItemType) {
 }
 
 function hasCollision(item: ItemType) {
-  return items[item].group.layer >= 1;
+  return items[item].group.layer >= 0;
 }
 
 function getWeaponSpeedMultiplier(weapon: Weapons) {
   return weapons[weapon].spdMult || 1;
 }
 
-export { PrimaryWeapons, SecondaryWeapons, getHitTime, Weapons, getWeaponAttackDetails, getWeaponDamage, getItemCost, getPlaceable, getPlaceOffset, getScale, getGameObjID, getWeaponGatherAmount, getPrerequisiteItem, getGroupID, getPrerequisiteWeapon, getWeaponSpeedMultiplier, hasCollision };
+function getStructureDamage(weapon: Weapons) {
+  let weaponData = weapons[weapon];
+
+  if (weaponData.dmg) {
+    if (weaponData.sDmg)
+      return weaponData.dmg * weaponData.sDmg;
+
+    return weaponData.dmg;
+  }
+
+  return 0;
+}
+
+function getGameObjHealth(item: ItemType) {
+  return items[item].health || -1;
+}
+
+function getGameObjDamage(item: ItemType) {
+  return items[item].dmg || 0;
+}
+
+export {
+  PrimaryWeapons,
+  SecondaryWeapons,
+  getHitTime,
+  Weapons,
+  getWeaponAttackDetails,
+  getWeaponDamage,
+  getItemCost,
+  getPlaceable,
+  getPlaceOffset,
+  getScale,
+  getGameObjID,
+  getWeaponGatherAmount,
+  getPrerequisiteItem,
+  getGroupID,
+  getPrerequisiteWeapon,
+  getWeaponSpeedMultiplier,
+  hasCollision,
+  getStructureDamage,
+  getGameObjHealth,
+  getGameObjDamage
+};

src/moomoo/Game.ts

@@ -14,7 +14,7 @@ import GameObject from "../gameobjects/GameObject";
 import { PacketType } from "../packets/PacketType";
 import FileAsync from 'lowdb/adapters/FileAsync';
 import { PacketFactory } from "../packets/PacketFactory";
-import { getWeaponDamage, getWeaponAttackDetails, getItemCost, getPlaceable, PrimaryWeapons, getWeaponGatherAmount, getPrerequisiteItem, getGroupID, Weapons, getPrerequisiteWeapon, getPlaceOffset, getWeaponSpeedMultiplier } from "../items/items";
+import { getWeaponDamage, getWeaponAttackDetails, getItemCost, getPlaceable, PrimaryWeapons, getWeaponGatherAmount, getPrerequisiteItem, getGroupID, Weapons, getPrerequisiteWeapon, getPlaceOffset, getWeaponSpeedMultiplier, getStructureDamage } from "../items/items";
 import { gameObjectSizes, GameObjectType } from "../gameobjects/gameobjects";
 import { getUpgrades, getWeaponUpgrades } from './Upgrades';
 import { getHat } from './Hats';
@@ -507,6 +507,42 @@ export default class Game {
           }
 
           for (let hitGameObject of hitGameObjects) {
+            if (hitGameObject.health !== -1) {
+              let dmgMult = 1;
+              let hat = getHat(player.hatID);
+
+              if (hat && hat.bDmg)
+                dmgMult *= hat.bDmg;
+
+              hitGameObject.health -= getStructureDamage(player.selectedWeapon) * dmgMult;
+
+              if (hitGameObject.health <= 0) {
+                let itemCost = getItemCost(hitGameObject.data);
+                let costs = chunk(itemCost, 2);
+
+                for (let cost of costs) {
+                  switch (cost[0]) {
+                    case "food":
+                      player.food += cost[1] as number;
+                      break;
+                    case "wood":
+                      player.wood += cost[1] as number;
+                      break;
+                    case "stone":
+                      player.stone += cost[1] as number;
+                      break;
+                  }
+                }
+
+                this.state.removeGameObject(hitGameObject);
+                this.sendGameObjects(player);
+
+                for (let otherPlayer of player.getNearbyPlayers(this.state)) {
+                  this.sendGameObjects(otherPlayer);
+                }
+              }
+            }
+
             for (let nearbyPlayer of nearbyPlayers) {
               nearbyPlayer.client?.socket.send(
                 packetFactory.serializePacket(

src/moomoo/GameState.ts

@@ -18,6 +18,25 @@ export default class GameState {
     this.game = game;
   }
 
+  removeGameObject(gameObject: GameObject) {
+    let packetFactory = PacketFactory.getInstance();
+    this.gameObjects.splice(this.gameObjects.indexOf(gameObject), 1);
+
+    for (let player of this.players) {
+      if (player.client && player.client.seenGameObjects.includes(gameObject.id)) {
+        player.client.seenGameObjects.splice(player.client.seenGameObjects.indexOf(gameObject.id), 1);
+        player.client.socket.send(
+          packetFactory.serializePacket(
+            new Packet(
+              PacketType.REMOVE_GAME_OBJ,
+              [gameObject.id]
+            )
+          )
+        );
+      }
+    }
+  }
+
   joinClan(player: Player, tribe: Tribe) {
     if (!tribe.membersSIDs.includes(player.id))
       tribe.membersSIDs.push(player.id);

src/moomoo/Physics.ts

@@ -1,16 +1,16 @@
 import Vec2 from "vec2";
 import Player from "./Player";
-import { eucDistance } from "./util";
 import GameObject from '../gameobjects/GameObject';
-import { gameObjectSizes } from "../gameobjects/gameobjects";
-import { getWeaponAttackDetails, Weapons, hasCollision } from "../items/items";
+import { getWeaponAttackDetails, hasCollision, getGameObjDamage } from "../items/items";
 import GameState from "./GameState";
+import { ItemType } from "../items/UpgradeItems";
+import { getHat } from "./Hats";
 
 function collideCircles(pos1: Vec2, r1: number, pos2: Vec2, r2: number) {
   return pos1.distance(pos2) <= r1 + r2;
 }
 
-function collideRectangles(x1: number, y1: number, w1: number, h1: number, x2: number, y2: number, w2: number, h2: number) {
+function collideRectangles(x1: number, y1: number, w1: number, x2: number, y2: number, w2: number, h2: number) {
   return x1 + w1 >= x2 && x1 <= x2 + w2 && y1 + w1 >= y2 && y1 <= y2 + h2;
 }
 
@@ -32,13 +32,39 @@ function collidePlayerGameObject(player: Player, gameObj: GameObject) {
 }
 
 function tryMovePlayer(player: Player, delta: number, xVel: number, yVel: number, state: GameState) {
+  let inTrap = false;
+
   let newLocation = new Vec2(
     player.location.x,
     player.location.y
   );
 
   for (let gameObj of player.getNearbyGameObjects(state)) {
-    if (!gameObj.type && typeof gameObj.data === 'number') {
+    if (gameObj.isPlayerGameObject() && collidePlayerGameObject(player, gameObj)) {
+      if (
+        gameObj.data === ItemType.PitTrap &&
+        gameObj.isEnemy(player, state.tribes)
+      ) {
+        inTrap = true;
+      }
+
+      let dmg = getGameObjDamage(gameObj.data);
+
+      if (
+        dmg &&
+        gameObj.isEnemy(player, state.tribes)
+      ) {
+        let hat = getHat(player.hatID);
+
+        if (hat) {
+          dmg *= hat.dmgMult || 1;
+        }
+
+        let angle = Math.atan2(player.location.y - gameObj.location.y, player.location.x - gameObj.location.x);
+        player.velocity.add(Math.cos(angle), Math.sin(angle));
+        player.health -= dmg;
+      }
+
       if (!hasCollision(gameObj.data)) continue;
     }
 
@@ -47,20 +73,23 @@ function tryMovePlayer(player: Player, delta: number, xVel: number, yVel: number
       yVel *= .75;
 
       let angle = Math.atan2(newLocation.y - gameObj.location.y, newLocation.x - gameObj.location.x);
+
       newLocation = new Vec2(
         gameObj.location.x + Math.cos(angle) * (gameObj.realScale + 35),
         gameObj.location.y + Math.sin(angle) * (gameObj.realScale + 35)
       );
     }
   }
 
+  player.inTrap = inTrap;
+  if (inTrap) return;
+
   newLocation.clamp(new Vec2(0 + 35, 0 + 35), new Vec2(14400 - 35, 14400 - 35));
   player.location = newLocation.add(delta * xVel, delta * yVel);
 }
 
 function movePlayer(player: Player, delta: number, state: GameState) {
   if (player.velocity.x || player.velocity.y) {
-    let angle = Math.atan2(player.velocity.y, player.velocity.x);
     tryMovePlayer(player, delta, player.velocity.x, player.velocity.y, state);
     player.velocity = player.velocity.multiply(0.993 ** delta, 0.993 ** delta);
   }
@@ -91,7 +120,7 @@ function checkAttack(player: Player, players: Player[]) {
 }
 
 function collideGameObjects(gameObject1: GameObject, gameObject2: GameObject) {
-  return collideCircles(gameObject1.location, gameObject1.scale, gameObject2.location, gameObject1.scale);
+  return collideCircles(gameObject1.location, gameObject1.realScale * 0.9, gameObject2.location, gameObject1.realScale);
 }
 
 function checkAttackGameObj(player: Player, gameObjects: GameObject[]) {

src/moomoo/Player.ts

@@ -16,7 +16,8 @@ import {
   getPlaceable,
   getScale,
   getPlaceOffset,
-  getGameObjID
+  getGameObjID,
+  getGameObjHealth
 } from "../items/items";
 import { ItemType } from "../items/UpgradeItems";
 import GameObject from "../gameobjects/GameObject";
@@ -306,10 +307,10 @@ export default class Player extends Entity {
         this.angle,
         getScale(item),
         -1,
-        undefined,
-        // getGameObjID(item),
+        item === ItemType.PitTrap ? 0.3 * getScale(item) : undefined,
         item,
-        this.id
+        this.id,
+        getGameObjHealth(item)
       );
 
       for (let gameObject of gameState.gameObjects) {

src/packets/PacketFactory.ts

@@ -66,6 +66,7 @@ packetTypeMapping[PacketType.UPDATE_STATS] = { value: "9", side: Side.Client };
 packetTypeMapping[PacketType.IO_INIT] = { value: "io-init", side: Side.Client };
 packetTypeMapping[PacketType.HEALTH_CHANGE] = { value: "t", side: Side.Client };
 packetTypeMapping[PacketType.JOIN_REQUEST] = { value: "an", side: Side.Client };
+packetTypeMapping[PacketType.REMOVE_GAME_OBJ] = { value: "12", side: Side.Client };
 
 let reversePacketTypeMapping: ReverseMapping[] = [];
 

src/packets/PacketType.ts

@@ -47,7 +47,8 @@ enum PacketType {
   CLAN_NOTIFY_SERVER,
   CLAN_NOTIFY_CLIENT,
   HEALTH_CHANGE,
-  JOIN_REQUEST
+  JOIN_REQUEST,
+  REMOVE_GAME_OBJ
 }
 
 export { PacketType };