Example #1
0
        public void AddObstacle(int obsType, float gridSize)
        {
            if (obstacleT != null)
            {
                if (obstacleT.gameObject.layer == TBTK.GetLayerObstacleHalfCover() && obsType == 1)
                {
                    return;
                }
                if (obstacleT.gameObject.layer == TBTK.GetLayerObstacleFullCover() && obsType == 2)
                {
                    return;
                }

                                #if UNITY_EDITOR
                Undo.DestroyObjectImmediate(obstacleT.gameObject);
                                #endif
            }

            if (wallList.Count > 0)
            {
                if (!Application.isPlaying)
                {
                    Grid grid = GridManager.GetInstance().GetGrid();
                    while (wallList.Count > 0)
                    {
                        RemoveWall(wallList[0].angle, grid.GetNeighbourInDir(this, wallList[0].angle));
                    }
                }
                else
                {
                    while (wallList.Count > 0)
                    {
                        RemoveWall(wallList[0].angle, GetNeighbourFromAngle(wallList[0].angle));
                    }
                }
            }

            //float gridSize=GridManager.GetTileSize();

                        #if UNITY_EDITOR
            Transform obsT = (Transform)PrefabUtility.InstantiatePrefab(GridManager.GetObstacleT(obsType));
            Undo.RecordObject(this, "Tile");
            Undo.RecordObject(GetComponent <Renderer>(), "TileRenderer");
            Undo.RegisterCreatedObjectUndo(obsT.gameObject, "Obstacle");
                        #else
            Transform obsT = (Transform)Instantiate(GridManager.GetObstacleT(obsType));
                        #endif



            //~ float offsetY=0;
            //~ if(type==_TileType.Square){
            //~ if(obsType==1)offsetY=obsT.localScale.z*gridSize/4;
            //~ if(obsType==2)offsetY=obsT.localScale.z*gridSize/2;
            //~ }
            //~ else if(type==_TileType.Hex) offsetY=obsT.localScale.z*gridSize/4;

            obsT.position = GetPos();          //+new Vector3(0, offsetY, 0);

            obsT.localScale *= gridSize * GridManager.GetGridToTileSizeRatio();
            obsT.parent      = transform;

            obstacleT = obsT;
            walkable  = false;

            GetComponent <Renderer>().enabled = false;

            //SetState(_TileState.Default);
        }
Example #2
0
        //~ public void ActivateTargetModeUnit(Tile tile, int range, int AOE, bool normalAttack, bool requireDirectLOS, _TargetType type, TargetModeCallBack sCallBack, TargetModeCallBack eCallBack){
        public void ActivateTargetModeUnit(Tile tile, UnitAbility ability, int abIndex, TargetModeCallBack sCallBack, ExitTargetModeCallBack eCallBack)
        {
            TBTK.OnUnitABTargetMode(abIndex);
            _ActivateTargetMode(abIndex, ability.GetAOERange(), ability.targetType, sCallBack, eCallBack);

            if (!ability.AttackInLine())
            {
                if (!ability.normalAttack)
                {
                    if (targetModeType == _TargetType.EmptyTile)
                    {
                        targetModeTileList = GridManager.GetTilesWithinDistance(tile, ability.GetRange(), true);
                    }
                    else
                    {
                        targetModeTileList = GridManager.GetTilesWithinDistance(tile, ability.GetRange());
                    }
                }
                else
                {
                    targetModeTileList = new List <Tile>();
                    List <Tile> tilesInRangeList = GridManager.GetTilesWithinDistance(tile, ability.GetRange());

                    int         sight = tile.unit.GetSight();
                    List <Unit> allFriendlyUnitList = FactionManager.GetAllUnitsOfFaction(tile.unit.factionID);

                    for (int i = 0; i < tilesInRangeList.Count; i++)
                    {
                        Tile targetTile = tilesInRangeList[i];

                        if (!GameControl.EnableFogOfWar() && !GameControl.AttackThroughObstacle())
                        {
                            if (!FogOfWar.InLOS(tile, targetTile, 0))
                            {
                                continue;
                            }
                        }

                        bool inSight = GameControl.EnableFogOfWar() ? false : true;
                        if (GameControl.EnableFogOfWar())
                        {
                            if (FogOfWar.InLOS(tile, targetTile) && GridManager.GetDistance(tile, targetTile) <= sight)
                            {
                                inSight = true;
                            }
                            else if (!ability.requireDirectLOS)
                            {
                                for (int n = 0; n < allFriendlyUnitList.Count; n++)
                                {
                                    if (allFriendlyUnitList[n] == tile.unit)
                                    {
                                        continue;
                                    }
                                    if (GridManager.GetDistance(allFriendlyUnitList[n].tile, targetTile) > allFriendlyUnitList[n].GetSight())
                                    {
                                        continue;
                                    }
                                    if (FogOfWar.InLOS(allFriendlyUnitList[n].tile, targetTile))
                                    {
                                        inSight = true;
                                        break;
                                    }
                                }
                            }
                        }

                        if (inSight)
                        {
                            targetModeTileList.Add(targetTile);
                        }
                    }
                }
            }
            else
            {
                /*
                 * List<Tile> neighbourList=tile.GetNeighbourList();
                 * for(int i=0; i<neighbourList.Count; i++){
                 *      bool walkableOnly=(ability.type==UnitAbility._AbilityType.ChargeAttack);
                 *      List<Tile> tileList=GridManager.GetTilesInALine(tile, neighbourList[i], ability.GetRange(), walkableOnly);
                 *
                 *      if(tileList.Count>0){
                 *              if(targetModeType!=_TargetType.EmptyTile) targetModeTileList.Add(tileList[tileList.Count-1]);
                 *              else if (tileList[tileList.Count-1].unit==null) targetModeTileList.Add(tileList[tileList.Count-1]);
                 *      }
                 * }
                 */
            }

            //for(int i=0; i<targetModeTileList.Count; i++) targetModeTileList[i].SetState(_TileState.Range);
            OverlayManager.ShowAbilityRangeIndicator(targetModeTileList);
        }
