Beispiel #1
0
    /// <summary>
    /// returns a "delta" list, containing lost troops when comparing the current and the "remaining" lists
    /// </summary>
    /// <param name="remainingTroops"></param>
    public TroopList GetLossesList(TroopList remainingTroops)
    {
        int       troopIndexInAfter;
        int       troopsOfCurTypeLost;
        TroopList resultingList = new TroopList();

        for (int i = 0; i < Count; i++)
        {
            troopIndexInAfter = remainingTroops.IndexOfTroopInThisList(this[i].troopTypeID);
            if (troopIndexInAfter != -1)
            {
                troopsOfCurTypeLost = (remainingTroops[troopIndexInAfter].troopAmount - this[i].troopAmount) * -1;
                if (troopsOfCurTypeLost > 0)
                {
                    resultingList.AddTroop(this[i].troopTypeID, troopsOfCurTypeLost);
                }
            }
            else
            {
                //all troops of that type have been lost, probably
                resultingList.AddTroop(this[i].troopTypeID, this[i].troopAmount);
            }
        }

        return(resultingList);
    }
Beispiel #2
0
    /// <summary>
    /// returns a new troopList of the combination of both troopLists
    /// </summary>
    /// <param name="theOtherContainerTroops"></param>
    /// <returns></returns>
    public TroopList GetCombinedTroops(TroopList theOtherContainerTroops)
    {
        TroopList returnedList = new TroopList();

        returnedList.AddRange(this);

        int             testedTroopIndex = -1;
        TroopNumberPair checkedTNP;

        foreach (TroopNumberPair tnp in theOtherContainerTroops)
        {
            testedTroopIndex = IndexOfTroopInThisList(tnp.troopTypeID);
            if (testedTroopIndex >= 0)
            {
                checkedTNP                     = returnedList[testedTroopIndex];
                checkedTNP.troopAmount        += tnp.troopAmount;
                returnedList[testedTroopIndex] = checkedTNP;
            }
            else
            {
                returnedList.Add(tnp);
            }
        }

        return(returnedList);
    }
Beispiel #3
0
        public override int GetCreditWithPosition(Troop source, out Point?position)
        {
            //position = 0;
            position = new Point(0, 0);
            TroopList hostileTroopsInView = source.GetHostileTroopsInView();
            TroopList list2 = new TroopList();

            foreach (Troop troop in hostileTroopsInView)
            {
                if ((troop.IsInArchitecture || !troop.DaysToReachPosition(source.Position, 1)) || (troop.Army.Kind.Type == MilitaryType.水军))
                {
                    list2.Add(troop);
                }
            }
            foreach (Troop troop in list2)
            {
                hostileTroopsInView.Remove(troop);
            }
            if (hostileTroopsInView.Count == 0)
            {
                return(0);
            }
            List <Point> orientations = new List <Point>();
            int          num          = 0;

            foreach (Troop troop in hostileTroopsInView)
            {
                orientations.Add(troop.Position);
                num += troop.FightingForce;
            }
            int num2          = 0;
            int fightingForce = source.FightingForce;
            int num4          = source.TroopIntelligence + source.ChanceIncrementOfStratagem;

            if (num4 > 100)
            {
                num4 = 100;
            }
            num2 = (((GameObject.Square(num4) / 60) * num) / fightingForce) / 100;
            if (num2 > 0)
            {
                GameArea area = new GameArea();
                foreach (Point point in source.GetStratagemArea(source.Position).Area)
                {
                    if (!source.Scenario.PositionIsOnFire(point) && (source.Scenario.IsPositionEmpty(point) && source.Scenario.IsFireVaild(point, false, MilitaryType.步兵)))
                    {
                        area.Area.Add(point);
                    }
                }
                if (area.Count > 0)
                {
                    position = source.Scenario.GetClosestPosition(area, orientations);
                }
                else
                {
                    num2 = 0;
                }
            }
            return(num2);
        }
    public void SetupAndOpen(TroopList attackerForces, TroopList defenderForces)
    {
        attackerPanel.representedTroops = attackerForces;
        defenderPanel.representedTroops = defenderForces;

        gameObject.SetActive(true);
    }
