示例#1
0
        /// <summary>
        /// The method which does all the complicated battle simulation. From calculating Damage to dealing Damage and so forth.
        /// Gets called when the event OnAnimFight is fired. When the needsAnimating property is false it will execute this code.
        /// </summary>
        /// <param Name="Attacker"></param>
        /// <param Name="Defender"></param>
        private void BattleSimulation(OnAnimFight evt)
        {
            if (evt.attacker != null && evt.defender != null && !evt.needsAnimating)
            {
                UnitGameObject attacker = evt.attacker;
                UnitGameObject defender = evt.defender;
                attacker.UnitGame.UpdateUnitColor();
                Unit attUnit = attacker.UnitGame;
                Unit defUnit = defender.UnitGame;

                float damageToDefender = attUnit.Damage * attUnit.GetStrength() * attUnit.GetGroundModifier() *
                                         attUnit.GetUnitModifier(defender.type);
                float damageToAttacker = defUnit.Damage * defUnit.GetStrength() * defUnit.GetGroundModifier() *
                                         defUnit.GetUnitModifier(attacker.type);
                damageToDefender = Mathf.Clamp(damageToDefender, 1f, float.MaxValue);
                damageToAttacker = Mathf.Clamp(damageToAttacker, 1f, float.MaxValue);

                defUnit.DecreaseHealth(damageToDefender);

                if (defUnit.AttackRange >= attUnit.AttackRange)
                {
                    attUnit.DecreaseHealth(damageToAttacker);
                }

                CheckUnitsHealth(attacker, defender);
            }
        }
示例#2
0
    // Use this for initialization
    void Start()
    {
        switch (name)
        {
        case "NorthEast":
            direction = 1;
            break;

        case "East":
            direction = 3;
            break;

        case "SouthEast":
            direction = 5;
            break;

        case "SouthWest":
            direction = 4;
            break;

        case "West":
            direction = 2;
            break;

        case "NorthWest":
            direction = 0;
            break;
        }
        unitGameObject = GetComponentInParent <UnitGameObject>();
    }
示例#3
0
    public static Unit CreateUnit(UnitGameObject unit, bool isHero, UnitTypes type)
    {
        string   unitType   = isHero ? type + "Hero" : type.ToString();
        string   jsonString = Resources.Load <TextAsset>("JSON/Units/" + unitType).text;
        JSONNode jsonUnit   = JSON.Parse(jsonString);

        int       attackRange        = jsonUnit["attackRange"].AsInt;
        int       moveRange          = jsonUnit["moveRange"].AsInt;
        bool      canAttackAfterMove = jsonUnit["canAttackAfterMove"].AsBool;
        float     maxHealth          = jsonUnit["maxHealth"].AsFloat;
        float     damage             = jsonUnit["damage"].AsFloat;
        int       cost     = jsonUnit["cost"].AsInt;
        int       fowLos   = jsonUnit["fowLos"].AsInt;
        float     baseLoot = jsonUnit["baseLoot"].AsFloat;
        JSONArray a        = jsonUnit["unitModifiers"].AsArray;

        var modifiers = new Dictionary <UnitTypes, float>();

        foreach (UnitTypes suit in (UnitTypes[])Enum.GetValues(typeof(UnitTypes)))
        {
            foreach (JSONNode item in a)
            {
                if (!String.IsNullOrEmpty(item[suit.ToString()]) && item[suit.ToString()] != suit.ToString())
                {
                    modifiers.Add(suit, item[suit.ToString()].AsFloat);
                }
            }
        }
        return(new Unit(unit, isHero, attackRange, moveRange, canAttackAfterMove, maxHealth, damage, cost, fowLos, baseLoot, modifiers));
    }
示例#4
0
 private void Update()
 {
     if (CanClick && Input.GetMouseButtonDown(0) && ParentProduction.IsProductionOverlayActive &&
         !ParentProduction.BuildingClickedProduction.Tile.HasUnit())
     {
         Ray        ray = Camera.main.ScreenPointToRay(Input.mousePosition);
         RaycastHit touchBox;
         if (Physics.Raycast(ray, out touchBox))
         {
             if (touchBox.collider == this.collider)
             {
                 BuildingGameObject buildingToProduceFrom = ParentProduction.BuildingClickedProduction;
                 // Kind of ugly yet could not find better solution. The unit is created before we check if it can be bought.
                 // Set it inactive immediatly and then check for enough Gold. If not then destroy else decrease the Gold and set it active.
                 UnitGameObject unit = CreatorFactoryUnit.CreateUnit(buildingToProduceFrom.Tile,
                                                                     buildingToProduceFrom.index, type);
                 unit.gameObject.SetActive(false);
                 if (lm.CurrentLevel.CurrentPlayer.CanBuy(unit.UnitGame.Cost))
                 {
                     unit.gameObject.SetActive(true);
                     lm.CurrentLevel.CurrentPlayer.DecreaseGoldBy(unit.UnitGame.Cost);
                     CanClick = false;
                     ParentProduction.InitiateMoving(true);
                 }
                 else
                 {
                     Notificator.Notify("Not enough gold!", 1.5f);
                     unit.DestroyUnit();
                 }
             }
         }
     }
 }
