Exemplo n.º 1
0
        private Tile AnalyseCoverSystem(Unit unit, List <Tile> walkableTilesInRange, List <Unit> allHostileInSight)
        {
            List <Tile> walkableTilesInRangeAlt = new List <Tile>();    //for cover system, secondary tiles with less cover

            List <Tile> halfCoveredList = new List <Tile>();            //a list for all the tiles with half Cover
            List <Tile> fullCoveredList = new List <Tile>();            //a list for all the tiles with full Cover

            if (allHostileInSight.Count == 0)
            {
                fullCoveredList = walkableTilesInRange;
            }
            else                //if there are hostile in sight
                                //loop through all the walkable, record their score based on
            {
                for (int i = 0; i < walkableTilesInRange.Count; i++)
                {
                    Tile tile = walkableTilesInRange[i];
                    tile.hostileCount = 0;
                    tile.coverScore   = 0;

                    //iterate through all hostile, add the count, and cover type to the tile, this will then be used in tile.GetCoverRating() when this loop is complete
                    for (int n = 0; n < allHostileInSight.Count; n++)
                    {
                        // if the hostile is out of range, ignore it
                        int hostileRange = allHostileInSight[n].GetMoveRange() + allHostileInSight[n].GetAttackRange();
                        if (GridManager.GetDistance(allHostileInSight[n].tile, tile) > hostileRange)
                        {
                            continue;
                        }

                        tile.hostileCount += 1;

                        CoverSystem._CoverType coverType = CoverSystem.GetCoverType(allHostileInSight[n].tile, walkableTilesInRange[i]);
                        if (coverType == CoverSystem._CoverType.Half)
                        {
                            tile.coverScore += 1;
                        }
                        else if (coverType == CoverSystem._CoverType.Full)
                        {
                            tile.coverScore += 2;
                        }
                    }

                    //get cover rating for the tile
                    //if score is >=2, the tile has full cover from all hostile, so add it to fullCoveredList
                    //if score is >=1 && <2, the tile has half cover from all hostile, so add it to halfCoveredList
                    //if anything <1, the tile is exposed to hostile in some manner
                    if (tile.GetCoverRating() >= 2)
                    {
                        fullCoveredList.Add(tile);
                    }
                    else if (tile.GetCoverRating() >= 1)
                    {
                        halfCoveredList.Add(tile);
                    }
                }
            }

            //if either of the CoveredList is not empty, replace walkableTilesInRange with that since there's no need to consider to move into tiles without cover
            if (fullCoveredList.Count != 0)
            {
                walkableTilesInRange    = fullCoveredList;
                walkableTilesInRangeAlt = halfCoveredList;
            }
            else if (halfCoveredList.Count != 0)
            {
                walkableTilesInRange = halfCoveredList;
            }

            //if there are hostile
            if (allHostileInSight.Count > 0)
            {
                //fill up the walkableTilesInRange hostile list
                //then filter thru walkableTilesInRange, those that have a hostile in range will be add to a tilesWithHostileInRange
                List <Tile> tilesWithHostileInRange = new List <Tile>();
                GridManager.SetupHostileInRangeforTile(unit, walkableTilesInRange);
                for (int i = 0; i < walkableTilesInRange.Count; i++)
                {
                    if (walkableTilesInRange[i].GetHostileInRange().Count > 0)
                    {
                        tilesWithHostileInRange.Add(walkableTilesInRange[i]);
                    }
                }

                if (tilesWithHostileInRange.Count == 0)
                {
                    GridManager.SetupHostileInRangeforTile(unit, walkableTilesInRangeAlt);
                    for (int i = 0; i < walkableTilesInRangeAlt.Count; i++)
                    {
                        if (walkableTilesInRangeAlt[i].GetHostileInRange().Count > 0)
                        {
                            tilesWithHostileInRange.Add(walkableTilesInRangeAlt[i]);
                        }
                    }
                }

                //if the tilesWithHostileInRange is not empty after the process, means there's tiles which the unit can move into and attack
                //return one of those in the tilesWithHostileInRange so the unit can attack
                if (tilesWithHostileInRange.Count > 0)
                {
                    //if the unit current tile is one of those tiles with hostile, just stay put and attack
                    if (tilesWithHostileInRange.Contains(unit.tile))
                    {
                        //randomize it a bit so the unit do move around but not stay in place all the time
                        if (Random.Range(0f, 1f) > 0.25f)
                        {
                            return(unit.tile);
                        }
                    }
                    return(tilesWithHostileInRange[Random.Range(0, tilesWithHostileInRange.Count)]);
                }
            }

            return(null);
        }
