🆙 added latest changes

packages/room/src/object/RoomMapData.ts

@@ -7,7 +7,7 @@ export class RoomMapData implements IRoomMapData
     private _wallHeight: number;
     private _fixedWallsHeight: number;
     private _tileMap: { height: number }[][];
-    private _holeMap: { id: number, x: number, y: number, width: number, height: number }[];
+    private _holeMap: { id: number, x: number, y: number, width: number, height: number, invert: boolean }[];
     private _doors: { x: number, y: number, z: number, dir: number }[];
     private _dimensions: { minX: number, maxX: number, minY: number, maxY: number };
 
@@ -73,7 +73,7 @@ export class RoomMapData implements IRoomMapData
         return this._tileMap;
     }
 
-    public get holeMap(): { id: number, x: number, y: number, width: number, height: number }[]
+    public get holeMap(): { id: number, x: number, y: number, width: number, height: number, invert: boolean }[]
     {
         return this._holeMap;
     }

packages/room/src/object/RoomObjectModel.ts

@@ -26,7 +26,7 @@ export class RoomObjectModel implements IRoomObjectModel
             if(this._map.get(key) === value) return;
         }
 
-        this._map.set(key, (value as T));
+        this._map.set(key, value);
 
         this._updateCounter++;
     }

packages/room/src/object/logic/RoomLogic.ts

@@ -413,12 +413,14 @@ export class RoomLogic extends RoomObjectLogicBase
         let eventType: string = null;
 
         if((event.type === MouseEventType.MOUSE_MOVE) || (event.type === MouseEventType.ROLL_OVER)) eventType = RoomObjectMouseEvent.MOUSE_MOVE;