示例#5
0
        /// <summary>
        /// Show the attack highlights for the specified unit with the specified range.
        /// </summary>
        /// <param Name="unit"></param>
        /// <param Name="range"></param>
        /// <returns></returns>
        public int ShowAttackHighlights(UnitGameObject unit, int range)
        {
            foreach (var item in TileHelper.GetAllTilesWithinRange(unit.Tile.Coordinate, range))
            {
                foreach (var tile in item.Value.Where(tile => tile.Value.HasUnit() && tile.Value.unitGameObject.index != unit.index))
                {
                    // If unit is an archer we don't need to calculate paths because archer can shoot over units, water etc.
                    if (!unit.UnitGame.CanAttackAfterMove && !tile.Value.IsFogShown)
                    {
                        tile.Value.Highlight.ChangeHighlight(HighlightTypes.highlight_attack);
                        highlight.HighlightObjects.Add(tile.Value.Highlight);
                    }
                    else
                    {
                        List <Node> path = movement.CalculateShortestPath(unit.Tile, tile.Value, true);

                        if (path != null && path.Count <= unit.UnitGame.GetAttackMoveRange && !tile.Value.IsFogShown)
                        {
                            tile.Value.Highlight.ChangeHighlight(HighlightTypes.highlight_attack);
                            highlight.HighlightObjects.Add(tile.Value.Highlight);
                        }
                    }
                }
            }
            int count = highlight.HighlightObjects.Count;

            highlight.IsHighlightOn = count > 0;
            return(count);
        }
示例#6
0
 /// <summary>
 /// Moves unit logically by calling on unitmove and graphically by calling on beginwalking
 /// </summary>
 /// <param name="goal">Destination</param>
 public void moveUnit(Point goal)
 {
     if (!finishedWalking && !isWalking && !attacking)
     {
         UnitGameObject activeUnit = initative[whoseTurn];
         path = battleField.unitMove(activeUnit.LogicalPos, goal);
         BeginWalking();
     }
 }
示例#7
0
        public void Moving(UnitGameObject unitMoving)
        {
            unitMoving.transform.position = Vector2.Lerp(unitMoving.Tile.Vector2, nodeList.Last().Tile.Vector2,
                                                         GetTimePassed());

            if (GetTimePassed() >= 1f)
            {
                // Show fow for the unit.
                dayStateControl.ShowFowWithinLineOfSight(unitMoving.index);
                // Remove the references from the old Tile.
                unitMoving.Tile.unitGameObject = null;
                unitMoving.Tile = null;
                // Remove the last Tile from the list.
                Tile newPosition = nodeList.Last().Tile;
                nodeList.Remove(nodeList.Last());
                // Assign the references using the new Tile.
                newPosition.unitGameObject = unitMoving;
                unitMoving.Tile            = newPosition;
                unitMoving.Tile.Vector2    = newPosition.Vector2;
                // Set the parent and position of the unit to the new Tile.
                unitMoving.transform.parent   = newPosition.transform;
                unitMoving.transform.position = newPosition.transform.position;
                // Hide the fow for the unit. It will use the new Tile location.
                dayStateControl.HideFowWithinLineOfSight(unitMoving.index);
                StartTimeMoving = Time.time;
            }

            if (nodeList.Count <= 0)
            {
                highlight.ClearHighlights();
                Tile endDestinationTile = unitMoving.Tile;

                if (endDestinationTile.HasLoot())
                {
                    endDestinationTile.Loot.PickUpLoot(levelManager.CurrentLevel.CurrentPlayer);
                }

                if (endDestinationTile.HasBuilding())
                {
                    CaptureBuildings capBuilding = GameObject.Find("_Scripts").GetComponent <CaptureBuildings>();
                    capBuilding.AddBuildingToCaptureList(
                        endDestinationTile.buildingGameObject.BuildingGame);
                }
                if (unitMoving.UnitGame.CanAttackAfterMove &&
                    attack.ShowAttackHighlights(unitMoving, unitMoving.UnitGame.AttackRange) > 0)
                {
                    unitMoving.UnitGame.HasMoved = true;
                }
                else
                {
                    unitMoving.UnitGame.HasMoved    = true;
                    unitMoving.UnitGame.HasAttacked = true;
                }
                NeedsMoving = false;
                unitMoving.UnitGame.UpdateUnitColor();
            }
        }
示例#8
0
        private static UnitGameObject ConfigUnitAndTile(Tile tile, GameObject obj)
        {
            UnitGameObject unit = ((GameObject)GameObject.Instantiate(obj)).GetComponent <UnitGameObject>();

            tile.unitGameObject     = unit;
            unit.transform.position = tile.transform.position;
            unit.transform.parent   = tile.transform;
            unit.Tile = tile;
            return(unit);
        }
示例#9
0
 /// <summary>
 /// When a unit captured an trainingzone, train him to his hero form.
 /// </summary>
 /// <param Name="unitToHero">The unit to train to an hero.</param>
 private void OnTrainingzoneCapturedHero(UnitGameObject unitToHero)
 {
     if (!unitToHero.isHero)
     {
         Tile        tiletoSpawn = unitToHero.Tile;
         PlayerIndex index       = unitToHero.index;
         UnitTypes   type        = unitToHero.type;
         unitToHero.DestroyUnit();
         CreatorFactoryUnit.CreateHeroUnit(tiletoSpawn, index, type);
     }
 }