Exemplo n.º 2
0
        void Awake()
        {
            instance = this;

            TBData.ClearEndData();

            SettingDB settingDB = InitSetting();

            if (enableCover)
            {
                CoverSystem.SetFullCoverDodgeBonus(fullCoverBonus);
                CoverSystem.SetHalfCoverDodgeBonus(halfCoverBonus);
                CoverSystem.SetExposedCritChanceBonus(exposedCritBonus);
            }

            //get the instance of each component and initiate them, the order in which these component matters

            PerkManager perkManager = (PerkManager)FindObjectOfType(typeof(PerkManager));

            if (perkManager != null)
            {
                perkManager.Init();
            }

            AbilityManagerUnit abManagerUnit = (AbilityManagerUnit)FindObjectOfType(typeof(AbilityManagerUnit));

            if (abManagerUnit != null)
            {
                abManagerUnit.Init();
            }

            AbilityManagerFaction abManagerFac = (AbilityManagerFaction)FindObjectOfType(typeof(AbilityManagerFaction));

            if (abManagerFac != null)
            {
                abManagerFac.Init();
            }

            TurnControl turnControl = (TurnControl)FindObjectOfType(typeof(TurnControl));

            turnControl.Init();

            if (settingDB != null)
            {
                turnControl.turnMode  = settingDB.turnMode;
                turnControl.moveOrder = settingDB.moveOrder;
            }

            GridManager gridManager = (GridManager)FindObjectOfType(typeof(GridManager));

            if (settingDB != null)
            {
                gridManager.generateGridOnStart = settingDB.generateGridOnStart;
            }
            gridManager.Init();

            FactionManager factionManager = (FactionManager)FindObjectOfType(typeof(FactionManager));

            if (settingDB != null)
            {
                factionManager.generateUnitOnStart = settingDB.generateUnitOnStart;
            }
            factionManager.Init();

            CollectibleManager collectibleManager = (CollectibleManager)FindObjectOfType(typeof(CollectibleManager));

            if (settingDB != null)
            {
                collectibleManager.generateCollectibleOnStart = settingDB.generateCollectibleOnStart;
            }
            collectibleManager.Init();

            GridManager.SetupGridForFogOfWar();

            OverlayManager overlayManager = (OverlayManager)FindObjectOfType(typeof(OverlayManager));

            overlayManager.Init();

            defaultShootObject = Resources.Load("ScenePrefab/DefaultShootObject", typeof(GameObject)) as GameObject;

            gamePhase = _GamePhase.Initialization;
        }