Beispiel #5
0
    public void OpenImportOps()
    {
        List <KeyValuePair <string, UnityAction> > importOptions =
            new List <KeyValuePair <string, UnityAction> >();

        GameInterface GI = GameInterface.instance;


        importOptions.Add(new KeyValuePair <string, UnityAction>("JSON Array - Don't use if attackers and defenders share troop types", () => {
            GI.textInputPanel.SetPanelInfo("JSON Text to Import", "insert the JSON string here", "", "Import", () => {
                SerializedTroop[] readTroops = JsonHandlingUtils.JsonToSerializedTroopArray
                                                   (GI.textInputPanel.theInputField.text);
                if (readTroops == null)
                {
                    ModalPanel.Instance().OkBox("Json Import Failed", "Please check your JSON string, it must be something like [{'name':'troop', 'amount':5}]");
                    return;
                }

                TroopList attackersRemaining = new TroopList(),
                defendersRemaining           = new TroopList();

                foreach (SerializedTroop tnp in readTroops)
                {
                    //Debug.Log("got this kvp: " + tnp.name + " : " + tnp.amount);

                    TroopNumberPair convertedTNP = JsonHandlingUtils.SerializedTroopToTroopNumberPair(tnp);
                    if (convertedTNP.troopAmount > 0)
                    {
                        if (battlePhase.battleData.defenderSideInfo.sideArmy.IndexOfTroopInThisList(convertedTNP.troopTypeID) != -1)
                        {
                            defendersRemaining.Add(convertedTNP);
                        }
                        else if (battlePhase.battleData.attackerSideInfo.sideArmy.IndexOfTroopInThisList(convertedTNP.troopTypeID) != -1)
                        {
                            attackersRemaining.Add(convertedTNP);
                        }
                    }
                }

                battlePhase.battleData.defenderSideInfo.SetPostBattleArmyData_RemainingArmy(defendersRemaining);
                battlePhase.battleData.attackerSideInfo.SetPostBattleArmyData_RemainingArmy(attackersRemaining);

                if (!battlePhase.battleData.BattleEndCheck())
                {
                    //we only need to update side info displays if the battle hasn't ended yet,
                    //because the delegate would take care of it otherwise
                    UpdateArmyDisplays();
                }

                GI.textInputPanel.Close();
            });
            GI.textInputPanel.Open();
            GI.exportOpsPanel.gameObject.SetActive(false);
        }));


        //when done preparing options, open the import ops panel
        GI.exportOpsPanel.Open("Remaining Armies: Import Options", importOptions);
    }
Beispiel #6
0
 public Commander(int ownerFactionID, int zoneStartingLocation)
 {
     this.ID           = GameController.GetUnusedCmderID();
     this.ownerFaction = ownerFactionID;
     this.zoneIAmIn    = zoneStartingLocation;
     troopsContained   = new TroopList();
     GameController.instance.curData.deployedCommanders.Add(this);
 }
Beispiel #7
0
    public void ShowTooltipForZone(Zone targetZone, Vector3 basePos, bool showGarrInfo = true, bool refreshCanvasesBeforeGetSize = false)
    {
        baseTooltipPos = basePos;
        Faction ownerFaction = GameController.GetFactionByID(targetZone.ownerFaction);

        if (ownerFaction != null)
        {
            ChangeBackgroundAccordingToFactionRelations(ownerFaction);
            AddTooltipTitleEntry(targetZone.name, ownerFaction.color, 70);
            AddTooltipTitleEntry("(" + ownerFaction.name + ")", ownerFaction.color);
            AddTooltipTitleEntry("Garrison: " + targetZone.troopsContained.TotalTroopAmount + "/"
                                 + targetZone.MaxTroopsInGarrison, Color.white, 55);
            foreach (TroopNumberPair tnp in targetZone.troopsContained)
            {
                AddTooltipTroopEntry(GameController.GetTroopTypeByID(tnp.troopTypeID).name,
                                     tnp.troopAmount.ToString());
            }
            List <Commander> cmdersInZone =
                GameController.GetCommandersOfFactionAndAlliesInZone(targetZone, ownerFaction);
            if (cmdersInZone.Count > 0)
            {
                TroopList totalArmy =
                    GameController.GetCombinedTroopsInZoneFromFactionAndAllies(targetZone, ownerFaction);
                AddTooltipTitleEntry("Commanders: " + cmdersInZone.Count.ToString(), ownerFaction.color, 60);
                AddTooltipTitleEntry("Combined Army: " +
                                     totalArmy.TotalTroopAmount, Color.white, 50);
                foreach (TroopNumberPair tnp in totalArmy)
                {
                    AddTooltipTroopEntry(GameController.GetTroopTypeByID(tnp.troopTypeID).name,
                                         tnp.troopAmount.ToString());
                }
            }
        }
        else
        {
            backgroundImg.color = defaultColor;
            AddTooltipTitleEntry(targetZone.name, Color.white, 70);
            AddTooltipTitleEntry("(" + Rules.NO_FACTION_NAME + ")", Color.white);
        }

        AddTooltipInfoEntry(targetZone.multRecruitmentPoints.ToString("0%"),
                            targetZone.multTrainingPoints.ToString("0%"));

        MercCaravan localCaravan = GameController.GetMercCaravanInZone(targetZone.ID);

        if (localCaravan != null)
        {
            AddTooltipInfoEntry("Merc Caravan Troop",
                                GameController.GetTroopTypeByID(localCaravan.containedTroopType).name);
        }

        ContextualTooltipUpdate(refreshCanvasesBeforeGetSize);
    }