示例#10
0
        public void FacingDirectionMovement(UnitGameObject moveUnit, Tile destination)
        {
            Vector3 direction = moveUnit.transform.position - destination.transform.position;

            var quaternion = new Quaternion(0, (direction.x > 0 ? 180 : 0), 0, 0);

            moveUnit.transform.rotation = quaternion;

            var attackerHealthQ = new Quaternion(0, 0, 0, (moveUnit.transform.position.y > 0 ? 0 : 180));

            moveUnit.UnitHealthText.transform.rotation = attackerHealthQ;
        }
示例#11
0
        /// <summary>
        /// Call this method whenever a unit has moved onto an enemy or neutral building.
        /// </summary>
        /// <param Name="building"></param>
        public void AddBuildingToCaptureList(Building building)
        {
            UnitGameObject unitOnBuilding = building.BuildingGameObject.Tile.unitGameObject;

            if (!BuildingsBeingCaptured.Contains(building) && unitOnBuilding.index != building.BuildingGameObject.index)
            {
                BuildingsBeingCaptured.Add(building);
            }
            else if (BuildingsBeingCaptured.Contains(building) &&
                     unitOnBuilding.index == building.BuildingGameObject.index)
            {
                building.ResetCurrentCapturePoints();
                BuildingsBeingCaptured.Remove(building);
            }
        }
示例#12
0
        /// <summary>
        /// Get called whenever an OnHighlightClick is fired. If it is possible it will attack an enemy unit.
        /// </summary>
        /// <param Name="evt"></param>
        public void BattlePreparation(OnHighlightClick evt)
        {
            if (evt.highlight != null)
            {
                HighlightObject highlightObj = evt.highlight;
                if (highlight.IsHighlightOn && !movement.NeedsMoving &&
                    highlightObj.highlightTypeActive == HighlightTypes.highlight_attack)
                {
                    UnitGameObject attackingUnit = highlight.UnitSelected;
                    UnitGameObject defendingUnit = highlightObj.Tile.unitGameObject;


                    if (!attackingUnit.UnitGame.HasAttacked)
                    {
                        if (!attackingUnit.UnitGame.HasMoved ||
                            (attackingUnit.UnitGame.HasMoved && attackingUnit.UnitGame.CanAttackAfterMove))
                        {
                            if (TileHelper.IsTileWithinRange(attackingUnit.transform.position,
                                                             defendingUnit.transform.position, attackingUnit.UnitGame.AttackRange))
                            {
                                attackingUnit.UnitGame.HasAttacked = true;
                                attackingUnit.UnitGame.HasMoved    = true;
                                attackingUnit.UnitGame.PlaySound(UnitSoundType.Attack);

                                highlight.ClearHighlights();

                                // Check if units are faces the wrong way
                                FacingDirectionUnits(attackingUnit, defendingUnit);

                                // Dispatch the animation fight event. But set the needsanimating to true.
                                OnAnimFight fight = new OnAnimFight();
                                fight.attacker       = attackingUnit;
                                fight.defender       = defendingUnit;
                                fight.needsAnimating = true;
                                EventHandler.dispatch(fight);
                            }
                            else
                            {
                                Notificator.Notify("Move to this unit to attack!", 1f);
                            }
                        }
                    }
                }
            }
        }
示例#13
0
 private void CheckUnitsHealth(UnitGameObject attacker, UnitGameObject defender)
 {
     if (!attacker.UnitGame.IsAlive() && !defender.UnitGame.IsAlive())
     {
         defender.UnitGame.OnDeath();
         attacker.UnitGame.OnDeath();
     }
     else if (!attacker.UnitGame.IsAlive())
     {
         attacker.UnitGame.OnDeath();
         defender.UnitGame.AddLoot(10);
     }
     else if (!defender.UnitGame.IsAlive())
     {
         defender.UnitGame.OnDeath();
         attacker.UnitGame.AddLoot(10);
     }
 }
示例#14
0
        private void FacingDirectionUnits(UnitGameObject attacker, UnitGameObject defender)
        {
            Vector3 attDirection = defender.transform.position - attacker.transform.position;
            Vector3 defDirection = attacker.transform.position - defender.transform.position;

            var attackerQ = new Quaternion(0, (attDirection.x >= 0 ? 0 : 180), 0, 0);
            var defenderQ = new Quaternion(0, (defDirection.x >= 0 ? 0 : 180), 0, 0);

            attacker.transform.rotation = attackerQ;
            defender.transform.rotation = defenderQ;

            var attackerHealthQ = new Quaternion(0, 0, 0, (attacker.transform.position.y > 0 ? 0 : 180));
            var defenderHealthQ = new Quaternion(0, 0, 0, (defender.transform.position.y > 0 ? 0 : 180));

            attacker.UnitHealthText.transform.rotation = attackerHealthQ;
            defender.UnitHealthText.transform.rotation = defenderHealthQ;

            // While attacking don't show the UnitHealth
            attacker.UnitHealthText.renderer.enabled = false;
            defender.UnitHealthText.renderer.enabled = false;
        }