-        else if((event.type === MouseEventType.MOUSE_CLICK)) eventType = RoomObjectMouseEvent.CLICK;
+        else if(event.type === MouseEventType.MOUSE_CLICK) eventType = RoomObjectMouseEvent.CLICK;
+        else if(event.type === MouseEventType.MOUSE_DOWN) eventType = RoomObjectMouseEvent.MOUSE_DOWN;
 
         switch(event.type)
         {
             case MouseEventType.MOUSE_MOVE:
             case MouseEventType.ROLL_OVER:
+            case MouseEventType.MOUSE_DOWN:
             case MouseEventType.MOUSE_CLICK: {
                 let newEvent: RoomObjectEvent = null;
 

packages/room/src/object/logic/furniture/FurnitureAreaHideLogic.ts

@@ -0,0 +1,96 @@
+import { IRoomGeometry, MouseEventType, NumberDataType, RoomObjectVariable } from '@nitrots/api';
+import { RoomObjectEvent, RoomObjectStateChangedEvent, RoomObjectWidgetRequestEvent, RoomSpriteMouseEvent } from '@nitrots/events';
+import { ObjectDataUpdateMessage, RoomObjectUpdateMessage } from '../../../messages';
+import { FurnitureMultiStateLogic } from './FurnitureMultiStateLogic';
+
+export class FurnitureAreaHideLogic extends FurnitureMultiStateLogic
+{
+    public getEventTypes(): string[]
+    {
+        const types = [RoomObjectWidgetRequestEvent.AREA_HIDE];
+
+        return this.mergeTypes(super.getEventTypes(), types);
+    }
+
+    public processUpdateMessage(message: RoomObjectUpdateMessage): void
+    {
+        super.processUpdateMessage(message);
+
+        if(!this.object) return;
+
+        if(message instanceof ObjectDataUpdateMessage)
+        {
+            message.data.writeRoomObjectModel(this.object.model);
+
+            if(this.object.model.getValue<number>(RoomObjectVariable.FURNITURE_REAL_ROOM_OBJECT) === 1)
+            {
+                this.setupObject();
+            }
+        }
+    }
+
+    private setupObject(): void
+    {
+        if(!this.object || !this.object.model) return;
+
+        const numberData = new NumberDataType();
+
+        numberData.initializeFromRoomObjectModel(this.object.model);
+
+        const state = numberData.getValue(0);
+        const rootX = numberData.getValue(1);
+        const rootY = numberData.getValue(2);
+        const width = numberData.getValue(3);
+        const length = numberData.getValue(4);
+        const invisibility = (numberData.getValue(5) === 1);
+        const wallItems = (numberData.getValue(6) === 1);
+        const invert = (numberData.getValue(7) === 1);
+
+        this.object.model.setValue(RoomObjectVariable.FURNITURE_AREA_HIDE_ROOT_X, rootX);
+        this.object.model.setValue(RoomObjectVariable.FURNITURE_AREA_HIDE_ROOT_Y, rootY);
+        this.object.model.setValue(RoomObjectVariable.FURNITURE_AREA_HIDE_WIDTH, width);
+        this.object.model.setValue(RoomObjectVariable.FURNITURE_AREA_HIDE_LENGTH, length);
+        this.object.model.setValue(RoomObjectVariable.FURNITURE_AREA_HIDE_INVISIBILITY, ((invisibility) ? 1 : 0));
+        this.object.model.setValue(RoomObjectVariable.FURNITURE_AREA_HIDE_WALL_ITEMS, ((wallItems) ? 1 : 0));
+        this.object.model.setValue(RoomObjectVariable.FURNITURE_AREA_HIDE_INVERT, ((invert) ? 1 : 0));
+        this.object.setState(state, 0);
+    }
+
+    public useObject(): void
+    {
+        if(!this.object || !this.eventDispatcher) return;
+
+        this.eventDispatcher.dispatchEvent(new RoomObjectWidgetRequestEvent(RoomObjectWidgetRequestEvent.AREA_HIDE, this.object));
+    }
+
+    public mouseEvent(event: RoomSpriteMouseEvent, geometry: IRoomGeometry): void
+    {
+        if(!event || !geometry || !this.object) return;
+
+        let objectEvent: RoomObjectEvent = null;
+
+        switch(event.type)
+        {
+            case MouseEventType.DOUBLE_CLICK: {
+                if((event.spriteTag === 'turn_on') || (event.spriteTag === 'turn_off'))
+                {
+                    objectEvent = new RoomObjectStateChangedEvent(RoomObjectStateChangedEvent.STATE_CHANGE, this.object);
+                }
+                else
+                {
+                    objectEvent = new RoomObjectWidgetRequestEvent(RoomObjectWidgetRequestEvent.AREA_HIDE, this.object);
+                }
+
+                if(this.eventDispatcher && objectEvent)
+                {
+                    this.eventDispatcher.dispatchEvent(objectEvent);
+
+                    return;
+                }
+                break;
+            }
+        }
+
+        super.mouseEvent(event, geometry);
+    }
+}

packages/room/src/object/logic/furniture/index.ts

@@ -1,4 +1,5 @@
 export * from './FurnitureAchievementResolutionLogic';
+export * from './FurnitureAreaHideLogic';
 export * from './FurnitureBadgeDisplayLogic';
 export * from './FurnitureChangeStateWhenStepOnLogic';
 export * from './FurnitureClothingChangeLogic';

packages/room/src/object/visualization/RoomObjectSprite.ts

@@ -26,6 +26,7 @@ export class RoomObjectSprite implements IRoomObjectSprite
     private _varyingDepth: boolean = false;
     private _libraryAssetName: string = '';
     private _clickHandling: boolean = false;
+    private _skipMouseHandling: boolean = false;
     private _visible: boolean = true;
     private _tag: string = '';
     private _posture: string = null;
@@ -352,4 +353,14 @@ export class RoomObjectSprite implements IRoomObjectSprite
     {
         return this._updateCounter;
     }
+
+    public get skipMouseHandling(): boolean
+    {
+        return this._skipMouseHandling;
+    }
+
+    public set skipMouseHandling(flag: boolean)
+    {
+        this._skipMouseHandling = flag;
+    }
 }

packages/room/src/object/visualization/data/PetSizeData.ts

@@ -8,7 +8,7 @@ export class PetSizeData extends AnimationSizeData
     private _posturesToAnimations: Map<string, number> = new Map();
     private _gesturesToAnimations: Map<string, number> = new Map();
     private _defaultPosture: string = null;
-    
+
     public processPostures(postures: { defaultPosture?: string, postures: IAssetPosture[] }): boolean
     {
         if(!postures) return false;

packages/room/src/object/visualization/data/SizeData.ts

@@ -235,7 +235,7 @@ export class SizeData
 
     public getLayerColor(layerId: number, colorId: number): number
     {
-        const existing = this._colors[colorId] as ColorData;
+        const existing = this._colors[colorId];
 
         if(!existing) return ColorData.DEFAULT_COLOR;
 

packages/room/src/object/visualization/furniture/FurnitureFireworksVisualization.ts

@@ -40,6 +40,8 @@ export class FurnitureFireworksVisualization extends FurnitureAnimatedVisualizat
                 {
                     const particleSystem = this._particleSystems.getValue(scale);
 
+                    if(!particleSystem) return false;
+
                     particleSystem.copyStateFrom(this._currentParticleSystem);
 
                     if(this._currentParticleSystem) this._currentParticleSystem.reset();

packages/room/src/object/visualization/furniture/FurnitureVisualization.ts

@@ -1,5 +1,5 @@
 import { AlphaTolerance, IGraphicAsset, IObjectVisualizationData, IRoomGeometry, IRoomObjectSprite, RoomObjectVariable, RoomObjectVisualizationType } from '@nitrots/api';
-import { BLEND_MODES, Texture } from 'pixi.js';
+import { BLEND_MODES, Filter, Texture } from 'pixi.js';
 import { RoomObjectSpriteVisualization } from '../RoomObjectSpriteVisualization';
 import { ColorData, LayerData } from '../data';
 import { FurnitureVisualizationData } from './FurnitureVisualizationData';
@@ -38,8 +38,11 @@ export class FurnitureVisualization extends RoomObjectSpriteVisualization
     protected _spriteXOffsets: number[];
     protected _spriteYOffsets: number[];
     protected _spriteZOffsets: number[];
+    protected _filters: Filter[] = [];
 
     private _animationNumber: number;
+    private _lookThrough: boolean;
+    private _needsLookThroughUpdate: boolean;
 
     constructor()
     {
@@ -75,6 +78,7 @@ export class FurnitureVisualization extends RoomObjectSpriteVisualization
         this._spriteZOffsets = [];
 
         this._animationNumber = 0;
+        this._lookThrough = false;
     }
 
     public initialize(data: IObjectVisualizationData): boolean
@@ -104,6 +108,7 @@ export class FurnitureVisualization extends RoomObjectSpriteVisualization
         this._spriteXOffsets = null;
         this._spriteYOffsets = null;
         this._spriteZOffsets = null;
+        this._filters = [];
     }
 
     protected reset(): void
@@ -160,6 +165,12 @@ export class FurnitureVisualization extends RoomObjectSpriteVisualization
 
         if(this.updateModel(scale)) updateSprites = true;
 
+        if(this._needsLookThroughUpdate)
+        {
+            updateSprites = true;
+            this._needsLookThroughUpdate = false;
+        }
+
         let number = 0;
 
         if(skipUpdate)
@@ -313,11 +324,15 @@ export class FurnitureVisualization extends RoomObjectSpriteVisualization
                     relativeDepth = 1;
                 }
 
+                if(this._lookThrough) sprite.alpha *= 0.2;
+
                 sprite.relativeDepth = (relativeDepth * FurnitureVisualization.DEPTH_MULTIPLIER);
                 sprite.name = assetName;
                 sprite.libraryAssetName = this.getLibraryAssetNameForSprite(assetData, sprite);
                 sprite.posture = this.getPostureForAsset(scale, assetData.source);
                 sprite.clickHandling = this._clickHandling;
+
+                if(sprite.blendMode !== 'add') sprite.filters = this._filters;
             }
             else
             {
@@ -582,6 +597,14 @@ export class FurnitureVisualization extends RoomObjectSpriteVisualization
         return asset?.texture ?? null;
     }
 
+    public set lookThrough(flag: boolean)
+    {
+        if(this._lookThrough == flag) return;
+
+        this._lookThrough = flag;
+        this._needsLookThroughUpdate = true;
+    }
+
     protected get direction(): number
     {
         return this._direction;

packages/room/src/object/visualization/furniture/FurnitureVisualizationData.ts

@@ -70,7 +70,7 @@ export class FurnitureVisualizationData implements IObjectVisualizationData
     {
         if(!visualizations) return false;
 
-        for(const visualizationId in visualizations)
+        for(const visualizationId of Object.keys(visualizations))
         {
             const visualization = visualizations[visualizationId];
 

packages/room/src/object/visualization/room/RoomPlane.ts

@@ -50,6 +50,8 @@ export class RoomPlane implements IRoomPlane
     private _hasTexture: boolean = true;
     private _canBeVisible: boolean = true;
     private _geometryUpdateId: number = -1;
+    private _extraDepth: number = 0;
+    private _isHighlighter: boolean = false;
 
     private _useMask: boolean;
     private _bitmapMasks: RoomPlaneBitmapMask[] = [];
@@ -569,7 +571,12 @@ export class RoomPlane implements IRoomPlane
 
     public get relativeDepth(): number
     {
-        return this._relativeDepth;
+        return (this._relativeDepth + this._extraDepth);
+    }
+
+    public set extraDepth(value: number)
+    {
+        this._extraDepth = value;
     }
 
     public get color(): number
@@ -633,4 +640,14 @@ export class RoomPlane implements IRoomPlane
     {
         this._hasTexture = flag;
     }
+
+    public get isHighlighter(): boolean
+    {
+        return this._isHighlighter;
+    }
+
+    public set isHighlighter(flag: boolean)
+    {
+        this._isHighlighter = flag;
+    }
 }

packages/room/src/object/visualization/room/RoomVisualization.ts

@@ -1,6 +1,6 @@
+import { AlphaTolerance, IObjectVisualizationData, IPlaneVisualization, IRoomGeometry, IRoomObjectModel, IRoomObjectSprite, IRoomPlane, RoomObjectSpriteType, RoomObjectVariable } from '@nitrots/api';
 import { ToInt32, Vector3d } from '@nitrots/utils';
-import { Rectangle, Texture } from 'pixi.js';
-import { AlphaTolerance, IObjectVisualizationData, IPlaneVisualization, IRoomGeometry, IRoomObjectModel, IRoomObjectSprite, IRoomPlane, RoomObjectSpriteType, RoomObjectVariable } from '../../../../../api';
+import { Filter, Rectangle, Texture } from 'pixi.js';
 import { RoomMapData } from '../../RoomMapData';
 import { RoomMapMaskData } from '../../RoomMapMaskData';
 import { RoomPlaneBitmapMaskData } from '../../RoomPlaneBitmapMaskData';
@@ -13,16 +13,16 @@ import { RoomVisualizationData } from './RoomVisualizationData';
 
 export class RoomVisualization extends RoomObjectSpriteVisualization implements IPlaneVisualization
 {
-    public static FLOOR_COLOR: number = 0xFFFFFF;
-    public static FLOOR_COLOR_LEFT: number = 0xDDDDDD;
-    public static FLOOR_COLOR_RIGHT: number = 0xBBBBBB;
+    private static FLOOR_COLOR: number = 0xFFFFFF;
+    private static FLOOR_COLOR_LEFT: number = 0xDDDDDD;
+    private static FLOOR_COLOR_RIGHT: number = 0xBBBBBB;
     private static WALL_COLOR_TOP: number = 0xFFFFFF;
     private static WALL_COLOR_SIDE: number = 0xCCCCCC;
     private static WALL_COLOR_BOTTOM: number = 0x999999;
     private static WALL_COLOR_BORDER: number = 0x999999;
-    public static LANDSCAPE_COLOR_TOP: number = 0xFFFFFF;
-    public static LANDSCAPE_COLOR_SIDE: number = 0xCCCCCC;
-    public static LANDSCAPE_COLOR_BOTTOM: number = 0x999999;
+    private static LANDSCAPE_COLOR_TOP: number = 0xFFFFFF;
+    private static LANDSCAPE_COLOR_SIDE: number = 0xCCCCCC;
+    private static LANDSCAPE_COLOR_BOTTOM: number = 0x999999;
     private static ROOM_DEPTH_OFFSET: number = 1000;
 
     protected _data: RoomVisualizationData = null;
@@ -54,6 +54,13 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
     private _maskData: RoomMapMaskData = null;
     private _isPlaneSet: boolean = false;
 
+    private _highlightAreaX: number = 0;
+    private _highlightAreaY: number = 0;
+    private _highlightAreaWidth: number = 0;
+    private _highlightAreaHeight: number = 0;
+    private _highlightFilter: Filter = null;
+    private _highlightPlaneOffsets: number[] = [];
+
     constructor()
     {
         super();
@@ -86,6 +93,7 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
         this._planes = null;
         this._visiblePlanes = null;
         this._visiblePlaneSpriteNumbers = null;
+        this._highlightPlaneOffsets = [];
 
         if(this._roomPlaneParser)
         {
@@ -321,6 +329,7 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
             }
 
             this._planes = [];
+            this._highlightPlaneOffsets = [];
         }
 
         this._isPlaneSet = false;
@@ -336,19 +345,29 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
         if(!isNaN(this._floorThickness)) this._roomPlaneParser.floorThicknessMultiplier = this._floorThickness;
         if(!isNaN(this._wallThickness)) this._roomPlaneParser.wallThicknessMultiplier = this._wallThickness;
 
+        this._roomPlaneParser.clearHighlightArea();
+
         const mapData = this.object.model.getValue<RoomMapData>(RoomObjectVariable.ROOM_MAP_DATA);
 
         if(!this._roomPlaneParser.initializeFromMapData(mapData)) return;
 
+        this._roomPlaneParser.initializeHighlightArea(this._highlightAreaX, this._highlightAreaY, this._highlightAreaWidth, this._highlightAreaHeight);
+
+        this.createPlanesAndSprites();
+    }
+
+    private createPlanesAndSprites(offset: number = 0): void
+    {
         const maxX = this.getLandscapeWidth();
         const maxY = this.getLandscapeHeight();
 
         let landscapeOffsetX = 0;
         let randomSeed = this.object.model.getValue<number>(RoomObjectVariable.ROOM_RANDOM_SEED);
-        let index = 0;
+        let index = offset;
 
         while(index < this._roomPlaneParser.planeCount)
         {
+            this._highlightPlaneOffsets[index] = -1;
             const location = this._roomPlaneParser.getPlaneLocation(index);
             const leftSide = this._roomPlaneParser.getPlaneLeftSide(index);
             const rightSide = this._roomPlaneParser.getPlaneRightSide(index);
@@ -414,6 +433,7 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
                         i++;
                     }
 
+                    this._highlightPlaneOffsets[index] = this._planes.length;
                     this._planes.push(plane);
                 }
             }
@@ -429,6 +449,53 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
         this.defineSprites();
     }
 
+    public initializeHighlightArea(highlightAreaX: number, highlightAreaY: number, highlightAreaWidth: number, highlightAreaHeight: number, highlightFilter: Filter): void
+    {
+        this.clearHighlightArea();
+
+        this._highlightAreaX = highlightAreaX;
+        this._highlightAreaY = highlightAreaY;
+        this._highlightAreaWidth = highlightAreaWidth;
+        this._highlightAreaHeight = highlightAreaHeight;
+        this._highlightFilter = highlightFilter;
+
+        this._roomPlaneParser.initializeHighlightArea(highlightAreaX, highlightAreaY, highlightAreaWidth, highlightAreaHeight);
+
+        this.createPlanesAndSprites(this._planes.length);
+        this.reset();
+    }
+
+    public clearHighlightArea(): void
+    {
+        this._highlightAreaX = 0;
+        this._highlightAreaY = 0;
+        this._highlightAreaWidth = 0;
+        this._highlightAreaHeight = 0;
+
+        const totalHighlightedPlanes = this._roomPlaneParser.clearHighlightArea();
+        let _local_4 = 0;
+
+        let _local_1 = this._roomPlaneParser.planeCount;
+
+        while(_local_1 < (this._roomPlaneParser.planeCount + totalHighlightedPlanes))
+        {
+            const _local_2 = this._highlightPlaneOffsets[_local_1];
+
+            if(_local_2 !== -1)
+            {
+                _local_4 = (_local_4 + 1);
+                this._highlightPlaneOffsets[_local_1] = -1;
+            };
+
+            _local_1 = (_local_1 + 1);
+        };
+
+        this._planes = this._planes.slice(0, (this._planes.length - _local_4));
+        this.createSprites(this._planes.length);
+
+        this.reset();
+    }
+
     protected defineSprites(): void
     {
         this.createSprites(this._planes.length);
@@ -467,6 +534,22 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
                 }
 
                 sprite.spriteType = RoomObjectSpriteType.ROOM_PLANE;
+
+                if(this._roomPlaneParser.isPlaneTemporaryHighlighter(planeIndex))
+                {
+                    if(this._highlightFilter) sprite.filters = [ this._highlightFilter ];
+
+                    sprite.skipMouseHandling = true;
+                    plane.extraDepth = -100;
+                    plane.isHighlighter = true;
+                }
+                else
+                {
+                    sprite.filters = [];
+                    sprite.skipMouseHandling = false;
+                    plane.extraDepth = 0;
+                    plane.isHighlighter = false;
+                }
             }
 
             planeIndex++;