Beispiel #8
0
    /// <summary>
    /// returns a "delta" list, containing lost troops according to the percentage of remaining troops provided
    /// </summary>
    /// <param name="remainingTroops"></param>
    public TroopList GetLossesListByPercentage(float remainingPercent)
    {
        TroopList resultingList = new TroopList();
        float     lossPercent   = 1.0f - remainingPercent;

        for (int i = 0; i < Count; i++)
        {
            resultingList.AddTroop(this[i].troopTypeID, Mathf.RoundToInt(this[i].troopAmount * lossPercent));
        }

        return(resultingList);
    }
Beispiel #9
0
    /// <summary>
    /// returns a new list with subtracted troop amounts according to the lossesList
    /// </summary>
    /// <param name="lossesList">defines how many troops of each type should be removed</param>
    /// <returns></returns>
    public TroopList GetListWithAppliedLosses(TroopList lossesList)
    {
        TroopList returnedList = new TroopList();

        returnedList.AddRange(this);

        for (int i = 0; i < lossesList.Count; i++)
        {
            returnedList.RemoveTroop(lossesList[i].troopTypeID, lossesList[i].troopAmount);
        }

        return(returnedList);
    }
Beispiel #10
0
 public Zone(string name, Vector3 zonePos)
 {
     this.ID           = GameController.GetUnusedZoneID();
     this.name         = name;
     this.ownerFaction = -1;
     this.coords       = new Vector2(zonePos.x,
                                     zonePos.z);
     troopsContained = new TroopList();
     linkedZones     = new List <int>();
     while (GameController.GetZoneByName(this.name) != null)
     {
         this.name = name + " copy";
     }
     GameController.instance.curData.zones.Add(this);
 }
    /// <summary>
    /// returns a troopNumberPair list with entries using the provided amounts
    /// </summary>
    /// <returns></returns>
    public TroopList BakeIntoArmy()
    {
        TroopList returnedList = new TroopList();

        for (int i = 0; i < listContainer.childCount; i++)
        {
            Transform entry = listContainer.GetChild(i);
            BattleResolutionRemainingTroopListEntry entryScript =
                entry.GetComponent <BattleResolutionRemainingTroopListEntry>();
            if (entryScript)
            {
                returnedList.Add(entryScript.BakeIntoNewPair());
            }
        }

        return(returnedList);
    }