示例#15
0
    /// <summary>
    /// Method finds wich enemy unit to attack and then calls the checkPos method
    /// </summary>
    /// <param name="activeUnit">The unit whose turn it is</param>
    public void act(UnitGameObject activeUnit)
    {
        x = activeUnit.LogicalPos.x;
        y = activeUnit.LogicalPos.y;
        UnitGameObject[] possibleTargets = new UnitGameObject[UnitTree.TREESIZE + 1];
        int next = 0;

        //Finds enemy units
        for (int i = 0; i < width; i++)
        {
            for (int j = 0; j < height; j++)
            {
                if (field[i, j].GetComponent <GroundGameObject>().IsOccupied&& unitsOnField[i, j] != null &&
                    unitsOnField[i, j].GetComponent <UnitGameObject>().AttackingSide)
                {
                    possibleTargets[next++] = unitsOnField[i, j].GetComponent <UnitGameObject>();
                }
            }
        }
        //Finds closest enemy unit
        UnitGameObject target   = possibleTargets[0];
        int            distance = HandyMethods.DistanceHex(activeUnit.LogicalPos, target.LogicalPos);

        for (int i = 1; i < possibleTargets.Length; i++)
        {
            if (possibleTargets[i] == null)
            {
                break;
            }
            int tmpDistance = HandyMethods.DistanceHex(activeUnit.LogicalPos, possibleTargets[i].LogicalPos);
            if (tmpDistance < distance)
            {
                target   = possibleTargets[i];
                distance = tmpDistance;
            }
        }

        checkPos(target.LogicalPos.x, target.LogicalPos.y);
    }
示例#16
0
 public Settler(int id, UnitAsset unitAsset, Hex hex, Player player)
 {
     this.Id            = id;
     this.UnitInfo      = unitAsset;
     this.PrivateName   = unitAsset.Name;
     this.Player        = player;
     this.Hex           = hex;
     this.CurrentHealth = unitAsset.MaxHealth;
     hex.Unit           = this;
     this.PrivateName   = "Settler";
     UnitGameObject     = GameObject.Instantiate(unitAsset.UnitPrefab);
     UnitGameObject.transform.position += hex.Position();
     UnitComponent           = UnitGameObject.AddComponent <UnitComponent>();
     UnitComponent.UnitLogic = this;
     foreach (Collider c in UnitGameObject.GetComponents <Collider>())
     {
         c.enabled = false;
     }
     foreach (Collider c in UnitGameObject.GetComponents <Collider>())
     {
         c.enabled = false;
     }
 }
示例#17
0
 /// <summary>
 /// Updates unit amount text representation
 /// </summary>
 /// <param name="ugo">Unit to be updated</param>
 public void updateAmount(UnitGameObject ugo)
 {
     ugo.GetComponentInChildren <TextMesh>().text = "" + ugo.UnitTree.getUnitAmount(ugo.PosInUnitTree);
 }
示例#18
0
    /// <summary>
    /// Readies initative and populates 2d array for units
    /// </summary>
    /// <param name="attacker">Attacking hero</param>
    /// <param name="defender">Defending units</param>
    public void populateInitative(Hero attacker, UnitTree defender)
    {
        unitsOnField = new GameObject[width, height];
        Initative    = new UnitGameObject[UnitTree.TREESIZE * 2];
        int logPos    = 0;
        int increment = Height / UnitTree.TREESIZE;
        int place     = 0;

        livingAttackers = livingDefenders = 0;
        // Adds attacking units
        UnitTree units = attacker.Units;

        for (int i = 0; i < UnitTree.TREESIZE; i++)
        {
            if (units.GetUnits()[i] != null)
            {
                GameObject go = Instantiate(unit, parent.transform);
                go.name = "a" + i;
                SpriteRenderer sr = go.GetComponent <SpriteRenderer>();
                sr.sprite           = troll;
                sr.sortingLayerName = "CombatUnits";
                TextMesh tm = go.GetComponentInChildren <TextMesh>();
                tm.text = "" + units.getUnitAmount(i);
                tm.GetComponent <Renderer>().sortingLayerName = "CombatUnits";
                UnitGameObject ugo = go.GetComponent <UnitGameObject>();
                ugo.UnitTree             = units;
                ugo.PosInUnitTree        = i;
                ugo.GraphicalBattlefield = this;
                ugo.AttackingSide        = true;
                ugo.Initative            = units.GetUnits()[i].Unitstats.Initative;
                ugo.LogicalPos           = new Point(0, place);
                Initative[logPos++]      = ugo;
                //set correct graphical pos
                go.transform.localPosition = field[0, place].transform.localPosition;
                UnitsOnField[0, place]     = go;
                field[0, place].GetComponent <GroundGameObject>().IsOccupied = true;
                livingAttackers++;
            }
            place += increment;
        }

        //Adds defending units
        units = defender;
        place = 0;
        for (int i = 0; i < UnitTree.TREESIZE; i++)
        {
            if (units.GetUnits()[i] != null)
            {
                GameObject go = Instantiate(unit, parent.transform);
                go.name = "d" + i;
                SpriteRenderer sr = go.GetComponent <SpriteRenderer>();
                sr.flipX            = true;
                sr.sprite           = troll;
                sr.sortingLayerName = "CombatUnits";
                TextMesh tm = go.GetComponentInChildren <TextMesh>();
                tm.text = "" + units.getUnitAmount(i);
                tm.GetComponent <Renderer>().sortingLayerName = "CombatUnits";
                UnitGameObject ugo = go.GetComponent <UnitGameObject>();
                ugo.UnitTree             = units;
                ugo.PosInUnitTree        = i;
                ugo.GraphicalBattlefield = this;
                ugo.AttackingSide        = false;
                ugo.Initative            = units.GetUnits()[i].Unitstats.Initative;
                ugo.LogicalPos           = new Point(width - 1, place);
                Initative[logPos++]      = ugo;
                //set correct graphical pos
                go.transform.localPosition     = field[width - 1, place].transform.localPosition;
                UnitsOnField[Width - 1, place] = go;
                field[width - 1, place].GetComponent <GroundGameObject>().IsOccupied = true;
                livingDefenders++;
            }
            place += increment;
        }
        Array.Sort(initative);
        Array.Reverse(initative);
        WhoseTurn = 0;
        initative[whoseTurn].ItsTurn = true;
    }
