Merge pull request #162 from rune-js/skills-by-name

TheBlackParade · web-flow · commit c8c999e03107 · 2020-06-06T13:44:33.000-05:00
Adding support for selecting player skill info via skill name.
diff --git a/src/plugins/commands/give-item-command.ts b/src/plugins/commands/give-item-command.ts
@@ -1,6 +1,7 @@
 import { ActionType, RunePlugin } from '@server/plugins/plugin';
 import { commandAction } from '@server/world/actor/player/action/input-command-action';
 import { cache } from '@server/game-server';
+import { itemIds } from '@server/world/config/item-ids';
 
 const action: commandAction = (details) => {
     const { player, args } = details;
@@ -12,7 +13,20 @@ const action: commandAction = (details) => {
         return;
     }
 
-    const itemId: number = args.itemId as number;
+    const itemSearch: string = args.itemSearch as string;
+    let itemId: number;
+
+    if(itemSearch.match(/^[0-9]+$/)) {
+        itemId = parseInt(itemSearch, 10);
+    } else {
+        // @TODO nested item ids
+        itemId = itemIds[itemSearch];
+    }
+
+    if(isNaN(itemId)) {
+        throw new Error(`Item name not found.`);
+    }
+
     let amount: number = args.amount as number;
 
     if(amount > 2000000000) {
@@ -52,8 +66,8 @@ export default new RunePlugin({
     commands: [ 'give', 'item', 'spawn' ],
     args: [
         {
-            name: 'itemId',
-            type: 'number'
+            name: 'itemSearch',
+            type: 'string'
         },
         {
             name: 'amount',
diff --git a/src/plugins/commands/spawn-scenery-command.ts b/src/plugins/commands/spawn-scenery-command.ts
@@ -16,11 +16,12 @@ const spawnSceneryAction: commandAction = (details) => {
     if(locationObjectSearch.match(/^[0-9]+$/)) {
         locationObjectId = parseInt(locationObjectSearch, 10);
     } else {
+        // @TODO nested object ids
         locationObjectId = objectIds[locationObjectSearch];
     }
 
     if(isNaN(locationObjectId)) {
-        throw `Location object name not found.`;
+        throw new Error(`Location object name not found.`);
     }
 
     const objectType = args.objectType as number;
diff --git a/src/plugins/skills/firemaking-plugin.ts b/src/plugins/skills/firemaking-plugin.ts
@@ -1,6 +1,5 @@
 import { itemOnItemAction } from '@server/world/actor/player/action/item-on-item-action';
 import { world } from '@server/game-server';
-import { Skill } from '@server/world/actor/skills';
 import { loopingAction } from '@server/world/actor/player/action/action';
 import { LocationObject } from '@runejs/cache-parser';
 import { Player } from '@server/world/actor/player/player';
@@ -52,7 +51,7 @@ const lightFire = (player: Player, position: Position, worldItemLog: WorldItem,
 
     player.playAnimation(null);
     player.sendMessage(`The fire catches and the logs begin to burn.`);
-    player.skills.addExp(Skill.FIREMAKING, burnExp);
+    player.skills.addExp('firemaking', burnExp);
 
     if(!player.walkingQueue.moveIfAble(-1, 0)) {
         if(!player.walkingQueue.moveIfAble(1, 0)) {
@@ -93,7 +92,8 @@ const action: itemOnItemAction = (details) => {
     player.removeItem(removeFromSlot);
     const worldItemLog = world.spawnWorldItem(log, player.position, player, 300);
 
-    if(player.metadata['lastFire'] && Date.now() - player.metadata['lastFire'] < 1200 && canChain(skillInfo.requiredLevel, player.skills.values[Skill.WOODCUTTING].level)) {
+    if(player.metadata['lastFire'] && Date.now() - player.metadata['lastFire'] < 1200 &&
+        canChain(skillInfo.requiredLevel, player.skills.getSkillLevel('firemaking'))) {
         lightFire(player, position, worldItemLog, skillInfo.burnExp);
     } else {
         player.sendMessage(`You attempt to light the logs.`);
@@ -121,7 +121,7 @@ const action: itemOnItemAction = (details) => {
                 player.playAnimation(animationIds.lightingFire);
             }
 
-            canLightFire = elapsedTicks > 10 && canLight(skillInfo.requiredLevel, player.skills.values[Skill.WOODCUTTING].level);
+            canLightFire = elapsedTicks > 10 && canLight(skillInfo.requiredLevel, player.skills.getSkillLevel('firemaking'));
 
             if(!canLightFire && (elapsedTicks === 0 || elapsedTicks % 4 === 0)) {
                 player.playSound(soundIds.lightingFire, 10, 0);
@@ -134,4 +134,8 @@ const action: itemOnItemAction = (details) => {
     }
 };
 
-export default new RunePlugin({ type: ActionType.ITEM_ON_ITEM_ACTION, items: logs.map(log => ({item1: itemIds.tinderbox, item2: log.logId})), action });
+export default new RunePlugin({
+    type: ActionType.ITEM_ON_ITEM_ACTION,
+    items: logs.map(log => ({ item1: itemIds.tinderbox, item2: log.logId })),
+    action
+});
diff --git a/src/world/actor/skills.ts b/src/world/actor/skills.ts
@@ -29,6 +29,10 @@ export enum Skill {
     CONSTRUCTION = 22
 }
 
+export type SkillName = 'attack' | 'defence' | 'strength' | 'hitpoints' | 'ranged' | 'prayer' | 'magic' | 'cooking' |
+    'woodcutting' | 'fletching' | 'fishing' | 'firemaking' | 'crafting' | 'smithing' | 'mining' | 'herblore' |
+    'agility' | 'thieving' | 'slayer' | 'farming' | 'runecrafting' | 'construction';
+
 export interface SkillDetail {
     readonly name: string;
     readonly advancementWidgetId?: number;
@@ -89,12 +93,12 @@ export class Skills {
      *   Also add a new method to get the unboostedLevel incase it's ever needed
      *   Then think about some way to reliably and easily fade those boosts out over time
      */
-    public getSkillLevel(skillId: number, level: number): number {
-        return this.values[skillId].level;
+    public getSkillLevel(skill: number | SkillName): number {
+        return this.get(skill).level;
     }
 
-    public hasSkillLevel(skillId: number, level: number): boolean {
-        return this.values[skillId].level >= level;
+    public hasSkillLevel(skill: number | SkillName, level: number): boolean {
+        return this.get(skill).level >= level;
     }
 
     public getLevelForExp(exp: number): number {
@@ -112,8 +116,8 @@ export class Skills {
         return 99;
     }
 
-    public addExp(skillId: number, exp: number): void {
-        const currentExp = this._values[skillId].exp;
+    public addExp(skill: number | SkillName, exp: number): void {
+        const currentExp = this.get(skill).exp;
         const currentLevel = this.getLevelForExp(currentExp);
         let finalExp = currentExp + (exp * serverConfig.expRate);
         if(finalExp > 200000000) {
@@ -122,34 +126,35 @@ export class Skills {
 
         const finalLevel = this.getLevelForExp(finalExp);
 
-        this.setExp(skillId, finalExp);
+        this.setExp(skill, finalExp);
 
         if(this.actor instanceof Player) {
-            this.actor.outgoingPackets.updateSkill(skillId, finalLevel, finalExp);
+            this.actor.outgoingPackets.updateSkill(this.getSkillId(skill), finalLevel, finalExp);
         }
 
         if(currentLevel !== finalLevel) {
-            this.setLevel(skillId, finalLevel);
+            this.setLevel(skill, finalLevel);
 
             if(this.actor instanceof Player) {
-                const achievementDetails = skillDetails[skillId];
+                const achievementDetails = skillDetails[this.getSkillId(skill)];
                 if(!achievementDetails) {
                     return;
                 }
 
-                this.actor.sendMessage(`Congratulations, you just advanced a ${achievementDetails.name.toLowerCase()} level.`);
-                this.showLevelUpDialogue(skillId, finalLevel);
+                this.actor.sendMessage(`Congratulations, you just advanced a ` +
+                    `${ achievementDetails.name.toLowerCase() } level.`);
+                this.showLevelUpDialogue(skill, finalLevel);
             }
         }
     }
 
-    public showLevelUpDialogue(skillId: number, level: number): void {
+    public showLevelUpDialogue(skill: number | SkillName, level: number): void {
         if(!(this.actor instanceof Player)) {
             return;
         }
 
         const player = this.actor as Player;
-        const achievementDetails = skillDetails[skillId];
+        const achievementDetails = skillDetails[this.getSkillId(skill)];
         const widgetId = achievementDetails.advancementWidgetId;
 
         if(!widgetId) {
@@ -164,9 +169,10 @@ export class Skills {
             closeOnWalk: true,
             beforeOpened: () => {
                 player.modifyWidget(widgetId, { childId: 0,
-                    text: `<col=000080>Congratulations, you just advanced ${startsWithVowel(skillName) ? 'an' : 'a'} ${skillName} level.</col>` });
+                    text: `<col=000080>Congratulations, you just advanced ${ startsWithVowel(skillName) ? 'an' : 'a' } ` +
+                        `${ skillName } level.</col>` });
                 player.modifyWidget(widgetId, { childId: 1,
-                    text: `Your ${skillName} level is now ${level}.` });
+                    text: `Your ${skillName} level is now ${ level }.` });
             },
             afterOpened: () => {
                 player.playGraphics({ id: gfxIds.levelUpFireworks, delay: 0, height: 125 });
@@ -175,14 +181,34 @@ export class Skills {
         });
     }
 
-    public setExp(skillId: number, exp: number): void {
+    public setExp(skill: number | SkillName, exp: number): void {
+        const skillId = this.getSkillId(skill);
         this._values[skillId].exp = exp;
     }
 
-    public setLevel(skillId: number, level: number): void {
+    public setLevel(skill: number | SkillName, level: number): void {
+        const skillId = this.getSkillId(skill);
         this._values[skillId].level = level;
     }
 
+    public getSkillId(skill: number | SkillName) : number {
+        if(typeof skill === 'number') {
+            return skill;
+        } else {
+            const skillName = skill.toString().toUpperCase();
+            return Skill[skillName].valueOf();
+        }
+    }
+
+    public get(skill: number | SkillName): SkillValue {
+        if(typeof skill === 'number') {
+            return this._values[skill];
+        } else {
+            const skillName = skill.toString().toUpperCase();
+            return this._values[Skill[skillName].valueOf()];
+        }
+    }
+
     public get values(): SkillValue[] {
         return this._values;
     }
diff --git a/src/world/world.ts b/src/world/world.ts
@@ -218,11 +218,16 @@ export class World {
         }
 
         const position = new Position(newObject.x, newObject.y, newObject.level);
+        const chunk = this.chunkManager.getChunkForWorldPosition(position);
 
+        this.deleteAddedLocationObjectMarker(oldObject, position, chunk);
         this.addLocationObject(newObject, position);
 
         if(respawnTicks !== -1) {
-            schedule(respawnTicks).then(() => this.addLocationObject(oldObject, position));
+            schedule(respawnTicks).then(() => {
+                this.deleteAddedLocationObjectMarker(newObject as LocationObject, position, chunk);
+                this.addLocationObject(oldObject, position);
+            });
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,12 @@ const spawnSceneryAction: commandAction = (details) => {`
`16`	`16`	`if(locationObjectSearch.match(/^[0-9]+$/)) {`
`17`	`17`	`locationObjectId = parseInt(locationObjectSearch, 10);`
`18`	`18`	`} else {`
	`19`	`+ // @TODO nested object ids`
`19`	`20`	`locationObjectId = objectIds[locationObjectSearch];`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`if(isNaN(locationObjectId)) {`
`23`		- throw `Location object name not found.`;
	`24`	+ throw new Error(`Location object name not found.`);
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`const objectType = args.objectType as number;`
Original file line number	Diff line number	Diff line change
`@@ -218,11 +218,16 @@ export class World {`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`const position = new Position(newObject.x, newObject.y, newObject.level);`
	`221`	`+ const chunk = this.chunkManager.getChunkForWorldPosition(position);`
`221`	`222`
	`223`	`+ this.deleteAddedLocationObjectMarker(oldObject, position, chunk);`
`222`	`224`	`this.addLocationObject(newObject, position);`
`223`	`225`
`224`	`226`	`if(respawnTicks !== -1) {`
`225`		`- schedule(respawnTicks).then(() => this.addLocationObject(oldObject, position));`
	`227`	`+ schedule(respawnTicks).then(() => {`
	`228`	`+ this.deleteAddedLocationObjectMarker(newObject as LocationObject, position, chunk);`
	`229`	`+ this.addLocationObject(oldObject, position);`
	`230`	`+ });`
`226`	`231`	`}`
`227`	`232`	`}`
`228`	`233`