Beispiel #12
0
    /// <summary>
    /// sets the displayed and stored army data, such as autocalc power and numbers.
    /// providing the zone separated from the rest of our containers will affect the description
    /// of forces only
    /// </summary>
    /// <param name="sideFactions"></param>
    /// <param name="ourZone"></param>
    /// <param name="containers"></param>
    /// <param name="postBattle"></param>
    public void SetupArmyData(List <Faction> sideFactions, Zone ourZone, List <TroopContainer> containers)
    {
        totalBattleLosses.Clear();
        ourContainers.Clear();
        ourContainers.AddRange(containers);
        sideArmy.Clear();
        this.sideFactions     = sideFactions;
        pointsAwardedToVictor = 0;
        int   armyNumbers = 0;
        int   armyCmders  = 0;
        float armyPower   = 0;

        if (ourZone != null)
        {
            if (!ourContainers.Contains(ourZone))              //if our zone wasn't added in ourContainers already...
            {
                ourContainers.Add(ourZone);
                armyCmders--;
            }
        }

        foreach (TroopContainer cont in ourContainers)
        {
            armyCmders++;
            armyNumbers += cont.troopsContained.TotalTroopAmount;
            armyPower   += cont.troopsContained.TotalAutocalcPower;
            sideArmy     = cont.troopsContained.GetCombinedTroops(sideArmy);
        }

        //clamp the side's forces according to the maxTroopsInvolvedInBattlePerTurn rule

        int maxTroops = GameController.CurGameData.rules.maxTroopsInvolvedInBattlePerTurn;

        sideArmy = GameController.GetRandomSampleArmyFromArmy(sideArmy, maxTroops);

        curArmyNumbers = Mathf.Min(armyNumbers, maxTroops);

        if (curArmyNumbers != armyNumbers)
        {
            armyPower = sideArmy.TotalAutocalcPower;
        }

        initialArmyPower = armyPower;
        curArmyPower     = armyPower;
    }
Beispiel #13
0
    /// <summary>
    /// variation used for getting info from all owned commanders in the zone where the selected cmder is in
    /// </summary>
    /// <param name="cmdersArmy"></param>
    /// <param name="cmdersCount"></param>
    /// <param name="sampleCmder"></param>
    public void SetContent(TroopList cmdersArmy, int cmdersCount, Commander sampleCmder)
    {
        //clear troop entries first
        ClearTroopEntries();

        numTroopsTxt.text = "Troops: " + cmdersArmy.TotalTroopAmount + "/" + sampleCmder.MaxTroopsCommanded * cmdersCount;

        foreach (TroopNumberPair tnp in cmdersArmy)
        {
            AddTroopEntry(tnp);
        }


        //and the zone info
        Zone curZone = GameController.GetZoneByID(sampleCmder.zoneIAmIn);

        zoneInfoEntry.leftTxt.text  = curZone.multRecruitmentPoints.ToString("0%");
        zoneInfoEntry.rightTxt.text = curZone.multTrainingPoints.ToString("0%");
    }
Beispiel #14
0
    /// <summary>
    /// updates the army's "power" and "numbers" data according to the provided losses list.
    /// calls the "onSideDefeated" delegate if it's not null and the army's numbers got to 0
    /// </summary>
    public void UpdatePostBattleArmy(TroopList lossesList)
    {
        totalBattleLosses = totalBattleLosses.GetCombinedTroops(lossesList);
        int armyNumbers;

        sideArmy = sideArmy.GetListWithAppliedLosses(lossesList);

        armyNumbers = sideArmy.TotalTroopAmount;

        curArmyNumbers = armyNumbers;
        curArmyPower   = sideArmy.TotalAutocalcPower;

        if (armyNumbers <= 0)
        {
            if (onSideDefeated != null)
            {
                onSideDefeated();
                onSideDefeated = null;
            }
        }
    }
Beispiel #15
0
    public void ShowTooltipForCmder(Commander targetCmder, Vector3 basePos, bool refreshCanvasesBeforeGetSize = false)
    {
        baseTooltipPos = basePos;
        Faction ownerFaction = GameController.GetFactionByID(targetCmder.ownerFaction);

        ChangeBackgroundAccordingToFactionRelations(ownerFaction);
        AddTooltipTitleEntry("Commander", ownerFaction.color, 50);
        AddTooltipTitleEntry("(" + ownerFaction.name + ")", ownerFaction.color);
        AddTooltipTitleEntry("Troops: " + targetCmder.troopsContained.TotalTroopAmount + "/" + targetCmder.MaxTroopsCommanded, Color.white);
        foreach (TroopNumberPair tnp in
                 targetCmder.troopsContained)
        {
            AddTooltipTroopEntry(GameController.GetTroopTypeByID(tnp.troopTypeID).name,
                                 tnp.troopAmount.ToString());
        }

        List <Commander> cmdersInZone =
            GameController.GetCommandersOfFactionAndAlliesInZone(
                GameController.GetZoneByID(targetCmder.zoneIAmIn), ownerFaction);

        if (cmdersInZone.Count > 1)
        {
            TroopList totalCmderArmy = new TroopList();
            foreach (Commander c in cmdersInZone)
            {
                totalCmderArmy = c.troopsContained.GetCombinedTroops(totalCmderArmy);
            }

            AddTooltipTitleEntry("Combined Cmd. Army: " + totalCmderArmy.TotalTroopAmount, Color.white, 50);
            foreach (TroopNumberPair tnp in totalCmderArmy)
            {
                AddTooltipTroopEntry(GameController.GetTroopTypeByID(tnp.troopTypeID).name,
                                     tnp.troopAmount.ToString());
            }
        }

        ContextualTooltipUpdate(refreshCanvasesBeforeGetSize);
    }
