Refactoring all interface-related things to take on the widget naming…

src/game-server.ts

@@ -51,7 +51,7 @@ export function runGameServer(): void {
     }
 
     process.on('unhandledRejection', (err, promise) => {
-        if(err === 'INTERFACE_CLOSED') {
+        if(err === 'WIDGET_CLOSED') {
             return;
         }
 

src/net/rs-buffer.ts

@@ -253,6 +253,11 @@ export class RsBuffer {
         this.writeUnsignedByte(value + 128 & 0xff);
     }
 
+    public writeUnsignedOffsetShortBE(value: number): void {
+        this.writeUnsignedByte((value >> 8) & 0xff);
+        this.writeUnsignedByte(value + 128 & 0xff);
+    }
+
     public writeNegativeOffsetShortBE(value: number): void {
         this.writeUnsignedByte(value >> 8);
         this.writeUnsignedByte(value - 128 & 0xff);
@@ -263,6 +268,11 @@ export class RsBuffer {
         this.writeUnsignedByte(value >> 8);
     }
 
+    public writeUnsignedOffsetShortLE(value: number): void {
+        this.writeUnsignedByte(value + 128 & 0xff);
+        this.writeUnsignedByte((value >> 8) & 0xff);
+    }
+
     public writeNegativeOffsetShortLE(value: number): void {
         this.writeUnsignedByte(value - 128 & 0xff);
         this.writeUnsignedByte(value >> 8);

src/plugins/buttons/skill-guide-plugin.ts

@@ -67,49 +67,49 @@ export const action: buttonAction = (details) => {
     }
 
     if(refreshSidebar) {
-        player.packetSender.updateInterfaceString(sidebarTextIds[0], guide.subGuides[0].name);
+        player.packetSender.updateWidgetString(sidebarTextIds[0], guide.subGuides[0].name);
 
         for(let i = 1; i < sidebarTextIds.length; i++) {
             const sidebarId = sidebarIds[i];
             let hide: boolean = true;
 
             if(i >= guide.subGuides.length) {
-                player.packetSender.updateInterfaceString(sidebarTextIds[i], '');
+                player.packetSender.updateWidgetString(sidebarTextIds[i], '');
                 hide = true;
             } else {
-                player.packetSender.updateInterfaceString(sidebarTextIds[i], guide.subGuides[i].name);
+                player.packetSender.updateWidgetString(sidebarTextIds[i], guide.subGuides[i].name);
                 hide = false;
             }
 
             if(sidebarId !== -1) {
                 // Apparently you can never have only TWO subguides...
                 // Because 8813 deletes both options 2 AND 3. So, good thing there are no guides with only 2 sections, I guess?...
                 // Verified this in an interface editor, and they are indeed grouped in a single layer for some reason...
-                player.packetSender.toggleInterfaceVisibility(sidebarIds[i] as number, hide);
+                player.packetSender.toggleWidgetVisibility(sidebarIds[i] as number, hide);
             }
         }
     }
 
     const subGuide: SkillSubGuide = guide.subGuides[subGuideIndex];
 
     const itemIds: number[] = subGuide.lines.map(g => g.itemId).concat(new Array(30 - subGuide.lines.length).fill(null));
-    player.packetSender.sendUpdateAllInterfaceItemsById(8847, itemIds);
+    player.packetSender.sendUpdateAllWidgetItemsById(8847, itemIds);
 
-    player.packetSender.updateInterfaceString(8716, guide.name + ' Guide');
-    player.packetSender.updateInterfaceString(8849, subGuide.name);
+    player.packetSender.updateWidgetString(8716, guide.name + ' Guide');
+    player.packetSender.updateWidgetString(8849, subGuide.name);
 
     for(let i = 0; i < 30; i++) {
         if(subGuide.lines.length <= i) {
-            player.packetSender.updateInterfaceString(8720 + i, '');
-            player.packetSender.updateInterfaceString(8760 + i, '');
+            player.packetSender.updateWidgetString(8720 + i, '');
+            player.packetSender.updateWidgetString(8760 + i, '');
         } else {
-            player.packetSender.updateInterfaceString(8720 + i, subGuide.lines[i].level.toString());
-            player.packetSender.updateInterfaceString(8760 + i, subGuide.lines[i].text);
+            player.packetSender.updateWidgetString(8720 + i, subGuide.lines[i].level.toString());
+            player.packetSender.updateWidgetString(8760 + i, subGuide.lines[i].text);
         }
     }
 
-    player.activeInterface = {
-        interfaceId: 8714,
+    player.activeWidget = {
+        widgetId: 8714,
         type: 'SCREEN',
         closeOnWalk: false
     };

src/plugins/item-on-item/firemaking/firemaking-plugin.ts

@@ -16,7 +16,7 @@ const logs = [
     }
 ];
 
-const failedToLight = (logLevel: number, playerLevel: number): boolean => {
+const canLight = (logLevel: number, playerLevel: number): boolean => {
     playerLevel++;
     const hostRatio = Math.random() * logLevel;
     const clientRatio = Math.random() * ((playerLevel - logLevel) * (1 + (logLevel * 0.01)));
@@ -61,7 +61,7 @@ const lightFire = (player: Player, position: Position, worldItemLog: WorldItem,
         }
     }
 
-    player.face(position);
+    player.face(position, false);
     player.metadata['lastFire'] = Date.now();
 };
 
@@ -111,7 +111,7 @@ const action: itemOnItemAction = (details) => {
                 player.packetSender.playSound(375, 7, 1);
             }
 
-            const canLightFire = elapsedTicks > 0 && !failedToLight(skillInfo.requiredLevel, player.skills.values[Skill.WOODCUTTING].level);
+            const canLightFire = elapsedTicks > 0 && canLight(skillInfo.requiredLevel, player.skills.values[Skill.WOODCUTTING].level);
 
             if(canLightFire) {
                 loop.cancel();

src/util/address.ts

@@ -0,0 +1,14 @@
+export const addressToInt = (address: string): number => {
+    if(!address) {
+        return 0;
+    }
+
+    const parts = address.split('.');
+    if(!parts || parts.length !== 4) {
+        return 0;
+    }
+
+    const num = parts.map(p => parseInt(p));
+
+    return ((num[0] & 0xff) << 24) + ((num[1] & 0xff) << 16) + ((num[2] & 0xff) << 8) + (num[3] & 0xff);
+};

src/util/time.ts

@@ -0,0 +1,4 @@
+export const rsTime = (date: Date): number => {
+    const days = Math.round(date.getTime() / 0x5265c00);
+    return days - 11745;
+};

src/world/mob/mob.ts

@@ -33,7 +33,7 @@ export abstract class Mob extends Entity {
         this.skills = new Skills(this);
     }
 
-    public face(face: Position | Mob, autoClear: boolean = true): void {
+    public face(face: Position | Mob, clearWalkingQueue: boolean = true, autoClear: boolean = true): void {
         if(face instanceof Position) {
             this.updateFlags.facePosition = face;
         } else if(face instanceof Mob) {
@@ -47,8 +47,10 @@ export abstract class Mob extends Entity {
             }
         }
 
-        this.walkingQueue.clear();
-        this.walkingQueue.valid = false;
+        if(clearWalkingQueue) {
+            this.walkingQueue.clear();
+            this.walkingQueue.valid = false;
+        }
     }
 
     public clearFaceMob(): void {

src/world/mob/player/action/dialogue-action.ts

@@ -3,7 +3,7 @@ import { gameCache } from '@server/game-server';
 import { Npc } from '@server/world/mob/npc/npc';
 import { skillDetails } from '@server/world/mob/skills';
 
-const interfaceIds = {
+const widgetIds = {
     PLAYER: [ 968, 973, 979, 986 ],
     NPC: [ 4882, 4887, 4893, 4900 ],
     OPTIONS: [ 2459, 2469, 2480, 2492 ]
@@ -94,20 +94,20 @@ export class DialogueAction {
 
         this._action = null;
 
-        let interfaceIndex = options.lines.length - 1;
+        let widgetIndex = options.lines.length - 1;
         if(options.type === 'OPTIONS') {
-            interfaceIndex--;
+            widgetIndex--;
         }
 
-        let interfaceId = -1;
+        let widgetId = -1;
 
         if(options.type === 'LEVEL_UP') {
-            interfaceId = skillDetails.map(skill => skill.advancementInterfaceId === undefined ? -1 : skill.advancementInterfaceId)[options.skillId];
+            widgetId = skillDetails.map(skill => skill.advancementWidgetId === undefined ? -1 : skill.advancementWidgetId)[options.skillId];
         } else {
-            interfaceId = interfaceIds[options.type][interfaceIndex];
+            widgetId = widgetIds[options.type][widgetIndex];
         }
 
-        if(interfaceId === undefined || interfaceId === null || interfaceId === -1) {
+        if(widgetId === undefined || widgetId === null || widgetId === -1) {
             return Promise.resolve(this);
         }
 
@@ -119,30 +119,30 @@ export class DialogueAction {
             }
 
             if(options.type === 'NPC') {
-                this.p.packetSender.setInterfaceModel2(interfaceId + 1, options.npc);
-                this.p.packetSender.updateInterfaceString(interfaceId + 2, gameCache.npcDefinitions.get(options.npc).name);
+                this.p.packetSender.setWidgetModel2(widgetId + 1, options.npc);
+                this.p.packetSender.updateWidgetString(widgetId + 2, gameCache.npcDefinitions.get(options.npc).name);
             } else if(options.type === 'PLAYER') {
-                this.p.packetSender.setInterfacePlayerHead(interfaceId + 1);
-                this.p.packetSender.updateInterfaceString(interfaceId + 2, this.p.username);
+                this.p.packetSender.setWidgetPlayerHead(widgetId + 1);
+                this.p.packetSender.updateWidgetString(widgetId + 2, this.p.username);
             }
 
-            this.p.packetSender.playInterfaceAnimation(interfaceId + 1, options.emote);
+            this.p.packetSender.playWidgetAnimation(widgetId + 1, options.emote);
             textOffset += 2;
         } else if(options.type === 'OPTIONS') {
-            this.p.packetSender.updateInterfaceString(interfaceId + 1, options.title);
+            this.p.packetSender.updateWidgetString(widgetId + 1, options.title);
             textOffset += 1;
         }
 
         for(let i = 0; i < options.lines.length; i++) {
-            this.p.packetSender.updateInterfaceString(interfaceId + textOffset + i, options.lines[i]);
+            this.p.packetSender.updateWidgetString(widgetId + textOffset + i, options.lines[i]);
         }
 
         return new Promise<DialogueAction>((resolve, reject) => {
-            this.p.activeInterface = {
-                interfaceId,
+            this.p.activeWidget = {
+                widgetId: widgetId,
                 type: 'CHAT',
                 closeOnWalk: true,
-                forceClosed: () => reject('INTERFACE_CLOSED')
+                forceClosed: () => reject('WIDGET_CLOSED')
             };
 
             this.p.dialogueInteractionEvent.subscribe(action => {
@@ -153,7 +153,7 @@ export class DialogueAction {
     }
 
     public close(): void {
-        this.p.packetSender.closeActiveInterfaces();
+        this.p.packetSender.closeActiveWidgets();
     }
 
     public get action(): number {

src/world/mob/player/action/drop-item-action.ts

@@ -1,12 +1,12 @@
 import { Player } from '../player';
 import { world } from '@server/game-server';
 import { Item } from '@server/world/items/item';
-import { interfaceIds } from '@server/world/mob/player/game-interface';
+import { widgetIds } from '@server/world/mob/player/widget';
 
 export const dropItemAction = (player: Player, item: Item, inventorySlot: number) => {
     player.inventory.remove(inventorySlot);
     // @TODO change packets to only update modified container slots
-    player.packetSender.sendUpdateAllInterfaceItems(interfaceIds.inventory, player.inventory);
+    player.packetSender.sendUpdateAllWidgetItems(widgetIds.inventory, player.inventory);
     player.packetSender.playSound(376, 7);
     world.chunkManager.spawnWorldItem(item, player.position, player, 300);
 };

src/world/mob/player/action/equip-item-action.ts

@@ -3,7 +3,7 @@ import { world } from '@server/game-server';
 import { logger } from '@runejs/logger/dist/logger';
 import { EquipmentSlot, equipmentSlotIndex, ItemDetails, WeaponType } from '@server/world/config/item-data';
 import { Item } from '@server/world/items/item';
-import { interfaceIds } from '../game-interface';
+import { widgetIds } from '../widget';
 import { ItemContainer } from '@server/world/items/item-container';
 
 export const equipItemAction = (player: Player, itemId: number, inventorySlot: number) => {
@@ -65,8 +65,8 @@ export const equipItemAction = (player: Player, itemId: number, inventorySlot: n
     }
 
     // @TODO change packets to only update modified container slots
-    player.packetSender.sendUpdateAllInterfaceItems(interfaceIds.inventory, inventory);
-    player.packetSender.sendUpdateAllInterfaceItems(interfaceIds.equipment, equipment);
+    player.packetSender.sendUpdateAllWidgetItems(widgetIds.inventory, inventory);
+    player.packetSender.sendUpdateAllWidgetItems(widgetIds.equipment, equipment);
     player.updateBonuses();
     player.updateFlags.appearanceUpdateRequired = true;
 };

src/world/mob/player/action/input-command-action.ts

@@ -90,16 +90,16 @@ const commands: { [key: string]: commandHandler } = {
 
     chati: (player: Player, args: string[]) => {
         if(args.length !== 1) {
-            throw `chati interfaceId`;
+            throw `chati widgetId`;
         }
 
-        const interfaceId: number = parseInt(args[0]);
+        const widgetId: number = parseInt(args[0]);
 
-        if(isNaN(interfaceId)) {
-            throw `chati interfaceId`;
+        if(isNaN(widgetId)) {
+            throw `chati widgetId`;
         }
 
-        player.packetSender.showChatboxInterface(interfaceId);
+        player.packetSender.showChatboxWidget(widgetId);
     },
 
     sound: (player, args) => {

src/world/mob/player/action/item-on-item-action.ts

@@ -15,8 +15,8 @@ export interface ItemOnItemActionDetails {
     usedWithItem: Item;
     usedSlot: number;
     usedWithSlot: number;
-    usedInterfaceId: number;
-    usedWithInterfaceId: number;
+    usedWidgetId: number;
+    usedWithWidgetId: number;
 }
 
 /**
@@ -42,8 +42,8 @@ export const setItemOnItemPlugins = (plugins: ItemOnItemActionPlugin[]): void =>
 };
 
 export const itemOnItemAction = (player: Player,
-                                 usedItem: Item, usedSlot: number, usedInterfaceId: number,
-                                 usedWithItem: Item, usedWithSlot: number, usedWithInterfaceId: number): void => {
+                                 usedItem: Item, usedSlot: number, usedWidgetId: number,
+                                 usedWithItem: Item, usedWithSlot: number, usedWithWidgetId: number): void => {
     // Find all item on item action plugins that match this action
     const interactionPlugins = itemOnItemInteractions.filter(plugin =>
         plugin.items.findIndex(i => i.item1 === usedItem.itemId && i.item2 === usedWithItem.itemId) !== -1 ||
@@ -58,5 +58,5 @@ export const itemOnItemAction = (player: Player,
 
     // Immediately run the plugins
     interactionPlugins.forEach(plugin => plugin.action({ player, usedItem, usedWithItem, usedSlot, usedWithSlot,
-        usedInterfaceId, usedWithInterfaceId }));
+        usedWidgetId: usedWidgetId, usedWithWidgetId: usedWithWidgetId }));
 };

src/world/mob/player/action/swap-item-action.ts

@@ -1,8 +1,8 @@
 import { Player } from '../player';
-import { interfaceIds } from '../game-interface';
+import { widgetIds } from '../widget';
 
-export const swapItemAction = (player: Player, fromSlot: number, toSlot: number, interfaceId: number) => {
-    if(interfaceId === interfaceIds.inventory) {
+export const swapItemAction = (player: Player, fromSlot: number, toSlot: number, widgetId: number) => {
+    if(widgetId === widgetIds.inventory) {
         const inventory = player.inventory;
 
         if(toSlot > inventory.size - 1 || fromSlot > inventory.size - 1) {

src/world/mob/player/action/unequip-item-action.ts

@@ -1,6 +1,6 @@
 import { Player } from '../player';
 import { Item } from '@server/world/items/item';
-import { interfaceIds } from '../game-interface';
+import { widgetIds } from '../widget';
 
 export const unequipItemAction = (player: Player, itemId: number, equipmentSlot: number) => {
     const inventory = player.inventory;
@@ -18,8 +18,8 @@ export const unequipItemAction = (player: Player, itemId: number, equipmentSlot:
         equipment.remove(equipmentSlot);
         inventory.set(inventorySlot, itemInEquipmentSlot);
 
-        player.packetSender.sendUpdateSingleInterfaceItem(interfaceIds.inventory, inventorySlot, itemInEquipmentSlot);
-        player.packetSender.sendUpdateSingleInterfaceItem(interfaceIds.equipment, equipmentSlot, null);
+        player.packetSender.sendUpdateSingleWidgetItem(widgetIds.inventory, inventorySlot, itemInEquipmentSlot);
+        player.packetSender.sendUpdateSingleWidgetItem(widgetIds.equipment, equipmentSlot, null);
         player.updateBonuses();
         player.updateFlags.appearanceUpdateRequired = true;
     }