示例#19
0
 /// <summary>
 /// Initiates attack on unit
 /// </summary>
 /// <param name="defender">Unit thats being attacked</param>
 /// <param name="goal">Place on field attacking unit is going to</param>
 public void attackUnit(UnitGameObject defender, Point goal)
 {
     if (!isWalking && !finishedWalking && !attacking)
     {
         UnitGameObject activeUnit    = initative[whoseTurn];
         Unit           attackingUnit = activeUnit.UnitTree.GetUnits()[activeUnit.PosInUnitTree];
         //If unit does not need to move, call on method for attacking without moving
         if (activeUnit.LogicalPos.Equals(goal))
         {
             battleField.attackWithoutMoving(activeUnit.LogicalPos, defender.LogicalPos, false);
             beginAttacking(defender.LogicalPos.x);
         }
         else
         {
             //checks if unit is ranged, and if it has ammo. if not move and attack
             if (attackingUnit.IsRanged)
             {
                 Ranged r = (Ranged)attackingUnit;
                 if (r.Ammo > 0 && !r.Threatened)
                 {
                     battleField.attackWithoutMoving(activeUnit.LogicalPos, defender.LogicalPos, true);
                     beginAttacking(defender.LogicalPos.x);
                 }
                 else
                 {
                     path = battleField.UnitMoveAndAttack(activeUnit.LogicalPos, goal, defender.LogicalPos);
                     BeginWalking();
                     attacking = true;
                 }
             }
             else
             {
                 path = battleField.UnitMoveAndAttack(activeUnit.LogicalPos, goal, defender.LogicalPos);
                 BeginWalking();
                 attacking = true;
             }
         }
         //Updates living units counts
         if (defender.UnitTree.getUnitAmount(defender.PosInUnitTree) == 0)
         {
             if (defender.AttackingSide)
             {
                 livingAttackers--;
             }
             else
             {
                 livingDefenders--;
             }
         }
         if (activeUnit.UnitTree.getUnitAmount(activeUnit.PosInUnitTree) == 0)
         {
             if (activeUnit.AttackingSide)
             {
                 livingAttackers--;
             }
             else
             {
                 livingDefenders--;
             }
         }
         Debug.Log(livingAttackers + " " + livingDefenders);
         updateAmount(defender);
         updateAmount(getUnitWhoseTurnItIs());
     }
 }
示例#20
0
 public OnUnitClick(UnitGameObject _unit)
 {
     unit = _unit;
 }
示例#21
0
 public OnAnimFight(UnitGameObject _attacker, UnitGameObject _defender, bool _needsAnimating)
 {
     attacker       = _attacker;
     defender       = _defender;
     needsAnimating = _needsAnimating;
 }
示例#22
0
        /// <summary>
        /// This method is called by the GameManager within the NextPlayer method. It will calculate all of the capturing stuff.
        /// </summary>
        public void CalculateCapturing()
        {
            int count = BuildingsBeingCaptured.Count;

            for (int i = 0; i < count; i++)
            {
                Building building = BuildingsBeingCaptured[i];
                if (building.BuildingGameObject.Tile.HasUnit())
                {
                    UnitGameObject unitOnBuilding = building.BuildingGameObject.Tile.unitGameObject;
                    float          health         = unitOnBuilding.UnitGame.CurrentHealth;
                    building.IncreaseCapturePointsBy(health);

                    unitOnBuilding.UnitGame.DecreaseHealth(building.DamageToCapturingUnit);

                    if (!unitOnBuilding.UnitGame.IsAlive())
                    {
                        unitOnBuilding.UnitGame.OnDeath();
                    }

                    if (building.HasCaptured())
                    {
                        if (building.BuildingGameObject.type != BuildingTypes.Headquarters)
                        {
                            BuildingTypes type = building.BuildingGameObject.type;

                            BuildingsBeingCaptured.Remove(building);
                            count--;
                            i--;
                            building.BuildingGameObject.DestroyBuilding();

                            CreatorFactoryBuilding.CreateBuilding(unitOnBuilding.Tile, unitOnBuilding.index, type);

                            if (type == BuildingTypes.TrainingZone)
                            {
                                OnTrainingzoneCapturedHero(unitOnBuilding);
                            }
                        }
                        else
                        {
                            LevelManager lm = GameObjectReferences.GetGlobalScriptsGameObject().GetComponent <LevelManager>();
                            Camera.main.backgroundColor = lm.CurrentLevel.Players[unitOnBuilding.index].PlayerColor;
                            GameObject.FindGameObjectWithTag("Level").SetActive(false);
                            GameObject.Find("_Scripts").GetComponent <GameBar>().enabled       = false;
                            GameObject.Find("_Scripts").GetComponent <Notificator>().enabled   = false;
                            GameObject.Find("NotificationText").GetComponent <TextMesh>().text = unitOnBuilding.index + " has won the game! \n\nPress anywhere to return to the menu.";
                            lm.CurrentLevel.IsEnded = true;
                        }
                    }
                }
                else
                {
                    building.DecreaseCapturePointsBy(building.CapturePointsDecreasedBy);
                    if (building.CurrentCapturePoints <= 0f)
                    {
                        BuildingsBeingCaptured.Remove(building);
                        count--;
                        i--;
                    }
                }
            }
        }
