Exemple #1
0
    public void Merge(int value, float percentage)
    {
        float d;
        // _newvalue should have been set correctly either by the constructor or by the Update function
        int mergedValue = MathUtility.LerpToIntAndGetDecimals(_newValue, value, percentage, out d);

        if (d > Group.GetNextLocalRandomFloat(RngOffsets.KNOWLEDGE_MERGE + InstanceRngOffset))
        {
            mergedValue++;
        }

#if DEBUG
        if ((Id == SocialOrganizationKnowledge.KnowledgeId) && (mergedValue < SocialOrganizationKnowledge.MinValueForTribeFormation))
        {
            if (Group.GetFactionCores().Count > 0)
            {
                Debug.LogWarning("group with low social organization has faction cores - Id: " + Group.Id);
            }
        }
#endif

//#if DEBUG
//        if ((Manager.RegisterDebugEvent != null) && (Manager.TracingData.Priority <= 0))
//        {
//            if (Group.Id == Manager.TracingData.GroupId)
//            {
//                string groupId = "Id:" + Group.Id + "|Long:" + Group.Longitude + "|Lat:" + Group.Latitude;

//                SaveLoadTest.DebugMessage debugMessage = new SaveLoadTest.DebugMessage(
//                    "CellCulturalKnowledge.Merge - Group:" + groupId,
//                    "CurrentDate: " + Group.World.CurrentDate +
//                    ", Id: " + Id +
//                    ", IsPresent: " + IsPresent +
//                    ", Value: " + Value +
//                    ", _newValue: " + _newValue +
//                    ", mergedValue: " + mergedValue +
//                    ", value (param): " + value +
//                    ", percentage: " + percentage +
//                    "");

//                Manager.RegisterDebugEvent("DebugMessage", debugMessage);
//            }
//        }
//#endif

        _newValue = mergedValue;
    }
    private void SwitchCellProminences(Polity sourcePolity, Clan triggerClan)
    {
        float targetPolityInfluence = triggerClan.Influence;
        float sourcePolityInfluence = 1 - targetPolityInfluence;

        if (targetPolityInfluence <= 0)
        {
            throw new System.Exception("Pulling clan influence equal or less than zero.");
        }

        int maxGroupCount = sourcePolity.Groups.Count;

        Dictionary <CellGroup, float> groupDistances = new Dictionary <CellGroup, float>(maxGroupCount);

        Queue <CellGroup> sourceGroups = new Queue <CellGroup>(maxGroupCount);

        sourceGroups.Enqueue(CoreGroup);

        int reviewedCells = 0;
        int switchedCells = 0;

        HashSet <Faction> factionsToTransfer = new HashSet <Faction>();

        while (sourceGroups.Count > 0)
        {
            CellGroup group = sourceGroups.Dequeue();

            if (groupDistances.ContainsKey(group))
            {
                continue;
            }

            PolityProminence pi = group.GetPolityProminence(sourcePolity);

            if (pi == null)
            {
                continue;
            }

            reviewedCells++;

            float distanceToTargetPolityCore = CalculateShortestCoreDistance(group, groupDistances);

            if (distanceToTargetPolityCore >= CellGroup.MaxCoreDistance)
            {
                continue;
            }

            groupDistances.Add(group, distanceToTargetPolityCore);

            float distanceToSourcePolityCore = pi.PolityCoreDistance;

            float percentProminence = 1f;

            if (distanceToSourcePolityCore < CellGroup.MaxCoreDistance)
            {
                float ditanceToCoresSum = distanceToTargetPolityCore + distanceToSourcePolityCore;

                float distanceFactor = distanceToSourcePolityCore / ditanceToCoresSum;

                distanceFactor = Mathf.Clamp01((distanceFactor * 3f) - 1f);

                float targetDistanceFactor = distanceFactor;
                float sourceDistanceFactor = 1 - distanceFactor;

                float targetPolityWeight = targetPolityInfluence * targetDistanceFactor;
                float sourcePolityWeight = sourcePolityInfluence * sourceDistanceFactor;

                percentProminence = targetPolityWeight / (targetPolityWeight + sourcePolityWeight);
            }

            if (percentProminence <= 0)
            {
                continue;
            }

            if (percentProminence > 0.5f)
            {
                switchedCells++;

                foreach (Faction faction in group.GetFactionCores())
                {
                    // Do not transfer factions that belong to polities other than the source one
                    if (faction.Polity != sourcePolity)
                    {
                        continue;
                    }

                    if (sourcePolity.DominantFaction == faction)
                    {
                        new System.Exception("Dominant Faction getting switched...");
                    }

                    //					#if DEBUG
                    //					if (sourcePolity.FactionCount == 1) {
                    //						throw new System.Exception ("Number of factions in Polity " + Id + " will be equal or less than zero. Current Date: " + World.CurrentDate);
                    //					}
                    //					#endif

                    factionsToTransfer.Add(faction);
                }
            }

            float prominenceValue = pi.Value;

            group.SetPolityProminence(sourcePolity, prominenceValue * (1 - percentProminence));

            group.SetPolityProminence(this, prominenceValue * percentProminence, distanceToTargetPolityCore, distanceToTargetPolityCore);

            World.AddGroupToUpdate(group);

            foreach (CellGroup neighborGroup in group.NeighborGroups)
            {
                if (groupDistances.ContainsKey(neighborGroup))
                {
                    continue;
                }

                sourceGroups.Enqueue(neighborGroup);
            }
        }

        float highestInfluence = triggerClan.Influence;
        Clan  dominantClan     = triggerClan;

        foreach (Faction faction in factionsToTransfer)
        {
            if (faction is Clan clan)
            {
                if (clan.Influence > highestInfluence)
                {
                    highestInfluence = clan.Influence;
                    dominantClan     = clan;
                }
            }

            faction.ChangePolity(this, faction.Influence);
        }

        SetDominantFaction(dominantClan);

        //		Debug.Log ("SwitchCellProminences: source polity cells: " + maxGroupCount + ", reviewed cells: " + reviewedCells + ", switched cells: " + switchedCells);
    }
