Merge branch 'develop' into feature/replace-login-music

Author: Tynarus

.gitignore

@@ -22,3 +22,4 @@ yarn-error.log*
 *.njsproj
 *.sln
 *.sw?
+/.vs

package.json

@@ -12,6 +12,7 @@
         "start:infra": "concurrently \"npm run start:update\" \"npm run start:login\"",
         "start:standalone": "concurrently \"npm run start:infra\" \"npm run start:game\"",
         "lint": "eslint -c .eslintrc.js --ext .ts src",
+        "lint-fix": "eslint -c .eslintrc.js --ext .ts src --fix",
         "fake-players": "concurrently \"npm run build:watch\" \"node --max-old-space-size=4096 dist/index.js -fakePlayers\"",
         "fake-players-tick": "concurrently \"npm run build:watch\" \"node --max-old-space-size=4096 dist/index.js -fakePlayers -tickTime\"",
         "build:watch": "babel ./src --out-dir dist --extensions \".ts,.tsx,.js\" --source-maps --watch",

src/game-engine/net/inbound-packets/magic-attack-packet.ts

@@ -0,0 +1,23 @@
+import { Player, playerOptions } from '../../world/actor/player/player';
+import { world } from '../../game-server';
+import { World } from '../../world';
+import { logger } from '@runejs/core';
+import { PacketData } from '../inbound-packets';
+
+
+const magicAttackPacket = (player: Player, packet: PacketData) => {
+    const { buffer } = packet;
+    const npcWorldIndex = buffer.get('short', 'u'); // unsigned short BE
+    const widgetId = buffer.get('short', 'u', 'le'); // unsigned short LE
+    const widgetChildId = buffer.get(); // unsigned short LE
+
+    const npc = world.npcList[npcWorldIndex];
+
+    player.actionPipeline.call('magic_on_npc', npc, player, widgetId, widgetChildId);
+};
+
+export default [{
+    opcode: 253,
+    size: 6,
+    handler: magicAttackPacket
+}];

src/game-engine/net/inbound-packets/widget-interaction-packet.js renamed to src/game-engine/net/inbound-packets/widget-interaction-packet.ts