示例#23
0
    // Update is called once per frame
    void Update()
    {
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);

        if (Physics.Raycast(ray, out hit, Mathf.Infinity, MouseLayerMask))
        {
            currentMousePoint = hit.point;
            #region Visszavonások
            if (GUISetup.GhostActive)
            {
                return;
            }
            #endregion
            //Store point at mouse button down
            if (Input.GetMouseButtonDown(0))
            {
                if (EventSystem.current.IsPointerOverGameObject())
                {
                    EndModes();
                }
                mouseDownPoint            = hit.point;
                TimeLeftBeforeDeclareDrag = TimeLimitBeforeDeclareDrag;
                MouseDragStart            = Input.mousePosition;
                StartedDrag = true;

                #region CommandRegion
                if (MoveMode)
                {
                    for (int i = 0; i < CurrentlySelectedUnits.Count; i++)
                    {
                        AIDestinationSetter setter = (CurrentlySelectedUnits[i] as GameObject).GetComponent <AIDestinationSetter>();
                        if (hit.collider.gameObject.layer == LayerMask.NameToLayer("Unit"))
                        {
                            setter.target = hit.collider.gameObject.transform;
                        }
                        else
                        {
                            setter.ai.destination = mouseDownPoint;
                        }
                        setter.ai.isStopped = false;
                    }
                    MoveMode = false;
                }
                if (AttackMode)
                {
                    for (int i = 0; i < CurrentlySelectedUnits.Count; i++)
                    {
                        AIDestinationSetter setter = (CurrentlySelectedUnits[i] as GameObject).GetComponent <AIDestinationSetter>();
                        if (hit.collider.gameObject.layer == LayerMask.NameToLayer("Unit"))
                        {
                            setter.target = hit.collider.gameObject.transform;
                        }
                        else
                        {
                            setter.ai.destination = mouseDownPoint;
                            (CurrentlySelectedUnits[i] as GameObject).GetComponent <Unit>().aMove = true;
                        }
                        setter.ai.isStopped = false;
                    }
                    AttackMode = false;
                }

                if (RepairMode)
                {
                    for (int i = 0; i < CurrentlySelectedUnits.Count; i++)
                    {
                        AIDestinationSetter setter = (CurrentlySelectedUnits[i] as GameObject).GetComponent <AIDestinationSetter>();
                        Unit unit = (CurrentlySelectedUnits[i] as GameObject).GetComponent <Unit>();
                        if (unit.isGatherer && hit.collider.gameObject.layer == LayerMask.NameToLayer("Unit") &&
                            !Game.players.Where(x => x.empireName.Equals(unit.Owner)).SingleOrDefault().enemies.Contains(Game.players.Where(x => x.empireName.Equals(hit.collider.transform.GetComponent <Unit>().Owner)).SingleOrDefault()))
                        {
                            setter.target       = hit.collider.gameObject.transform;
                            setter.ai.isStopped = false;
                        }
                    }
                    RepairMode = false;
                }
                #endregion
            }
            else if (Input.GetMouseButton(0))
            {
                //If the user is not dragging, lets do the tests
                if (!UserIsDragging)
                {
                    TimeLeftBeforeDeclareDrag = Time.deltaTime;
                    if (TimeLeftBeforeDeclareDrag <= 0f || UserDraggingByPosition(MouseDragStart, Input.mousePosition))
                    {
                        UserIsDragging = true;
                    }
                }
            }
            else if (Input.GetMouseButtonUp(0))
            {
                //User is dragging
                if (UserIsDragging)
                {
                    FinishedDragOnThisFrame = true;
                }
                UserIsDragging = false;
            }

            //Mouse click
            if (!UserIsDragging)
            {
                //Debug.Log(hit.collider.name);

                #region Jobb klikk
                if (Input.GetMouseButtonDown(1) && !EventSystem.current.IsPointerOverGameObject())
                {
                    if (hit.collider.gameObject.layer == LayerMask.NameToLayer("Unit"))
                    {
                        SelectTargets(hit);
                    }
                    else if (hit.collider.gameObject.layer == LayerMask.NameToLayer("Resources"))
                    {
                        SelectGatherTargets(hit);
                    }
                    else if (hit.collider.name == "TerrainMain")
                    {
                        SelectRally(hit);
                        RightClickPoint = hit.point;
                        DeselectTargets();
                    }
                }
                #endregion

                // End of Terrain
                else
                {
                    //Hitting other objects
                    if (Input.GetMouseButtonUp(0) && DidUserClickLeftMouse(mouseDownPoint) && !EventSystem.current.IsPointerOverGameObject())
                    {
                        //Is the user hitting a unit?
                        if ((hit.collider.gameObject.GetComponent <Unit>() || hit.collider.gameObject.layer == LayerMask.NameToLayer("SelectMesh")) && hit.collider.transform.parent.parent.name == game.currentSolarSystem.Name)
                        {
                            Transform UnitGameObject;
                            if (hit.collider.gameObject.layer == LayerMask.NameToLayer("SelectMesh"))
                            {
                                UnitGameObject = hit.collider.transform.parent.transform;
                            }
                            else
                            {
                                UnitGameObject = hit.collider.transform;
                            }

                            //Are we selecting a different object?
                            if (!UnitAlreadyInCurrentySelectedUnits(UnitGameObject.gameObject))
                            {
                                //If shift key is not down, remove the rest of the units
                                if (!Common.ShiftKeysDown())
                                {
                                    DeselectGameObjectsIfSelected();
                                }

                                GameObject SelectedObj = UnitGameObject.Find("Selected").gameObject;
                                if (UnitGameObject.GetComponent <Unit>().Owner != Game.currentPlayer.empireName)
                                {
                                    DeselectGameObjectsIfSelected();
                                    SelectedObj.GetComponent <Projector>().material.color = Color.red;
                                }
                                else
                                {
                                    SelectedObj.GetComponent <Projector>().material.color = Color.green;
                                }
                                SelectedObj.SetActive(true);

                                //Add unit to currently selected units
                                CurrentlySelectedUnits.Add(UnitGameObject.gameObject);

                                //Change the unit selected value to true
                                UnitGameObject.gameObject.GetComponent <Unit>().Selected = true;
                            }
                            else
                            {
                                //Unit is currently in the selected units arraylist
                                //Remove the units
                                if (Common.ShiftKeysDown())
                                {
                                    RemoveUnitFromCurrentlySelectedUnits(UnitGameObject.gameObject);
                                }
                                else if (!Common.ShiftKeysDown())
                                {
                                    DeselectGameObjectsIfSelected();

                                    GameObject SelectedObj = UnitGameObject.Find("Selected").gameObject;
                                    if (UnitGameObject.GetComponent <Unit>().Owner != Game.currentPlayer.empireName)
                                    {
                                        SelectedObj.GetComponent <Projector>().material.color = Color.red;
                                    }
                                    else
                                    {
                                        SelectedObj.GetComponent <Projector>().material.color = Color.green;
                                    }
                                    SelectedObj.SetActive(true);
                                    UnitGameObject.gameObject.GetComponent <Unit>().Selected = true;

                                    //Add unit to currently selected units
                                    CurrentlySelectedUnits.Add(UnitGameObject.gameObject);
                                }
                            }
                        }
                        else
                        {
                            //If this object is not a unit
                            if (!Common.ShiftKeysDown() && !EventSystem.current.IsPointerOverGameObject())
                            {
                                DeselectGameObjectsIfSelected();
                            }
                        }
                    }
                }
            }
            else
            {
                if (Input.GetMouseButtonUp(0) && DidUserClickLeftMouse(mouseDownPoint) && !EventSystem.current.IsPointerOverGameObject())
                {
                    if (!Common.ShiftKeysDown())
                    {
                        DeselectGameObjectsIfSelected();
                    }
                }
            }
            //End of dragging
        } //End of raycasthit

        if (CurrentlySelectedUnits.Count != 0)
        {
            CurrentlyFocusedUnit = CurrentlySelectedUnits[0] as GameObject;
        }
        else
        {
            CurrentlyFocusedUnit = null;
        }

        if (!Common.ShiftKeysDown() && StartedDrag && UserIsDragging)
        {
            DeselectGameObjectsIfSelected();
            StartedDrag = false;
        }
        #region Csoport létrehozás
        if (CurrentlySelectedUnits.Count != 0 && (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl)))
        {
            for (int i = 1; i < 10; i++)
            {
                if (Input.GetKey(keyCodes[i - 1]))
                {
                    Grouping[i] = new ArrayList();
                    for (int j = 0; j < CurrentlySelectedUnits.Count; j++)
                    {
                        if ((CurrentlySelectedUnits[j] as GameObject).GetComponent <Unit>().Owner == Game.currentPlayer.empireName)
                        {
                            Grouping[i].Add(CurrentlySelectedUnits[j]);
                        }
                    }
                    Debug.Log(Grouping[i].Count);
                }
            }
        }
        #endregion

        #region Csoport kiválasztás
        if (GetAnyKey(keyCodes))
        {
            for (int i = 1; i < 10; i++)
            {
                if (Input.GetKey(keyCodes[i - 1]) && Grouping[i] != null)
                {
                    DeselectGameObjectsIfSelected();
                    for (int j = 0; j < Grouping[i].Count; j++)
                    {
                        CurrentlySelectedUnits.Add((Grouping[i])[j]);
                    }
                }
            }
            Debug.Log(CurrentlySelectedUnits.Count);
            for (int j = 0; j < CurrentlySelectedUnits.Count; j++)
            {
                GameObject SelectedObj = CurrentlySelectedUnits[j] as GameObject;
                SelectedObj.GetComponent <Unit>().Selected = true;
                SelectedObj.transform.Find("Selected").gameObject.SetActive(true);
                Debug.Log(j + ". aktív");
            }
        }
        #endregion

        Debug.DrawRay(ray.origin, ray.direction * 1000, Color.yellow);

        #region Dragbox variables
        if (UserIsDragging && currentMousePoint != Vector3.positiveInfinity)
        {
            BoxWidth  = Camera.main.WorldToScreenPoint(mouseDownPoint).x - Camera.main.WorldToScreenPoint(currentMousePoint).x;
            BoxHeight = Camera.main.WorldToScreenPoint(mouseDownPoint).y - Camera.main.WorldToScreenPoint(currentMousePoint).y;

            BoxLeft = Input.mousePosition.x;
            BoxTop  = (Screen.height - Input.mousePosition.y) - BoxHeight;

            if (Common.FloatToBool(BoxWidth))
            {
                if (Common.FloatToBool(BoxHeight))
                {
                    BoxStart = new Vector2(Input.mousePosition.x, Input.mousePosition.y + BoxHeight);
                }
                else
                {
                    BoxStart = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
                }
            }
            else
            if (!Common.FloatToBool(BoxWidth))
            {
                if (Common.FloatToBool(BoxHeight))
                {
                    BoxStart = new Vector2(Input.mousePosition.x + BoxWidth, Input.mousePosition.y + BoxHeight);
                }
                else
                {
                    BoxStart = new Vector2(Input.mousePosition.x + BoxWidth, Input.mousePosition.y);
                }
            }

            BoxFinish = new Vector2(BoxStart.x + Mathf.Abs(BoxWidth), BoxStart.y - Mathf.Abs(BoxHeight));
        }
        #endregion
    }
