예제 #1
0
        public void Reload(BasicMap m, GameContentDataBase gcdb)
        {
            buildingCompleteRender = new RenderTarget2D(Game1.graphics.GraphicsDevice, boundingZone.Height * 3, boundingZone.Height);
            buildingRender         = new RenderTarget2D(Game1.graphics.GraphicsDevice, boundingZone.Width, boundingZone.Height);


            int layer = 0;

            //location.Y *= -1;
            foreach (var item in buildingTilesPositions)
            {
                buildingTiles.Add(new List <BasicTile>());
                foreach (var position in item)
                {
                    // var chunk = m.testChunk[layer].Find(kv => kv.Key.Contains(position * 64 + location));
                    var       chunk    = m.Chunks.Find(c => c.region.Contains(position * 64 + location));
                    BasicTile tempTIle = chunk.returnLayer(layer).Find(tile => tile.positionGrid == position + location / 64);
                    tempTIle.Reload(gcdb);
                    tempTIle = tempTIle.BClone();
                    tempTIle.positionGrid = position;
                    tempTIle.BReload();
                    buildingTiles[layer].Add(tempTIle);
                }
                layer++;
            }
        }
예제 #2
0
        static public List <BasicTile> returnMapRadius(int r, List <BasicTile> bt, Vector2 bs)
        {
            Point            loc       = ((bs / 64).ToPoint().ToVector2() * 64).ToPoint();
            List <Rectangle> temp      = new List <Rectangle>();
            List <BasicTile> tempTiles = new List <BasicTile>();

            for (int i = 0; i < r + 1; i++)
            {
                for (int j = -(r - i); j < (r - i) + 1; j++)
                {
                    temp.Add(new Rectangle(loc.X + i * 64, loc.Y + j * 64, 64, 64));
                }
            }

            for (int i = -r; i != 0; i++)
            {
                for (int j = -(i + r); j < i + r + 1; j++)
                {
                    temp.Add(new Rectangle(loc.X + i * 64, loc.Y + j * 64, 64, 64));
                }
            }

            foreach (var item in temp)
            {
                BasicTile tempTile = bt.Find(t => t.mapPosition == item);
                if (tempTile != null)
                {
                    tempTiles.Add(tempTile);
                }
            }

            return(tempTiles);
        }
        public void FinalizeEnemyRound()
        {
            currentEnemy.character.attackedAsAI = false;
            BattleGUI.End();
            bTest    = false;
            AITarget = null;
            AIbtba   = default(KeyValuePair <BasicTile, BasicAbility>);
            currentEnemy.character.attackedAsAI = false;
            currentEnemy.bIsCompleted           = true;
            //var MaxAP = currentEnemy.character.trueSTATChart().currentPassiveStats[(int)STATChart.PASSIVESTATS.AP];
            //BasicTile finalTile = currentEnemy.returnCompleteArea().Find(t => t.mapPosition.Location == PathMoveHandler.finalPos.ToPoint());
            //var expendedAP = currentEnemy.characterArea.IndexOf(currentEnemy.characterArea.Find(area => area.Contains(finalTile))) + 1;
            //currentEnemy.character.statChart.currentActiveStats[(int)STATChart.ACTIVESTATS.STORED_AP] += MaxAP - expendedAP;

            if (currentEnemy.character.bSaveAP || true)
            {
                var       MaxAP      = currentEnemy.character.trueSTATChart().currentPassiveStats[(int)STATChart.PASSIVESTATS.AP];
                BasicTile finalTile  = currentEnemy.returnCompleteArea().Find(t => t.mapPosition.Location == PathMoveHandler.finalPos.ToPoint());
                var       expendedAP = currentEnemy.characterArea.IndexOf(currentEnemy.characterArea.Find(area => area.Contains(finalTile))) + 1;
                currentEnemy.character.statChart.currentActiveStats[(int)STATChart.ACTIVESTATS.STORED_AP] += MaxAP - expendedAP;
            }

            if (currentEnemy.character.bAIExecuteDefend)
            {
                BattleGUI.DefendOption(currentEnemy.character, currentEnemy.character);
            }

            //   Console.WriteLine(currentEnemy.character.statChart.currentActiveStats[(int)STATChart.ACTIVESTATS.STORED_AP]);
            BattleScriptHandler.Execute(LUA.LuaBScriptEvent.EventType.postCT, this.toLuaTurnSetInfo());
            TBAGW.EncounterInfo.currentTurn().bPlayerTurnEnemyOverriden = false; //This line must always be after the Execute line

            EncounterInfo.ClearDeathChars();
            EncounterInfo.UpdateAllStats();
        }
        public int TileDistance(BasicTile other)
        {
            int deltaX = (int)(other.positionGrid.X - positionGrid.X);
            int deltaY = (int)(other.positionGrid.Y - positionGrid.Y);

            return(Math.Abs(deltaX) + Math.Abs(deltaY));
        }