Beispiel #16
0
        private PathResult conflictionPathSearcher_OnCheckPosition(Point position, List <Point> middlePath, MilitaryKind kind)
        {
            TroopList list  = new TroopList();
            TroopList list2 = new TroopList();

            foreach (Troop troop in this.troop.BelongedFaction.KnownTroops.Values)
            {
                if (!troop.IsFriendly(this.troop.BelongedFaction))
                {
                    switch (this.troop.HostileAction)
                    {
                    case HostileActionKind.EvadeEffect:
                        if (troop.OffenceArea.HasPoint(position))
                        {
                            list.Add(troop);
                        }
                        break;

                    case HostileActionKind.EvadeView:
                        if (troop.ViewArea.HasPoint(position))
                        {
                            list.Add(troop);
                        }
                        break;
                    }
                }
                else if (troop.Position == position)
                {
                    list2.Add(troop);
                }
            }
            if ((list.Count > 0) || (list2.Count > 0))
            {
                bool flag = false;
                foreach (Troop troop in list)
                {
                    switch (this.troop.HostileAction)
                    {
                    case HostileActionKind.NotCare:
                        Session.Current.Scenario.SetPenalizedMapDataByPosition(troop.Position, 0xdac);
                        break;

                    case HostileActionKind.Attack:
                        Session.Current.Scenario.SetPenalizedMapDataByPosition(troop.Position, 0xdac);
                        break;

                    case HostileActionKind.EvadeEffect:
                        Session.Current.Scenario.SetPenalizedMapDataByArea(troop.OffenceArea, 1);
                        break;

                    case HostileActionKind.EvadeView:
                        Session.Current.Scenario.SetPenalizedMapDataByArea(troop.ViewArea, 1);
                        break;
                    }
                }

                /*foreach (Troop troop in list2)
                 * {
                 *  switch (this.troop.FriendlyAction)
                 *  {
                 *  }
                 * }*/
                flag = this.ModifyFirstTierPath(this.troop.Position, this.troop.FirstTierDestination, middlePath, kind);
                foreach (Troop troop in list)
                {
                    switch (this.troop.HostileAction)
                    {
                    case HostileActionKind.NotCare:
                        Session.Current.Scenario.ClearPenalizedMapDataByPosition(troop.Position);
                        break;

                    case HostileActionKind.Attack:
                        Session.Current.Scenario.ClearPenalizedMapDataByPosition(troop.Position);
                        break;

                    case HostileActionKind.EvadeEffect:
                        Session.Current.Scenario.ClearPenalizedMapDataByArea(troop.OffenceArea);
                        break;

                    case HostileActionKind.EvadeView:
                        Session.Current.Scenario.ClearPenalizedMapDataByArea(troop.ViewArea);
                        break;
                    }
                }

                /*foreach (Troop troop in list2)
                 * {
                 *  switch (this.troop.FriendlyAction)
                 *  {
                 *  }
                 * }*/
                if (flag)
                {
                    return(PathResult.Found);
                }
                return(PathResult.NotFound);
            }
            return(PathResult.Aborted);
        }
Beispiel #17
0
 /// <summary>
 /// distributes losses among troop containers, returning a "losses" list
 /// </summary>
 /// <param name="remainingArmy"></param>
 public void SetPostBattleArmyData_RemainingArmy(TroopList remainingArmy)
 {
     UpdatePostBattleArmy(sideArmy.GetLossesList(remainingArmy));
 }