示例#24
0
    /// <summary>
    /// Checks in a growing circular fashion what you can reach and flips the appropriate bool
    /// </summary>
    /// <param name="startingPoint">Position of unit</param>
    /// <param name="speed">How many steps the unit can take</param>
    public void flipReachable(Point startingPoint, int speed)
    {
        // List for all nodes that are to be evaluvated
        List <Node> openSet = new List <Node>();

        UnitGameObject aktiveUnit = units[startingPoint.x, startingPoint.y].GetComponent <UnitGameObject>();
        Unit           u          = aktiveUnit.UnitTree.GetUnits()[aktiveUnit.PosInUnitTree];
        Ranged         r          = null;

        if (u.IsRanged)
        {
            r            = (Ranged)u;
            r.Threatened = false;
        }
        //Adds starting node to openSet
        Node s = field[startingPoint.x, startingPoint.y];

        s.WalkedSteps = 0;
        s.InOpenSet   = true;
        openSet.Add(s);

        //Loops as long as there are unevaluvated nodes
        while (openSet.Count > 0)
        {
            //Fetches current node from openset
            Node cur = openSet[0];
            //Removes cur from openset and marks as evaluvated
            openSet.Remove(cur);
            cur.InOpenSet  = false;
            cur.Evaluvated = true;

            //Flips bool for reachable or attackable if unit can reach cur
            if (cur.Ggo.IsOccupied && units[cur.Pos.x, cur.Pos.y] != null && cur.WalkedSteps <= speed + 1 &&
                aktiveUnit.AttackingSide != units[cur.Pos.x, cur.Pos.y].GetComponent <UnitGameObject>().AttackingSide)
            {
                units[cur.Pos.x, cur.Pos.y].GetComponent <UnitGameObject>().Attackable = true;
                if (u.IsRanged && cur.WalkedSteps == 1)
                {
                    r.Threatened = true;
                }
                cur.Ggo.MarkReachable(ATTACKABLE);
            }
            else if (cur.WalkedSteps <= speed)
            {
                cur.Ggo.Reachable = true;
                cur.Ggo.MarkReachable(!ATTACKABLE);
            }

            if (cur.Ggo.IsOccupied && !cur.Pos.Equals(startingPoint))
            {
                continue;
            }

            //Finds walkable neighbours
            Node[] neighbours = findNeighboursHex(cur.Pos);

            //Loops trou neighbours
            for (int i = 0; i < neighbours.Length && neighbours[i] != null; i++)
            {
                Node neighbour = neighbours[i];
                // If already evaluvated, skip node
                if (neighbour.Evaluvated)
                {
                    continue;
                }

                // If not in openSet, add to openSet and calculate WalkedSteps
                if (!neighbour.InOpenSet)
                {
                    neighbour.WalkedSteps = cur.WalkedSteps + 1;
                    neighbour.InOpenSet   = true;

                    //Inserts neighbour node into openset at sorted position
                    int index = Math.Abs(openSet.BinarySearch(neighbour));
                    if (index >= openSet.Count)
                    {
                        openSet.Add(neighbour);
                    }
                    else
                    {
                        openSet.Insert(index, neighbour);
                    }
                }
                // OpenSet contains node, then check if current path is better.
                else
                {
                    int newWalkedSteps = cur.WalkedSteps + 1;
                    if (neighbour.WalkedSteps > newWalkedSteps)
                    {
                        neighbour.WalkedSteps = newWalkedSteps;
                    }
                }
            }
            //Breaks loop if next node to be checked is unreachable
            if (cur.WalkedSteps == speed + 2)
            {
                break;
            }
        }
        //Readies for new run
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                field[x, y].Evaluvated = false;
                field[x, y].InOpenSet  = false;
            }
        }
    }