예제 #5
0
 static internal bool bShouldRecheck(BasicTile t)
 {
     bMustDraw = true;
     if (lastCheckedTile == null || t.mapPosition != lastCheckedTile.mapPosition)
     {
         return(true);
     }
     return(false);
 }
        public static List <Building> Generate(BasicMap bm)
        {
            var test = AnyBuildingTilesLeft(bm, new List <BasicTile>());

            bool bHasBuildingTile = test.Key;

            if (!test.Key)
            {
                return(new List <Building>());
            }

            List <Building> final = new List <Building>();

            List <BasicTile>         allBuildingTiles = FindBuildingTiles(bm);
            List <List <BasicTile> > groupedTiles     = new List <List <BasicTile> >();

            if (allBuildingTiles.Count > 1)
            {
                groupedTiles = GroupProximityTiles(allBuildingTiles);
            }
            else
            {
                groupedTiles.Add(new List <BasicTile>());
                groupedTiles[0].Add(allBuildingTiles[0]);
            }

            int index = 0;

            foreach (var group in groupedTiles)
            {
                final.Add(new Building());
                float   firstX   = group.Min(t => t.positionGrid.X);
                float   firstY   = group.Min(t => t.positionGrid.Y);
                Vector2 firstPos = new Vector2(firstX, firstY);
                final[index].location = firstPos * 64;
                var temp  = group.OrderBy(t => t.tileLayer).Select(tile => tile.tileLayer).Distinct();
                int layer = 0;
                foreach (var item in temp)
                {
                    final[index].buildingTiles.Add(new List <BasicTile>());
                    foreach (var t in group.FindAll(tile => tile.tileLayer == item))
                    {
                        BasicTile tempTIle = t.BClone();
                        tempTIle.positionGrid -= firstPos;
                        final[index].buildingTiles[layer].Add(tempTIle);
                    }

                    layer++;
                }
                index++;
            }

            final.ForEach(b => b.Generate());

            return(final);
        }
예제 #7
0
 static internal void Start(BasicTile t, CharacterTurn ct)
 {
     if (bMustInitialize)
     {
         Initialize();
     }
     lai.Clear();
     CalculatePossiblePath(ct);
     lastCheckedTile = t;
 }