Exemple #3
0
    private void TryMigrateFactionCores()
    {
        int targetPopulation    = 0;
        int targetNewPopulation = Population;

        CellGroup targetGroup = TargetCell.Group;

        if (targetGroup != null)
        {
            targetPopulation     = targetGroup.Population;
            targetNewPopulation += targetPopulation;
        }

        FactionCoresToMigrate.Clear();

        foreach (Faction faction in SourceGroup.GetFactionCores())
        {
            PolityProminence pi = SourceGroup.GetPolityProminence(faction.Polity);

            if (pi == null)
            {
                Debug.LogError("Unable to find Polity with Id: " + faction.Polity.Id);
            }

            float sourceGroupProminence = pi.Value;
            float targetGroupProminence = sourceGroupProminence;

            if (targetGroup != null)
            {
                PolityProminence piTarget = targetGroup.GetPolityProminence(faction.Polity);

                if (piTarget != null)
                {
                    targetGroupProminence = piTarget.Value;
                }
                else
                {
                    targetGroupProminence = 0f;
                }
            }

            float targetNewGroupProminence = ((sourceGroupProminence * Population) + (targetGroupProminence * targetPopulation)) / targetNewPopulation;

            if (faction.ShouldMigrateFactionCore(SourceGroup, TargetCell, targetNewGroupProminence, targetNewPopulation))
            {
                FactionCoresToMigrate.Add(faction);
            }
        }

//#if DEBUG
//        if ((Manager.RegisterDebugEvent != null) && (Manager.TracingData.Priority <= 0))
//        {
//            if (SourceGroupId == Manager.TracingData.GroupId)
//            {
//                SaveLoadTest.DebugMessage debugMessage = new SaveLoadTest.DebugMessage(
//                    "TryMigrateFactionCores - SourceGroup:" + SourceGroupId,
//                    "CurrentDate: " + World.CurrentDate +
//                    "SourceGroup.GetFactionCores().Count: " + SourceGroup.GetFactionCores().Count +
//                    ", FactionCoresToMigrate.Count: " + FactionCoresToMigrate.Count +
//                    "");

//                Manager.RegisterDebugEvent("DebugMessage", debugMessage);
//            }
//        }
//#endif
    }