public TDCSwitchRecalculateTagAI(TDCSwitch mSwitchComponent, TDCRecalculateSprites mRecalculateComponent, string mOffTag, string mOnTag)
 {
     _switchComponent = mSwitchComponent;
     _recalculateComponent = mRecalculateComponent;
     OffTag = mOffTag;
     OnTag = mOnTag;
 }
Example #2
0
        public TDCDoor(DoorType mDoorType, bool mIsOff, TDGGame mGame, TDCSwitch mSwitchComponent, TDCRecalculateSprites mRecalculateSprites)
        {
            _doorType = mDoorType;

            _game = mGame;
            _isOff = mIsOff;

            _switchComponent = mSwitchComponent;
            _recalculateSpritesComponent = mRecalculateSprites;

            _switchComponent.OnTurnOff += SetRecalculationNeeded;
            _switchComponent.OnTurnOn += SetRecalculationNeeded;
        }
Example #3
0
        public static Entity BlueDoor(bool mIsOff = false)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Door};

            var cRender = TDLComponentFactory.Render(@"environment\door\blue\closed", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.DoorClosed, TDLRecalculations.RecalculateDoorSprite);
            var cSwitch = TDLComponentFactory.SwitchTexture(cRender, mIsOff, @"environment\door\blue\open", @"environment\door\blue\closed");
            cSwitch.OnlyOffTags.Add(TDLTags.BlueDoorOpen);
            cSwitch.OnlyOnTags.AddRange(new[] {TDLTags.BlueDoorClosed, TDLTags.Solid, TDLTags.GroundPathmapObstacle});
            var cSwitchRecalculateTagAI = new TDCSwitchRecalculateTagAI(cSwitch, cRecalculateSprites, TDLTags.BlueDoorOpen, TDLTags.BlueDoorClosed);
            var cDoor = new TDCDoor(TDCDoor.DoorType.Blue, mIsOff, Game, cSwitch, cRecalculateSprites);

            result.AddTags(TDLTags.BlueDoor);
            result.AddComponents(cRender, cSwitch, cSwitchRecalculateTagAI, cRecalculateSprites, cDoor);

            return result;
        }
Example #4
0
 public static void TryRecalculation(ref bool mRecalculationNeeded, TDCRecalculateSprites mRecalculateComponent)
 {
     if (!mRecalculationNeeded) return;
     mRecalculateComponent.RecalculateNearbySprites();
     mRecalculationNeeded = false;
 }
Example #5
0
        public static Entity Water()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Pit};

            var cRender = TDLComponentFactory.Render(@"environment\water", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.Water, TDLRecalculations.RecalculateDoorSprite);

            result.AddTags(TDLTags.Solid, TDLTags.Water, TDLTags.GroundPathmapObstacle);
            result.AddComponents(cRender, cRecalculateSprites);

            return result;
        }
Example #6
0
        public static Entity Wall(bool mIsBroken = false)
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Wall};

            var cRender = TDLComponentFactory.Render(@"environment\wall\purple", "walltiles", "single");
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.Break);
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.Wall, TDLRecalculations.RecalculateWallSprite);

            result.AddTags(TDLTags.Solid, TDLTags.Wall, TDLTags.HitByWeapon, TDLTags.GroundPathmapObstacle);
            result.AddComponents(cRender, cRecalculateSprites);
            if (mIsBroken)
            {
                TDLMethods.AttachBrokenOverlay(cRender);
                result.AddComponents(cHitByWeapon);
            }

            return result;
        }
Example #7
0
        public static Entity Oremites()
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"environment\oremites", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.Oremites, TDLRecalculations.RecalculateDoorSprite);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Oremites);
            var cOremites = new TDCOremites(cSpecialSquare);

            result.AddTags(TDLTags.Oremites);
            result.AddComponents(cRender, cSpecialSquare, cOremites, cRecalculateSprites);

            return result;
        }
Example #8
0
        public static Entity HotTile(int mTurnsToBurn = 2)
        {
            var result = new Entity(Tile) {UpdateOrder = TDLOrders.Trapdoor, Layer = TDLLayers.Trapdoor};

            var cRender = TDLComponentFactory.Render(@"environment\hottile", "doortiles", "single");
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.HotTile, TDLRecalculations.RecalculateDoorSprite);
            var cSpecialSquare = new TDCSpecialSquare(TDLPriorities.Trapdoor);
            var cHotTile = new TDCHotTile(cSpecialSquare, mTurnsToBurn);

            result.AddTags(TDLTags.HotTile);
            result.AddComponents(cRender, cSpecialSquare, cRecalculateSprites, cHotTile);

            return result;
        }
Example #9
0
        public static Entity Door(bool mIsBroken = false, bool mIsOff = false, List<int> mIDs = default(List<int>))
        {
            var result = new Entity(Tile) {Layer = TDLLayers.Door};

            var cRender = TDLComponentFactory.Render(@"environment\door\yellow\closed", "doortiles", "single");
            var cSwitch = TDLComponentFactory.SwitchTexture(cRender, mIsOff, @"environment\door\yellow\open", @"environment\door\yellow\closed");
            cSwitch.OnlyOffTags.Add(TDLTags.DoorOpen);
            cSwitch.OnlyOnTags.AddRange(new[] {TDLTags.DoorClosed, TDLTags.Solid, TDLTags.GroundPathmapObstacle});
            var cHitByWeapon = new TDCHitByWeapon(TDCHitByWeapon.HitActions.BreakIfOff);
            var cID = TDLComponentFactory.ID(mIDs);
            var cRecalculateSprites = new TDCRecalculateSprites(TDLTags.DoorClosed, TDLRecalculations.RecalculateDoorSprite, cID.SameIDsCondition);
            var cIDSwitchAI = new TDCIDSwitchAI(cSwitch, cID);
            var cSwitchRecalculateTagAI = new TDCSwitchRecalculateTagAI(cSwitch, cRecalculateSprites, TDLTags.DoorOpen, TDLTags.DoorClosed);
            var cDoor = new TDCDoor(TDCDoor.DoorType.Yellow, mIsOff, Game, cSwitch, cRecalculateSprites);

            result.AddTags(TDLTags.Door, TDLTags.HitByWeapon);
            result.AddComponents(cRender, cID, cSwitch, cSwitchRecalculateTagAI, cRecalculateSprites,
                                 cIDSwitchAI, cDoor);
            if (mIsBroken)
            {
                result.AddComponents(cHitByWeapon);
                TDLMethods.AttachBrokenOverlay(cRender);
            }

            return result;
        }