예제 #8
0
        static public List <SpotNode> returnURDL(List <SpotNode> openNodes, List <SpotNode> closedNodes, List <BasicTile> tiles, SpotNode selectedNode)
        {
            BasicTile       tileAbove = tiles.Find(t => t.mapPosition.Location == new Point(selectedNode.nodeLoc.X, selectedNode.nodeLoc.Y - 64));
            BasicTile       tileBelow = tiles.Find(t => t.mapPosition.Location == new Point(selectedNode.nodeLoc.X, selectedNode.nodeLoc.Y + 64));
            BasicTile       tileLeft  = tiles.Find(t => t.mapPosition.Location == new Point(selectedNode.nodeLoc.X - 64, selectedNode.nodeLoc.Y));
            BasicTile       tileRight = tiles.Find(t => t.mapPosition.Location == new Point(selectedNode.nodeLoc.X + 64, selectedNode.nodeLoc.Y));
            List <SpotNode> temp      = new List <SpotNode>();

            if (tileAbove != null)
            {
                temp.Add(new SpotNode(selectedNode.NodeCost + 1, new Point(selectedNode.nodeLoc.X, selectedNode.nodeLoc.Y - 64)));
                var temp1 = openNodes.Find(on => on.nodeLoc == tileAbove.mapPosition.Location);
                var temp2 = closedNodes.Find(on => on.nodeLoc == tileAbove.mapPosition.Location);
                if (temp1 != null || temp2 != null)
                {
                    temp.RemoveAt(temp.Count - 1);
                }
            }

            if (tileBelow != null)
            {
                temp.Add(new SpotNode(selectedNode.NodeCost + 1, new Point(selectedNode.nodeLoc.X, selectedNode.nodeLoc.Y + 64)));
                var temp1 = openNodes.Find(on => on.nodeLoc == tileBelow.mapPosition.Location);
                var temp2 = closedNodes.Find(on => on.nodeLoc == tileBelow.mapPosition.Location);
                if (temp1 != null || temp2 != null)
                {
                    temp.RemoveAt(temp.Count - 1);
                }
            }

            if (tileLeft != null)
            {
                temp.Add(new SpotNode(selectedNode.NodeCost + 1, new Point(selectedNode.nodeLoc.X - 64, selectedNode.nodeLoc.Y)));
                var temp1 = openNodes.Find(on => on.nodeLoc == tileLeft.mapPosition.Location);
                var temp2 = closedNodes.Find(on => on.nodeLoc == tileLeft.mapPosition.Location);
                if (temp1 != null || temp2 != null)
                {
                    temp.RemoveAt(temp.Count - 1);
                }
            }

            if (tileRight != null)
            {
                temp.Add(new SpotNode(selectedNode.NodeCost + 1, new Point(selectedNode.nodeLoc.X + 64, selectedNode.nodeLoc.Y)));
                var temp1 = openNodes.Find(on => on.nodeLoc == tileRight.mapPosition.Location);
                var temp2 = closedNodes.Find(on => on.nodeLoc == tileRight.mapPosition.Location);
                if (temp1 != null || temp2 != null)
                {
                    temp.RemoveAt(temp.Count - 1);
                }
            }

            return(temp);
        }
        public static void Start(List <BasicTile> ats)
        {
            availableTiles = ats;
            selectedChar   = null;
            secondaryChar  = null;
            foreach (var item in CombatProcessor.encounterEnemies)
            {
                ats.RemoveAll(t => t.mapPosition.Intersects(item.spriteGameSize) || t.mapPosition.Contains(item.spriteGameSize) || t.mapPosition == item.spriteGameSize);
            }
            BasicTile temp = new BasicTile();

            temp.mapPosition = PlayerController.selectedSprite.spriteGameSize;
            ats.Add(temp);
        }
        private static List <List <BasicTile> > GroupProximityTiles(List <BasicTile> allBuildingTiles)
        {
            List <List <BasicTile> > tempList = new List <List <BasicTile> >();

            int tilesLeftToCheck = allBuildingTiles.Count;
            int groupIndex       = 0;

            while (allBuildingTiles.Count != 0)
            {
                tempList.Add(new List <BasicTile>());
                List <BasicTile> handledTiles = new List <BasicTile>();
                BasicTile        selectedTile = allBuildingTiles[0];
                handledTiles.Add(selectedTile);
                tempList[groupIndex].Add(selectedTile);
                allBuildingTiles.Remove(selectedTile);
                if (allBuildingTiles.Count != 0)
                {
                    var temp = allBuildingTiles.FindAll(bt => bt.TileDistance(selectedTile) <= 1);
                    tempList[groupIndex].AddRange(temp);
                    foreach (var item in temp)
                    {
                        allBuildingTiles.Remove(item);
                    }
                }
                if (allBuildingTiles.Count != 0)
                {
                    while (handledTiles.Count != tempList[groupIndex].Count)
                    {
                        selectedTile = tempList[groupIndex].Except(handledTiles).First();
                        handledTiles.Add(selectedTile);

                        if (allBuildingTiles.Count != 0)
                        {
                            var temp = allBuildingTiles.FindAll(bt => bt.TileDistance(selectedTile) <= 1);
                            tempList[groupIndex].AddRange(temp);
                            foreach (var item in temp)
                            {
                                allBuildingTiles.Remove(item);
                            }
                        }
                    }
                }

                groupIndex++;
            }

            return(tempList);
        }
        public void FinalizeCharacterRound()
        {
            BattleGUI.End();
            bPlayerMustSelectAction       = false;
            selectedCharTurn.bIsCompleted = true;

            if (selectedCharTurn.character.bSaveAP)
            {
                var       MaxAP      = selectedCharTurn.character.trueSTATChart().currentPassiveStats[(int)STATChart.PASSIVESTATS.AP];
                BasicTile finalTile  = selectedCharTurn.returnCompleteArea().Find(t => t.mapPosition.Location == PathMoveHandler.finalPos.ToPoint());
                var       expendedAP = selectedCharTurn.characterArea.IndexOf(selectedCharTurn.characterArea.Find(area => area.Contains(finalTile))) + 1;
                selectedCharTurn.character.statChart.currentActiveStats[(int)STATChart.ACTIVESTATS.STORED_AP] += MaxAP - expendedAP;
            }

            //Console.WriteLine(selectedCharTurn.character.statChart.currentActiveStats[(int)STATChart.ACTIVESTATS.STORED_AP]);
            BattleScriptHandler.Execute(LUA.LuaBScriptEvent.EventType.postCT, this.toLuaTurnSetInfo());
            EncounterInfo.ClearDeathChars();

            selectedCharTurn = null;
            EncounterInfo.UpdateAllStats();
        }
        internal static DangerTile Convert(LuaDangerTile luaDangerTile)
        {
            DangerTile temp = null;

            try
            {
                BasicTile t = LuaHelp.PointToTile(luaDangerTile.tile);
                temp = new DangerTile(t, luaDangerTile.function);
            }
            catch (Exception)
            {
                return(null);
            }
            if (temp != null)
            {
                if (temp.callFunction == null)
                {
                    //return null
                }
                return(temp);
            }
            return(null);
        }