@@ -1,4 +1,8 @@
-const widgetInteractionPacket = (player, packet) => {
+import { Player } from '@engine/world/actor/player/player';
+import { PacketData } from '@engine/net/inbound-packets';
+
+
+const widgetInteractionPacket = (player: Player, packet: PacketData) => {
     const { buffer } = packet;
     const childId = buffer.get('short');
     const widgetId = buffer.get('short');

src/game-engine/world/action/index.ts

@@ -36,6 +36,10 @@ export type ActionType =
     | 'move_item'
     | 'spawned_item_interaction'
 
+    | 'magic_on_item'
+    | 'magic_on_player'
+    | 'magic_on_npc'
+
     | 'player_init'
     | 'player_command'
     | 'player_interaction'
@@ -61,10 +65,15 @@ export type ActionCancelType =
     | 'widget';
 
 
+/**
+ * The definition for the actual action pipe handler function.
+ */
+export type ActionPipeHandler = (...args: any[]) => RunnableHooks | void;
+
 /**
  * Basic definition of a game engine action file (.action.ts exports).
  */
-export type ActionPipe = [ ActionType, (...args: any[]) => void ];
+export type ActionPipe = [ ActionType, ActionPipeHandler ];
 
 
 /**
@@ -86,7 +95,7 @@ export interface RunnableHooks<T = any> {
  */
 export class ActionPipeline {
 
-    private static pipes = new Map<string, any>();
+    private static pipes = new Map<string, ActionPipeHandler>();
 
     private runningTasks: TaskExecutor<any>[] = [];
     private canceling: boolean = false;
@@ -97,12 +106,12 @@ export class ActionPipeline {
             .subscribe(async () => this.cancelRunningTasks());
     }
 
-    public static getPipe(action: ActionType): Map<string, any> {
+    public static getPipe(action: ActionType): ActionPipeHandler {
         return ActionPipeline.pipes.get(action);
     }
 
-    public static register(action: ActionType, actionPipe: (...args: any[]) => void): void {
-        ActionPipeline.pipes.set(action.toString(), actionPipe);
+    public static register(action: ActionType, actionPipeHandlerFn: ActionPipeHandler): void {
+        ActionPipeline.pipes.set(action.toString(), actionPipeHandlerFn);
     }
 
     public shutdown(): void {
@@ -113,7 +122,7 @@ export class ActionPipeline {
         const actionHandler = ActionPipeline.pipes.get(action.toString());
         if(actionHandler) {
             try {
-                await this.runActionHandler(actionHandler, ...args);
+                await this.runActionHandler(actionHandler, args);
             } catch(error) {
                 if(error) {
                     logger.error(`Error handling action ${action.toString()}`);
@@ -141,7 +150,7 @@ export class ActionPipeline {
         this.canceling = false;
     }
 
-    private async runActionHandler(actionHandler: any, ...args: any[]): Promise<void> {
+    private async runActionHandler(actionHandler: any, args: any[]): Promise<void> {
         const runnableHooks: RunnableHooks | null | undefined = await actionHandler(...args);
 
         if(!runnableHooks?.hooks || runnableHooks.hooks.length === 0) {
@@ -150,7 +159,6 @@ export class ActionPipeline {
 
         for(let i = 0; i < runnableHooks.hooks.length; i++) {
             const hook = runnableHooks.hooks[i];
-
             if(!hook) {
                 continue;
             }

src/game-engine/world/action/magic-on-npc.action.ts

@@ -0,0 +1,76 @@
+import { Player } from '@engine/world/actor/player/player';
+import { ActionHook, getActionHooks } from '@engine/world/action/hooks';
+import { advancedNumberHookFilter, questHookFilter } from '@engine/world/action/hooks/hook-filters';
+import { ActionPipe, RunnableHooks } from '@engine/world/action/index';
+import { Npc } from '../actor/npc/npc';
+
+
+/**
+ * Defines a button action hook.
+ */
+export interface MagicOnNPCActionHook extends ActionHook<MagicOnNPCAction, magiconnpcActionHandler> {
+    // The npc world id that was clicked on after choosing the spell
+    npcworldId?: number;
+    // The IDs of the UI widgets that the buttons are on.
+    widgetIds?: number[];
+    // The child ID or list of child IDs of the button(s) within the UI widget.
+    buttonIds?: number | number[];
+    // Whether or not this item action should cancel other running or queued actions.
+    cancelActions?: boolean;
+}
+
+
+/**
+ * The button action hook handler function to be called when the hook's conditions are met.
+ */
+export type magiconnpcActionHandler = (buttonAction: MagicOnNPCAction) => void | Promise<void>;
+
+
+/**
+ * Details about a button action being performed.
+ */
+export interface MagicOnNPCAction {
+    // The npc world id that was clicked on after choosing the spell
+    npc: Npc;
+    // The player performing the action.
+    player: Player;
+    // The ID of the UI widget that the button is on.
+    widgetId: number;
+    // The child ID of the button within the UI widget.
+    buttonId: number;
+}
+
+
+/**
+ * The pipe that the game engine hands button actions off to.
+ * @param npc
+ * @param player
+ * @param widgetId
+ * @param buttonId
+ */
+const magicOnNpcActionPipe = (npc:Npc, player: Player, widgetId: number, buttonId: number): RunnableHooks<MagicOnNPCAction> => {
+    //console.info(`pew pew you use magic on ${npc.name}!`);
+
+    // Find all object action plugins that reference this location object
+    const matchingHooks = getActionHooks<MagicOnNPCActionHook>('magic_on_npc');
+      
+
+    return {
+        hooks: matchingHooks,
+        actionPosition: player.position,
+        action: {
+            npc,
+            player,
+            widgetId,
+            buttonId
+        }
+    }
+    
+    
+};
+
+
+/**
+ * Button action pipe definition.
+ */
+export default [ 'magic_on_npc', magicOnNpcActionPipe ] as ActionPipe;

src/game-engine/world/action/widget-interaction.action.ts

@@ -48,9 +48,10 @@ export interface WidgetInteractionAction {
  * @param optionId The widget context option chosen by the player.
  */
 const widgetActionPipe = (player: Player, widgetId: number, childId: number, optionId: number): RunnableHooks<WidgetInteractionAction> => {
-    const playerWidget = Object.values(player.interfaceState.widgetSlots).find((widget) => widget && widget.widgetId === widgetId);
+    const playerWidget = Object.values(player.interfaceState.widgetSlots)
+        .find((widget) => widget && widget.widgetId === widgetId);
 
-    if(playerWidget && playerWidget.fakeWidget != undefined) {
+    if(playerWidget?.fakeWidget) {
         widgetId = playerWidget.fakeWidget;
     }
 
@@ -86,9 +87,11 @@ const widgetActionPipe = (player: Player, widgetId: number, childId: number, opt
         return null;
     }
 
+    const action: WidgetInteractionAction = { player, widgetId, childId, optionId };
+
     return {
         hooks: matchingHooks,
-        action: { player, widgetId, childId, optionId }
+        action
     };
 };
 

src/game-engine/world/actor/actor.ts

@@ -2,7 +2,7 @@ import { WalkingQueue } from './walking-queue';
 import { ItemContainer } from '../items/item-container';
 import { Animation, DamageType, Graphic, UpdateFlags } from './update-flags';
 import { Npc } from './npc/npc';
-import { Skills } from '@engine/world/actor/skills';
+import { Skill, Skills } from '@engine/world/actor/skills';
 import { Item } from '@engine/world/items/item';
 import { Position } from '@engine/world/position';
 import { DirectionData, directionFromIndex } from '@engine/world/direction';
@@ -14,6 +14,11 @@ import { WorldInstance } from '@engine/world/instances';
 import { Player } from '@engine/world/actor/player/player';
 import { ActionCancelType, ActionPipeline } from '@engine/world/action';
 import { LandscapeObject } from '@runejs/filestore';
+import { Behavior } from './behaviors/behavior';
+import { soundIds } from '../config/sound-ids';
+import { animationIds } from '../config/animation-ids';
+import { findNpc } from '../../config';
+import { itemIds } from '../config/item-ids';
 
 
 /**
@@ -36,6 +41,25 @@ export abstract class Actor {
 
     public pathfinding: Pathfinding = new Pathfinding(this);
     public lastMovementPosition: Position;
+    // #region Behaviors and Combat flags/checks
+    public inCombat: boolean = false;
+    public meleeDistance: number = 1;
+    public Behaviors: Behavior[] = [];
+    public isDead: boolean = false;
+    public combatTargets: Actor[] = [];
+    public hitPoints = this.skills.hitpoints.level * 4;
+    public maxHitPoints = this.skills.hitpoints.level * 4;
+    public get highestCombatSkill(): Skill {
+        const attack = this.skills.getLevel('attack');
+        const magic = this.skills.getLevel('magic');
+        const ranged = this.skills.getLevel('ranged');
+
+        if (ranged > magic && ranged > ranged) return ranged;
+        else if (magic > attack && magic > ranged) return magic;
+        else return attack;
+    }
+
+    // #endregion  
 
     protected randomMovementInterval;
 
@@ -59,20 +83,36 @@ export abstract class Actor {
         this._busy = false;
     }
 
-    public damage(amount: number, damageType: DamageType = DamageType.DAMAGE): 'alive' | 'dead' {
-        let remainingHitpoints: number = this.skills.hitpoints.level - amount;
-        const maximumHitpoints: number = this.skills.hitpoints.levelForExp;
-        if(remainingHitpoints < 0) {
-            remainingHitpoints = 0;
-        }
-
-        this.skills.setHitpoints(remainingHitpoints);
+    public damage(amount: number, damageType: DamageType = DamageType.DAMAGE) {
+        const armorReduction = 0;
+        const spellDamageReduction = 0;
+        const poisonReistance = 0;
+        amount -= armorReduction;
+        this.hitPoints -= amount;
+        this.skills.setHitpoints(this.hitPoints);
         this.updateFlags.addDamage(amount, amount === 0 ? DamageType.NO_DAMAGE : damageType,
-            remainingHitpoints, maximumHitpoints);
-
-        return remainingHitpoints === 0 ? 'dead' : 'alive';
+            this.hitPoints, this.maxHitPoints);
+        //this actor should respond when hit
+        world.playLocationSound(this.position, soundIds.npc.human.noArmorHitPlayer,5)
+        this.playAnimation(this.getBlockAnimation());
     }
 
+
+
+    //public damage(amount: number, damageType: DamageType = DamageType.DAMAGE): 'alive' | 'dead' {
+    //    let remainingHitpoints: number = this.skills.hitpoints.level - amount;
+    //    const maximumHitpoints: number = this.skills.hitpoints.levelForExp;
+    //    if(remainingHitpoints < 0) {
+    //        remainingHitpoints = 0;
+    //    }
+
+    //    this.skills.setHitpoints(remainingHitpoints);
+    //    this.updateFlags.addDamage(amount, amount === 0 ? DamageType.NO_DAMAGE : damageType,
+    //        remainingHitpoints, maximumHitpoints);
+
+    //    return remainingHitpoints === 0 ? 'dead' : 'alive';
+    //}
+
     /**
      * Waits for the actor to reach the specified position before resolving it's promise.
      * The promise will be rejected if the actor's walking queue changes or their movement is otherwise canceled.
@@ -548,4 +588,5 @@ export abstract class Actor {
         };
     }
 
+
 }