protected override bool SuccessCheck()
    {
        alliedWar = null;
        List <WS_Government> alliances = new List <WS_Government>();

        foreach (WS_Treaty treaty in tile.government.treaties)
        {
            if (treaty.type == TreatyType.ALLIANCE)
            {
                alliances.Add(treaty.target);
            }
        }

        foreach (WS_Government alliance in alliances)
        {
            foreach (WS_Treaty alliedTreaty in alliance.treaties)
            {
                if (alliedTreaty.type == TreatyType.WAR && tile.government.borderingGovernments.Contains(alliedTreaty.target))
                {
                    bool valid = true;

                    foreach (WS_Treaty treaty in tile.government.treaties)
                    {
                        if (treaty.target == alliedTreaty.target)
                        {
                            switch (treaty.type)
                            {
                            case TreatyType.ALLIANCE: valid = false; break;

                            case TreatyType.TRUCE: valid = false; break;

                            case TreatyType.NON_AGGRESSION: valid = false; break;
                            }

                            if (valid)
                            {
                                foreach (WS_Treaty enemyTreaty in treaty.target.treaties)
                                {
                                    if (enemyTreaty.target == tile.government)
                                    {
                                        treaty.target.treaties.Remove(enemyTreaty);
                                        break;
                                    }
                                }

                                tile.government.treaties.Remove(treaty);
                                break;
                            }
                        }
                    }

                    alliedWar = alliedTreaty;
                    return(Random.Range(0.0f, 1.0f) < ((tile.government.warNum > 0) ? 0.1f : 0.4f) && valid);
                }
            }
        }

        return(false);
    }
    protected override void Success()
    {
        WS_Treaty newTreatyA = new WS_Treaty();
        WS_Treaty newTreatyB = new WS_Treaty();

        newTreatyA.type = newTreatyB.type = TreatyType.WAR;

        newTreatyA.remainingDuration = newTreatyB.remainingDuration = alliedWar.remainingDuration;

        newTreatyA.target = alliedWar.target;
        tile.government.treaties.Add(newTreatyA);

        newTreatyB.target = tile.government;
        alliedWar.target.treaties.Add(newTreatyB);

        tile.government.warNum++;
        alliedWar.target.warNum++;
    }
Exemple #3
0
    protected override bool FireCheck()
    {
        war = null;

        if (tile.government.warNum > 0 && tile == tile.government.capital)
        {
            foreach (WS_Treaty treaty in tile.government.treaties)
            {
                if (treaty.type == TreatyType.WAR)
                {
                    if (!tile.government.borderingGovernments.Contains(treaty.target) || tile.government.warScore >= 100.0f)
                    {
                        war = treaty;
                    }
                }
            }
        }

        return(war != null);
    }
    protected override void Success()
    {
        WS_Treaty newTreatyA = new WS_Treaty();
        WS_Treaty newTreatyB = new WS_Treaty();

        newTreatyA.type = newTreatyB.type = treaty;

        newTreatyA.remainingDuration = newTreatyB.remainingDuration = Random.Range(30, 50);

        newTreatyA.target = target;
        tile.government.treaties.Add(newTreatyA);

        newTreatyB.target = tile.government;
        target.treaties.Add(newTreatyB);

        if (treaty == TreatyType.WAR)
        {
            tile.government.warNum++;
            target.warNum++;
        }
    }