Example #3
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;
        }
Example #4
0
        IEnumerator _ApplyAbilityEffect(Tile targetTile, Ability ability, int type, Unit srcUnit = null, float critMult = 1.0f)
        {
            if (targetTile != null && ability.effectObject != null)
            {
                if (!ability.autoDestroyEffect)
                {
                    ObjectPoolManager.Spawn(ability.effectObject, targetTile.GetPos(), Quaternion.identity);
                }
                else
                {
                    ObjectPoolManager.Spawn(ability.effectObject, targetTile.GetPos(), Quaternion.identity, ability.effectObjectDuration);
                }
            }

            if (!ability.useDefaultEffect)
            {
                yield break;
            }
            if (ability.effectDelayDuration > 0)
            {
                yield return(new WaitForSeconds(ability.effectDelayDuration));
            }

            if (type == 1)              //_AbilityType.Generic

            {
                List <Tile> tileList = new List <Tile>();
                if (targetTile != null)
                {
                    if (ability.aoeRange > 0)
                    {
                        tileList = GridManager.GetTilesWithinDistance(targetTile, ability.aoeRange);
                    }
                    tileList.Add(targetTile);
                }
                else
                {
                    if (ability.effTargetType == _EffectTargetType.Tile)
                    {
                        tileList = GridManager.GetTileList();
                    }
                    else
                    {
                        List <Unit> unitList = FactionManager.GetAllUnit();
                        for (int i = 0; i < unitList.Count; i++)
                        {
                            tileList.Add(unitList[i].tile);
                        }
                    }
                }

                if (ability.effTargetType == _EffectTargetType.AllUnit)
                {
                    for (int i = 0; i < tileList.Count; i++)
                    {
                        if (tileList[i].unit == null)
                        {
                            continue;
                        }
                        tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult), srcUnit);
                        SpawnEffectObjTarget(ability, tileList[i]);
                    }
                }
                else if (ability.effTargetType == _EffectTargetType.HostileUnit)
                {
                    for (int i = 0; i < tileList.Count; i++)
                    {
                        if (tileList[i].unit == null)
                        {
                            continue;
                        }
                        if (tileList[i].unit.factionID == ability.factionID)
                        {
                            continue;
                        }
                        tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult), srcUnit);
                        SpawnEffectObjTarget(ability, tileList[i]);
                    }
                }
                else if (ability.effTargetType == _EffectTargetType.FriendlyUnit)
                {
                    for (int i = 0; i < tileList.Count; i++)
                    {
                        if (tileList[i].unit == null)
                        {
                            continue;
                        }
                        if (tileList[i].unit.factionID != ability.factionID)
                        {
                            continue;
                        }
                        tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult), srcUnit);
                        SpawnEffectObjTarget(ability, tileList[i]);
                    }
                }
                else if (ability.effTargetType == _EffectTargetType.Tile)
                {
                    for (int i = 0; i < tileList.Count; i++)
                    {
                        tileList[i].ApplyEffect(ability.CloneEffect(critMult));
                        SpawnEffectObjTarget(ability, tileList[i]);
                    }
                }
            }
            else if (type == 2)                 //_AbilityType.SpawnNew
            {
                Quaternion rot     = srcUnit != null ? srcUnit.thisT.rotation : Quaternion.identity;
                GameObject unitObj = (GameObject)Instantiate(ability.spawnUnit.gameObject, targetTile.GetPos(), rot);
                Unit       unit    = unitObj.GetComponent <Unit>();

                unitObj.transform.position = targetTile.GetPos();
                if (srcUnit != null)
                {
                    unitObj.transform.rotation = srcUnit.thisT.rotation;
                }
                else
                {
                    Faction faction = FactionManager.GetFaction(ability.factionID);
                    if (faction != null)
                    {
                        unitObj.transform.rotation = Quaternion.Euler(0, faction.spawnDirection, 0);
                    }
                }

                FactionManager.InsertUnit(unit, ability.factionID);
                unit.SetNewTile(targetTile);
                //if(GridManager.GetDistance(targetTile, srcUnit.tile)<=srcUnit.GetMoveRange()) GameControl.SelectUnit(srcUnit);
            }
            else if (type == 3)                 //_AbilityType.ScanFogOfWar)
            {
                List <Tile> targetTileList = GridManager.GetTilesWithinDistance(targetTile, ability.GetAOERange());
                targetTileList.Add(targetTile);
                for (int i = 0; i < targetTileList.Count; i++)
                {
                    targetTileList[i].ForceVisible(ability.effect.duration);
                }
            }
            else if (type == 4)                 //_AbilityType.Overwatch
            {
                targetTile.unit.Overwatch(ability.CloneEffect(critMult));
            }
            else if (type == 5)                 //_AbilityType.Teleport
            {
                Quaternion wantedRot = Quaternion.LookRotation(targetTile.GetPos() - ability.unit.tile.GetPos());
                ability.unit.thisT.rotation = wantedRot;

                GameControl.ClearSelectedUnit();
                ability.unit.SetNewTile(targetTile);
                GameControl.SelectUnit(srcUnit);
            }



            else if (type == 6)                 //charge attack
            {
                List <Tile> tileList = GridManager.GetTilesInALine(srcUnit.tile, targetTile, ability.GetRange());

                for (int i = 0; i < tileList.Count; i++)
                {
                    while (true)
                    {
                        float dist = Vector3.Distance(srcUnit.thisT.position, tileList[i].GetPos());
                        if (dist < 0.05f)
                        {
                            if (tileList[i].unit != null)
                            {
                                tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult));
                                SpawnEffectObjTarget(ability, tileList[i]);
                            }
                            break;
                        }

                        Quaternion wantedRot = Quaternion.LookRotation(tileList[i].GetPos() - srcUnit.thisT.position);
                        srcUnit.thisT.rotation = Quaternion.Slerp(srcUnit.thisT.rotation, wantedRot, Time.deltaTime * srcUnit.moveSpeed * 6);

                        Vector3 dir = (tileList[i].GetPos() - srcUnit.thisT.position).normalized;
                        srcUnit.thisT.Translate(dir * Mathf.Min(srcUnit.moveSpeed * 2 * Time.deltaTime, dist), Space.World);
                        yield return(null);
                    }
                }

                srcUnit.tile.unit = null;
                srcUnit.tile      = tileList[tileList.Count - 1];
                tileList[tileList.Count - 1].unit = srcUnit;
                GameControl.ReselectUnit();
            }
            else if (type == 7)                 //attack all unit in a straight line
            {
                List <Tile> tileList = GridManager.GetTilesInALine(srcUnit.tile, targetTile, ability.GetRange());
                for (int i = 0; i < tileList.Count; i++)
                {
                    if (tileList[i].unit == null)
                    {
                        continue;
                    }
                    tileList[i].unit.ApplyEffect(ability.CloneEffect(critMult));
                    SpawnEffectObjTarget(ability, tileList[i]);
                }
            }
            else
            {
                Debug.LogWarning("Error, unknown ability type (" + type + ")");
            }

            yield return(null);
        }