Exemplo n.º 3
0
        public void Init()
        {
            for (int i = 0; i < tileList.Count; i++)
            {
                tileList[i].Init();
            }

            GridManager gridManager = GridManager.GetInstance();

            //setup the neighbour of each tile
            if (gridManager.tileType == _TileType.Square)
            {
                float distTH = gridManager.tileSize * gridManager.gridToTileRatio * 1.1f;
                for (int i = 0; i < tileList.Count; i++)
                {
                    Tile tile = tileList[i];
                    tile.aStar = new TileAStar(tile);

                    List <Tile> neighbourList = new List <Tile>();

                    int nID = i + 1;
                    if (nID < tileList.Count && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i + gridManager.length;
                    if (nID < tileList.Count && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i - 1;
                    if (nID >= 0 && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i - gridManager.length;
                    if (nID >= 0 && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    //tile.aStar.straightNeighbourCount=neighbourList.Count;

                    //diagonal neighbour, not in used
                    if (GridManager.EnableDiagonalNeighbour())
                    {
                        nID = (i + 1) + gridManager.length;
                        if (nID < tileList.Count && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH * 1.5f)
                        {
                            neighbourList.Add(tileList[nID]);
                        }

                        nID = (i + 1) - gridManager.length;
                        if (nID >= 0 && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH * 1.5f)
                        {
                            neighbourList.Add(tileList[nID]);
                        }

                        nID = (i - 1) + gridManager.length;
                        if (nID < tileList.Count && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH * 1.5f)
                        {
                            neighbourList.Add(tileList[nID]);
                        }

                        nID = (i - 1) - gridManager.length;
                        if (nID >= 0 && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH * 1.5f)
                        {
                            neighbourList.Add(tileList[nID]);
                        }
                    }

                    tile.aStar.SetNeighbourList(neighbourList);
                }
            }
            else if (gridManager.tileType == _TileType.Hex)
            {
                float distTH = GridGenerator.spaceZHex * gridManager.tileSize * gridManager.gridToTileRatio * 1.1f;
                for (int i = 0; i < tileList.Count; i++)
                {
                    Tile tile = tileList[i];
                    tile.aStar = new TileAStar(tile);

                    List <Tile> neighbourList = new List <Tile>();

                    int nID = i + 1;
                    if (nID < tileList.Count && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i + gridManager.length;
                    if (nID < tileList.Count && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i + gridManager.length - 1;
                    if (nID < tileList.Count && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i - 1;
                    if (nID >= 0 && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i - gridManager.length;
                    if (nID >= 0 && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    nID = i - gridManager.length + 1;
                    if (nID >= 0 && Vector3.Distance(tile.GetPosG(), tileList[nID].GetPosG()) <= distTH)
                    {
                        neighbourList.Add(tileList[nID]);
                    }

                    tile.aStar.SetNeighbourList(neighbourList);

                    //tile.aStar.straightNeighbourCount=neighbourList.Count;
                }
            }

            //setup the wall
            for (int i = 0; i < tileList.Count; i++)
            {
                tileList[i].InitWall();
            }

            if (GridManager.EnableDiagonalNeighbour())
            {
                for (int i = 0; i < tileList.Count; i++)
                {
                    tileList[i].CheckDiagonal();
                }
            }

            //setup the cover
            if (GameControl.EnableCover())
            {
                for (int i = 0; i < tileList.Count; i++)
                {
                    CoverSystem.InitCoverForTile(tileList[i]);
                }
            }
        }
Exemplo n.º 4
0
        private void CalculateChance()
        {
            if (calculated)
            {
                return;
            }
            calculated = true;

            float coverDodgeBonus  = 0;
            float exposedCritBonus = 0;

            //if cover system is enabled, get the dodge and crit bonus
            if (GameControl.EnableCover())
            {
                coverType = CoverSystem.GetCoverType(srcUnit.tile, tgtUnit.tile);
                if (coverType == CoverSystem._CoverType.Half)
                {
                    coverDodgeBonus = CoverSystem.GetHalfCoverDodgeBonus();
                }
                else if (coverType == CoverSystem._CoverType.Full)
                {
                    coverDodgeBonus = CoverSystem.GetFullCoverDodgeBonus();
                }
                else
                {
                    exposedCritBonus = CoverSystem.GetExposedCritChanceBonus();
                }
            }

            //calculate the hit chance
            float hit = !isMelee?srcUnit.GetHitChance() : srcUnit.GetHitChanceMelee();

            float dodge = tgtUnit.GetDodgeChance() + coverDodgeBonus;

            hitChance = Mathf.Clamp(hit - dodge, 0f, 1f);

            //calculate the critical chance
            float critHit   = (!isMelee ? srcUnit.GetCritChance() : srcUnit.GetCritChanceMelee()) + exposedCritBonus;
            float critAvoid = tgtUnit.GetCritAvoidance();

            critChance = Mathf.Clamp(critHit - critAvoid, 0f, 1f);

            //calculate stun chance
            float stunHit   = srcUnit.GetStunChance();
            float stunAvoid = tgtUnit.GetStunAvoidance();

            stunChance = Mathf.Clamp(stunHit - stunAvoid, 0f, 1f);

            //calculate silent chance
            float silentHit   = srcUnit.GetSilentChance();
            float silentAvoid = tgtUnit.GetSilentAvoidance();

            silentChance = Mathf.Clamp(silentHit - silentAvoid, 0f, 1f);

            if (isOverwatch)
            {
                hitChance -= GameControl.GetOverwatchHitPenalty();
                critHit   -= GameControl.GetOverwatchCritPenalty();
            }

            //check if flanking is enabled an applicable in this instance
            if (GameControl.EnableFlanking())
            {
                //Vector2 dir=new Vector2(srcUnit.tile.pos.x-tgtUnit.tile.pos.x, srcUnit.tile.pos.z-tgtUnit.tile.pos.z);
                float      angleTH        = 180 - Mathf.Min(180, GameControl.GetFlankingAngle());
                Quaternion attackRotation = Quaternion.LookRotation(tgtUnit.tile.GetPos() - srcUnit.tile.GetPos());
                //Debug.Log(Quaternion.Angle(attackRotation, tgtUnit.thisT.rotation)+"    "+angleTH);
                if (Quaternion.Angle(attackRotation, tgtUnit.thisT.rotation) < angleTH)
                {
                    flanked = true;
                }
            }
        }