예제 #13
0
        static public List <BasicTile> returnValidMapRadius2(int r, List <BasicTile> bt, Vector2 bs)
        {
            Point            loc       = ((bs / 64).ToPoint().ToVector2() * 64).ToPoint();
            List <Rectangle> temp      = new List <Rectangle>();
            List <BasicTile> tempTiles = new List <BasicTile>();

            for (int i = 0; i < r + 1; i++)
            {
                for (int j = -(r - i); j < (r - i) + 1; j++)
                {
                    temp.Add(new Rectangle(loc.X + i * 64, loc.Y + j * 64, 64, 64));
                }
            }

            for (int i = -r; i != 0; i++)
            {
                for (int j = -(i + r); j < i + r + 1; j++)
                {
                    temp.Add(new Rectangle(loc.X + i * 64, loc.Y + j * 64, 64, 64));
                }
            }

            foreach (var item in temp)
            {
                BasicTile tempTile = bt.Find(t => t.mapPosition == item);
                if (tempTile != null)
                {
                    tempTiles.Add(tempTile);
                }
            }

            List <SpotNode> openNodes   = new List <SpotNode>();
            List <SpotNode> closedNodes = new List <SpotNode>();
            SpotNode        startNode   = new SpotNode(0, ((bs / 64).ToPoint().ToVector2() * 64).ToPoint());
            SpotNode        selectedNode;

            openNodes.AddRange(returnURDL(openNodes, closedNodes, tempTiles, startNode));
            while (openNodes.Count != 0)
            {
                for (int i = 1; i < r + 1; i++)
                {
                    selectedNode = openNodes.Find(on => on.NodeCost == i);
                    if (selectedNode != null)
                    {
                        openNodes.Remove(selectedNode);
                        closedNodes.Add(selectedNode);
                        if (i != r)
                        {
                            openNodes.AddRange(returnURDL(openNodes, closedNodes, tempTiles, selectedNode));
                        }
                        break;
                    }
                }
            }

            List <BasicTile> toDeleteTiles = new List <BasicTile>();

            foreach (var tile in tempTiles)
            {
                bool bCanReach = false;
                foreach (var cn in closedNodes)
                {
                    if (tile.mapPosition.Location == cn.nodeLoc)
                    {
                        bCanReach = true;
                    }
                }

                if (!bCanReach)
                {
                    toDeleteTiles.Add(tile);
                }
            }

            foreach (var item in toDeleteTiles)
            {
                tempTiles.Remove(item);
            }

            return(tempTiles);
        }
예제 #14
0
        static public bool TryCalculatePath(NPC npc, NPCMoveToCommand NPCtc, BasicMap parentMap, BasicTile start, BasicTile end)
        {
            BasicMap mapToCheckIn;

            if (NPCtc.mapID == 0)
            {
                mapToCheckIn = parentMap;
            }
            else
            {
                mapToCheckIn = parentMap.subMaps.Find(m => m.identifier == NPCtc.mapID);
            }

            var chunks = MapChunk.returnChunkRadius(mapToCheckIn, start.mapPosition.Location.ToVector2(), 2);

            if (chunks.Count != 0)
            {
                List <BasicTile> tiles = new List <BasicTile>();
                foreach (var chunk in chunks)
                {
                    tiles.AddRange(mapToCheckIn.possibleTilesWithController(chunk.region, mapToCheckIn));
                }
                tiles = tiles.Distinct().ToList();
                var test = PathFinder.NewPathSearch(start, end, tiles);
                if (test != null && test.Count != 0)
                {
                    return(true);
                }
            }


            return(false);
        }
 internal DangerTile(BasicTile tile, NLua.LuaFunction f)
 {
     parentLocation = tile;
     callFunction   = f;
 }