def drawContents(self):

        self.deleteAllWidgets()

        # Create a new screen, called FinanceAdvisor, using the file FinanceAdvisor.py for input
        screen = self.getScreen()

        player = gc.getPlayer(self.iActiveLeader)

        numCities = player.getNumCities()

        totalUnitCost = player.calculateUnitCost()
        totalUnitSupply = player.calculateUnitSupply()
        totalMaintenance = player.getTotalMaintenance()
        totalCivicUpkeep = player.getCivicUpkeep([], False)
        totalPreInflatedCosts = player.calculatePreInflatedCosts()
        totalInflatedCosts = player.calculateInflatedCosts()
        goldCommerce = player.getCommerceRate(CommerceTypes.COMMERCE_GOLD)
        if not player.isCommerceFlexible(CommerceTypes.COMMERCE_RESEARCH):
            goldCommerce += player.calculateBaseNetResearch()
        gold = player.getGold()
        goldFromCivs = player.getGoldPerTurn()
        goldPerTurn = player.calculateGoldRate()

        szTreasuryPanel = self.getNextWidgetName()
        screen.addPanel(
            szTreasuryPanel,
            u"",
            "",
            True,
            True,
            self.X_SLIDERS,
            self.Y_TREASURY,
            self.X_EXPENSES + self.PANE_WIDTH - self.X_SLIDERS,
            self.H_TREASURY,
            PanelStyles.PANEL_STYLE_MAIN,
        )
        szText = localText.getText("TXT_KEY_FINANCIAL_ADVISOR_TREASURY", (gold,)).upper()
        if gold < 0:
            if goldPerTurn != 0:
                if gold + goldPerTurn >= 0:
                    szText += BugUtil.getText("TXT_KEY_MISC_POS_GOLD_PER_TURN", goldPerTurn)
                elif goldPerTurn >= 0:
                    szText += BugUtil.getText("TXT_KEY_MISC_POS_WARNING_GOLD_PER_TURN", goldPerTurn)
                else:
                    szText += BugUtil.getText("TXT_KEY_MISC_NEG_GOLD_PER_TURN", goldPerTurn)
        else:
            if goldPerTurn != 0:
                if goldPerTurn >= 0:
                    szText += BugUtil.getText("TXT_KEY_MISC_POS_GOLD_PER_TURN", goldPerTurn)
                elif gold + goldPerTurn >= 0:
                    szText += BugUtil.getText("TXT_KEY_MISC_NEG_WARNING_GOLD_PER_TURN", goldPerTurn)
                else:
                    szText += BugUtil.getText("TXT_KEY_MISC_NEG_GOLD_PER_TURN", goldPerTurn)
        screen.setLabel(
            self.getNextWidgetName(),
            szTreasuryPanel,
            u"<font=4>" + szText + u"</font>",
            CvUtil.FONT_CENTER_JUSTIFY,
            (self.X_SLIDERS + self.PANE_WIDTH + self.X_EXPENSES) / 2,
            self.Y_TREASURY + self.H_TREASURY / 2 - self.Y_SPACING / 2,
            self.Z_CONTROLS,
            FontTypes.TITLE_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_GOLD_RESERVE,
            -1,
            -1,
        )

        szCommercePanel = self.getNextWidgetName()
        screen.addPanel(
            szCommercePanel,
            u"",
            "",
            True,
            True,
            self.X_SLIDERS,
            self.Y_LOCATION,
            self.PANE_WIDTH,
            self.PANE_HEIGHT,
            PanelStyles.PANEL_STYLE_MAIN,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_COMMERCE", ()).upper() + u"</font>",
            CvUtil.FONT_CENTER_JUSTIFY,
            self.X_SLIDERS + self.PANE_WIDTH / 2,
            self.Y_LOCATION + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        szIncomePanel = self.getNextWidgetName()
        screen.addPanel(
            szIncomePanel,
            u"",
            "",
            True,
            True,
            self.X_INCOME,
            self.Y_LOCATION,
            self.PANE_WIDTH,
            self.PANE_HEIGHT,
            PanelStyles.PANEL_STYLE_MAIN,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_INCOME_HEADER", ()).upper() + u"</font>",
            CvUtil.FONT_CENTER_JUSTIFY,
            self.X_INCOME + self.PANE_WIDTH / 2,
            self.Y_LOCATION + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        szExpensePanel = self.getNextWidgetName()
        screen.addPanel(
            szExpensePanel,
            u"",
            "",
            True,
            True,
            self.X_EXPENSES,
            self.Y_LOCATION,
            self.PANE_WIDTH,
            self.PANE_HEIGHT,
            PanelStyles.PANEL_STYLE_MAIN,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_EXPENSES_HEADER", ()).upper() + u"</font>",
            CvUtil.FONT_CENTER_JUSTIFY,
            self.X_EXPENSES + self.PANE_WIDTH / 2,
            self.Y_LOCATION + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        # Commerce
        yLocation = self.Y_LOCATION
        iCommerce = 0

        # sum all worked tiles' commerce yields for player
        # move to MapUtil?
        iWorkedTileCount = 0
        iWorkedTiles = 0
        for city in PlayerUtil.playerCities(player):
            if not city.isDisorder():
                for i in range(gc.getNUM_CITY_PLOTS()):
                    plot = city.getCityIndexPlot(i)
                    if plot and not plot.isNone() and plot.hasYield():
                        if city.isWorkingPlot(plot):
                            iWorkedTileCount += 1
                            iWorkedTiles += plot.getYield(YieldTypes.YIELD_COMMERCE)

        yLocation += 1.5 * self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_WORKED_TILES", (iWorkedTileCount,)) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_SLIDERS + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(iWorkedTiles) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )
        iCommerce += iWorkedTiles

        # trade
        iDomesticTrade, _, iForeignTrade, _ = TradeUtil.calculateTradeRoutes(player)

        if iDomesticTrade > 0:
            if TradeUtil.isFractionalTrade():
                iDomesticTrade //= 100
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_DOMESTIC_TRADE", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_SLIDERS + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                *BugDll.widget("WIDGET_HELP_FINANCE_DOMESTIC_TRADE", self.iActiveLeader, 1)
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(iDomesticTrade) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                *BugDll.widget("WIDGET_HELP_FINANCE_DOMESTIC_TRADE", self.iActiveLeader, 1)
            )
            iCommerce += iDomesticTrade

        if iForeignTrade > 0:
            if TradeUtil.isFractionalTrade():
                iForeignTrade //= 100
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_FOREIGN_TRADE", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_SLIDERS + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                *BugDll.widget("WIDGET_HELP_FINANCE_FOREIGN_TRADE", self.iActiveLeader, 1)
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(iForeignTrade) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                *BugDll.widget("WIDGET_HELP_FINANCE_FOREIGN_TRADE", self.iActiveLeader, 1)
            )
            iCommerce += iForeignTrade

            # corporations
        iCorporations = 0
        for city in PlayerUtil.playerCities(player):
            if not city.isDisorder():
                iCorporations += city.getCorporationYield(YieldTypes.YIELD_COMMERCE)

        if iCorporations > 0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_CORPORATIONS", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_SLIDERS + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(iCorporations) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            iCommerce += iCorporations

            # specialists
        iSpecialists = 0
        for city in PlayerUtil.playerCities(player):
            if not city.isDisorder():
                for eSpec in range(gc.getNumSpecialistInfos()):
                    iSpecialists += player.specialistYield(eSpec, YieldTypes.YIELD_COMMERCE) * (
                        city.getSpecialistCount(eSpec) + city.getFreeSpecialistCount(eSpec)
                    )

        if iSpecialists > 0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_SPECIALISTS", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_SLIDERS + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(iSpecialists) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            iCommerce += iSpecialists

            # buildings
        iTotalCommerce = player.calculateTotalYield(YieldTypes.YIELD_COMMERCE)
        # buildings includes 50% capital bonus for Bureaucracy civic
        iBuildings = iTotalCommerce - iCommerce
        if iBuildings > 0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_BUILDINGS", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_SLIDERS + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(iBuildings) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            iCommerce += iBuildings

        yLocation += 1.5 * self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_BUG_FINANCIAL_ADVISOR_COMMERCE", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_SLIDERS + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(iCommerce) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        # Slider percentages

        yLocation += 0.5 * self.Y_SPACING
        for iI in range(CommerceTypes.NUM_COMMERCE_TYPES):
            eCommerce = (iI + 1) % CommerceTypes.NUM_COMMERCE_TYPES

            if player.isCommerceFlexible(eCommerce):
                yLocation += self.Y_SPACING
                screen.setButtonGFC(
                    self.getNextWidgetName(),
                    u"",
                    "",
                    self.X_SLIDERS + self.TEXT_MARGIN,
                    int(yLocation) + self.TEXT_MARGIN,
                    20,
                    20,
                    WidgetTypes.WIDGET_CHANGE_PERCENT,
                    eCommerce,
                    gc.getDefineINT("COMMERCE_PERCENT_CHANGE_INCREMENTS"),
                    ButtonStyles.BUTTON_STYLE_CITY_PLUS,
                )
                screen.setButtonGFC(
                    self.getNextWidgetName(),
                    u"",
                    "",
                    self.X_SLIDERS + self.TEXT_MARGIN + 24,
                    int(yLocation) + self.TEXT_MARGIN,
                    20,
                    20,
                    WidgetTypes.WIDGET_CHANGE_PERCENT,
                    eCommerce,
                    -gc.getDefineINT("COMMERCE_PERCENT_CHANGE_INCREMENTS"),
                    ButtonStyles.BUTTON_STYLE_CITY_MINUS,
                )

                szText = (
                    u"<font=3>"
                    + gc.getCommerceInfo(eCommerce).getDescription()
                    + u" ("
                    + unicode(player.getCommercePercent(eCommerce))
                    + u"%)</font>"
                )
                screen.setLabel(
                    self.getNextWidgetName(),
                    "Background",
                    szText,
                    CvUtil.FONT_LEFT_JUSTIFY,
                    self.X_SLIDERS + self.TEXT_MARGIN + 50,
                    yLocation + self.TEXT_MARGIN,
                    self.Z_CONTROLS + self.DZ,
                    FontTypes.GAME_FONT,
                    WidgetTypes.WIDGET_GENERAL,
                    -1,
                    -1,
                )
                szRate = u"<font=3>" + unicode(player.getCommerceRate(CommerceTypes(eCommerce))) + u"</font>"
                screen.setLabel(
                    self.getNextWidgetName(),
                    "Background",
                    szRate,
                    CvUtil.FONT_RIGHT_JUSTIFY,
                    self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
                    yLocation + self.TEXT_MARGIN,
                    self.Z_CONTROLS + self.DZ,
                    FontTypes.GAME_FONT,
                    WidgetTypes.WIDGET_GENERAL,
                    -1,
                    -1,
                )

        yLocation += self.Y_SPACING
        szText = (
            u"<font=3>"
            + gc.getCommerceInfo(CommerceTypes.COMMERCE_GOLD).getDescription()
            + u" ("
            + unicode(player.getCommercePercent(CommerceTypes.COMMERCE_GOLD))
            + u"%)</font>"
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            szText,
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_SLIDERS + self.TEXT_MARGIN + 50,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )
        szCommerce = u"<font=3>" + unicode(goldCommerce) + u"</font>"
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            szCommerce,
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_SLIDERS + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        # Income
        yLocation = self.Y_LOCATION
        iTaxRate = player.getCommercePercent(CommerceTypes.COMMERCE_GOLD)

        multipliers = []
        for eBldg in range(gc.getNumBuildingInfos()):
            info = gc.getBuildingInfo(eBldg)
            iMultiplier = info.getCommerceModifier(CommerceTypes.COMMERCE_GOLD)
            if iMultiplier > 0:
                multipliers.append([eBldg, iMultiplier, 0, 0.0])

        iBuildingCount = 0
        iHeadquartersCount = 0
        iShrinesCount = 0
        fTaxes = 0.0
        fBuildings = 0.0
        fHeadquarters = 0.0
        fShrines = 0.0
        fCorporations = 0.0
        fSpecialists = 0.0
        iWealthCount = 0
        fWealth = 0.0
        eWealth = gc.getInfoTypeForString("PROCESS_WEALTH")
        # ignores
        #   CyCity.getReligionCommerce() -- excludes shrines
        #   CyPlayer.getFreeCityCommerce()
        #   CyPlayer.getSpecialistExtraCommerce() * (CyCity.getSpecialistPopulation() + CyCity.getNumGreatPeople())
        for city in PlayerUtil.playerCities(player):
            if not city.isDisorder():
                fCityTaxes = city.getYieldRate(YieldTypes.YIELD_COMMERCE) * iTaxRate / 100.0
                fTaxes += fCityTaxes

                fCityBuildings = 0.0
                fCityHeadquarters = 0.0
                fCityShrines = 0.0
                for eBldg in range(gc.getNumBuildingInfos()):
                    iCount = city.getNumRealBuilding(eBldg)
                    if iCount > 0:
                        iBuildingGold = city.getBuildingCommerceByBuilding(CommerceTypes.COMMERCE_GOLD, eBldg)
                        if iBuildingGold > 0:
                            info = gc.getBuildingInfo(eBldg)
                            if info.getFoundsCorporation() != -1:
                                fCityHeadquarters += iBuildingGold
                                iHeadquartersCount += 1
                            elif info.getGlobalReligionCommerce() != -1:
                                fCityShrines += iBuildingGold
                                iShrinesCount += 1
                            else:
                                fCityBuildings += iBuildingGold
                                iBuildingCount += iCount
                fBuildings += fCityBuildings
                fHeadquarters += fCityHeadquarters
                fShrines += fCityShrines

                fCityCorporations = city.getCorporationCommerce(CommerceTypes.COMMERCE_GOLD)
                fCorporations += fCityCorporations

                fCitySpecialists = city.getSpecialistCommerce(CommerceTypes.COMMERCE_GOLD)
                fSpecialists += fCitySpecialists

                fCityWealth = 0.0
                if city.isProductionProcess() and city.getProductionProcess() == eWealth:
                    fCityWealth = (
                        city.getProductionToCommerceModifier(CommerceTypes.COMMERCE_GOLD)
                        * city.getYieldRate(YieldTypes.YIELD_PRODUCTION)
                        / 100.0
                    )
                    fWealth += fCityWealth
                    iWealthCount += 1

                    # buildings don't multiply wealth
                fCityTotel = fCityTaxes + fCityBuildings + fCityHeadquarters + fCityCorporations + fCitySpecialists
                for entry in multipliers:
                    eBldg, iMultiplier, _, _ = entry
                    iCount = city.getNumRealBuilding(eBldg)
                    if iCount > 0:
                        entry[2] += iCount
                        entry[3] += iCount * fCityTotel * iMultiplier / 100.0

        iTotalMinusTaxes = int(fBuildings) + int(fCorporations) + int(fSpecialists) + int(fWealth)
        for _, _, _, fGold in multipliers:
            iTotalMinusTaxes += int(fGold)

        yLocation += 1.5 * self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_TAXES", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_INCOME + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(goldCommerce - iTotalMinusTaxes) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        if fBuildings > 0.0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_BUILDINGS", ()) + " (%d)</font>" % iBuildingCount,
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_INCOME + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(int(fBuildings)) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )

        if fHeadquarters > 0.0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>"
                + localText.getText("TXT_KEY_CORPORATION_HEADQUARTERS", ())
                + " (%d)</font>" % iHeadquartersCount,
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_INCOME + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(int(fHeadquarters)) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )

        if fCorporations > 0.0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_CORPORATIONS", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_INCOME + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(int(fCorporations)) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )

        if fShrines > 0.0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>"
                + localText.getText("TXT_KEY_CONCEPT_RELIGIOUS_SHRINES", ())
                + " (%d)</font>" % iShrinesCount,
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_INCOME + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(int(fShrines)) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )

        if fSpecialists > 0.0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_CONCEPT_SPECIALISTS", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_INCOME + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                *BugDll.widget("WIDGET_HELP_FINANCE_SPECIALISTS", self.iActiveLeader, 1)
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(int(fSpecialists)) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                *BugDll.widget("WIDGET_HELP_FINANCE_SPECIALISTS", self.iActiveLeader, 1)
            )

        for eBldg, iMultiplier, iCount, fGold in multipliers:
            if iCount > 0 and fGold > 0.0:
                fAverage = fGold / iCount
                szDescription = (
                    gc.getBuildingInfo(eBldg).getDescription()
                    + u" "
                    + localText.getText(
                        "TXT_KEY_BUG_FINANCIAL_ADVISOR_BUILDING_COUNT_AVERAGE",
                        (iCount, BugUtil.formatFloat(fAverage, 2)),
                    )
                )
                yLocation += self.Y_SPACING
                screen.setLabel(
                    self.getNextWidgetName(),
                    "Background",
                    u"<font=3>" + szDescription + "</font>",
                    CvUtil.FONT_LEFT_JUSTIFY,
                    self.X_INCOME + self.TEXT_MARGIN,
                    yLocation + self.TEXT_MARGIN,
                    self.Z_CONTROLS + self.DZ,
                    FontTypes.GAME_FONT,
                    WidgetTypes.WIDGET_GENERAL,
                    -1,
                    -1,
                )
                screen.setLabel(
                    self.getNextWidgetName(),
                    "Background",
                    u"<font=3>" + unicode(int(fGold)) + "</font>",
                    CvUtil.FONT_RIGHT_JUSTIFY,
                    self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                    yLocation + self.TEXT_MARGIN,
                    self.Z_CONTROLS + self.DZ,
                    FontTypes.GAME_FONT,
                    WidgetTypes.WIDGET_GENERAL,
                    -1,
                    -1,
                )

        if fWealth > 0.0 and iWealthCount > 0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_PROCESS_WEALTH", ()) + " (%d)</font>" % iWealthCount,
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_INCOME + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(int(fWealth)) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_GENERAL,
                -1,
                -1,
            )

        iIncome = goldCommerce
        if goldFromCivs > 0:
            yLocation += self.Y_SPACING
            szText = unicode(goldFromCivs) + " : " + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_PER_TURN", ())
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_PER_TURN", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_INCOME + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_HELP_FINANCE_FOREIGN_INCOME,
                self.iActiveLeader,
                1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(goldFromCivs) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_HELP_FINANCE_FOREIGN_INCOME,
                self.iActiveLeader,
                1,
            )
            iIncome += goldFromCivs

        yLocation += 1.5 * self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_INCOME", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_INCOME + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(iIncome) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_INCOME + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        # Expenses
        yLocation = self.Y_LOCATION
        iExpenses = 0

        yLocation += 1.5 * self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_UNITCOST", ()) + u"</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_EXPENSES + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_UNIT_COST,
            self.iActiveLeader,
            1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(totalUnitCost) + u"</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_EXPENSES + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_UNIT_COST,
            self.iActiveLeader,
            1,
        )
        iExpenses += totalUnitCost

        yLocation += self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_UNITSUPPLY", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_EXPENSES + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_AWAY_SUPPLY,
            self.iActiveLeader,
            1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(totalUnitSupply) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_EXPENSES + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_AWAY_SUPPLY,
            self.iActiveLeader,
            1,
        )
        iExpenses += totalUnitSupply

        yLocation += self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_MAINTENANCE", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_EXPENSES + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_CITY_MAINT,
            self.iActiveLeader,
            1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(totalMaintenance) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_EXPENSES + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_CITY_MAINT,
            self.iActiveLeader,
            1,
        )
        iExpenses += totalMaintenance

        yLocation += self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_CIVICS", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_EXPENSES + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_CIVIC_UPKEEP,
            self.iActiveLeader,
            1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(totalCivicUpkeep) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_EXPENSES + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_CIVIC_UPKEEP,
            self.iActiveLeader,
            1,
        )
        iExpenses += totalCivicUpkeep

        if goldFromCivs < 0:
            yLocation += self.Y_SPACING
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_COST_PER_TURN", ()) + "</font>",
                CvUtil.FONT_LEFT_JUSTIFY,
                self.X_EXPENSES + self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_HELP_FINANCE_FOREIGN_INCOME,
                self.iActiveLeader,
                1,
            )
            screen.setLabel(
                self.getNextWidgetName(),
                "Background",
                u"<font=3>" + unicode(-goldFromCivs) + "</font>",
                CvUtil.FONT_RIGHT_JUSTIFY,
                self.X_EXPENSES + self.PANE_WIDTH - self.TEXT_MARGIN,
                yLocation + self.TEXT_MARGIN,
                self.Z_CONTROLS + self.DZ,
                FontTypes.GAME_FONT,
                WidgetTypes.WIDGET_HELP_FINANCE_FOREIGN_INCOME,
                self.iActiveLeader,
                1,
            )
            iExpenses -= goldFromCivs

        yLocation += self.Y_SPACING
        iInflation = totalInflatedCosts - totalPreInflatedCosts
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_INFLATION", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_EXPENSES + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_INFLATED_COSTS,
            self.iActiveLeader,
            1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(iInflation) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_EXPENSES + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_HELP_FINANCE_INFLATED_COSTS,
            self.iActiveLeader,
            1,
        )
        iExpenses += iInflation

        yLocation += 1.5 * self.Y_SPACING
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + localText.getText("TXT_KEY_FINANCIAL_ADVISOR_EXPENSES", ()) + "</font>",
            CvUtil.FONT_LEFT_JUSTIFY,
            self.X_EXPENSES + self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )
        screen.setLabel(
            self.getNextWidgetName(),
            "Background",
            u"<font=3>" + unicode(iExpenses) + "</font>",
            CvUtil.FONT_RIGHT_JUSTIFY,
            self.X_EXPENSES + self.PANE_WIDTH - self.TEXT_MARGIN,
            yLocation + self.TEXT_MARGIN,
            self.Z_CONTROLS + self.DZ,
            FontTypes.GAME_FONT,
            WidgetTypes.WIDGET_GENERAL,
            -1,
            -1,
        )

        return 0
Exemple #2
0
	def __repr__(self):
		return ("<deal %d [trades %d %s] [trades %d %s]>" % 
				(self.getID(), 
				self.getPlayer(), 
				TradeUtil.format(self.getPlayer(), [t for t in self.trades()]), 
				self.getOtherPlayer(), 
				TradeUtil.format(self.getOtherPlayer(), [t for t in self.otherTrades()])))
    def fillTable(self, screen, table, eYield, eTileType):
        """Fills the given GFC table control with the chosen yield values."""
        self.iRow = 0
        # Tiles
        iTotal = self.getYield(eYield, eTileType)
        self.appendTable(screen, table, False, BugUtil.getText(
            LABEL_KEYS[eTileType], (self.tileCounts[eTileType],)), eYield, iTotal)

        # Trade
        for eType in (DOMESTIC_TRADE, FOREIGN_TRADE):
            iValue = self.getYield(eYield, eType)
            if iValue != 0:
                self.appendTable(screen, table, False, BugUtil.getPlainText(
                    LABEL_KEYS[eType]), eYield, iValue, TradeUtil.isFractionalTrade())
        iValue = self.getYield(eYield, DOMESTIC_TRADE) + self.getYield(eYield, FOREIGN_TRADE)
        if TradeUtil.isFractionalTrade():
            iValue //= 100
        iTotal += iValue

        # Buildings, Corporations, Specialists
        for eType in (BUILDINGS, CORPORATIONS, SPECIALISTS):
            iValue = self.getYield(eYield, eType)
            if iValue != 0:
                iTotal += iValue
                self.appendTable(screen, table, False, BugUtil.getPlainText(LABEL_KEYS[eType]), eYield, iValue)

        # Subtotal and Base Modifiers
        iModifier = self.getYield(eYield, BASE_MODIFIER)
        if iModifier != 0:
            # Subtotal
            self.appendTableTotal(screen, table, eYield, iTotal)
            #self.appendTable(screen, table, True, BugUtil.getPlainText("TXT_KEY_CONCEPT_SUBTOTAL"), eYield, iTotal)
            # Modifier
            iValue = (iTotal * (iModifier + 100) // 100) - iTotal
            iSubtotal = iTotal + iValue
            self.appendTable(screen, table, False, BugUtil.getText(
                "TXT_KEY_CONCEPT_BASE_MODIFIER", (iModifier,)), eYield, iValue)
        else:
            iSubtotal = iTotal

        # Subtotal and Production Modifiers
        if eYield == YieldTypes.YIELD_PRODUCTION and self.iProductionModifier != 0:
            # Subtotal
            self.appendTableTotal(screen, table, eYield, iSubtotal)
            #self.appendTable(screen, table, True, BugUtil.getPlainText("TXT_KEY_CONCEPT_SUBTOTAL"), eYield, iSubtotal)
            # Total
            iTotal = iTotal * (iModifier + self.iProductionModifier + 100) // 100
            # Modifier
            iValue = iTotal - iSubtotal
            self.appendTable(screen, table, False, BugUtil.getText("TXT_KEY_CONCEPT_PRODUCTION_MODIFIER",
                             (self.sModifierDetail, self.iProductionModifier)), eYield, iValue)
        else:
            iTotal = iSubtotal

        # Total
        self.appendTableTotal(screen, table, eYield, iTotal)
Exemple #4
0
def canSeeCityList(playerOrID):
    """
    Returns True if the active player can see the list of <player>'s cities.
    
    In the unmodified game, this is possible if the players have met and <player>
    is not a vassal of a rival. They must be able to contact (trade with)
    <player>, and OCC must be disabled. You can always see a teammate's cities.
    """
    if GameUtil.isOCC():
        return False
    askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
    askingPlayer, askingTeam = getActivePlayerAndTeam()

    iDemographicsMission = -1

    if (GameUtil.isEspionage()):
        for iMissionLoop in range(gc.getNumEspionageMissionInfos()):
            if (gc.getEspionageMissionInfo(iMissionLoop).isSeeDemographics()):
                iDemographicsMission = iMissionLoop

    if gc.getGame().isOption(
            GameOptionTypes.GAMEOPTION_CITYCOUNT_TIED_TO_ESPIONAGE):
        if (askedTeam.isEverAlive()):
            if (askingTeam.isHasMet(playerOrID) or CyGame().isDebugMode()):
                if (iDemographicsMission != -1
                        and not askingPlayer.canDoEspionageMission(
                            iDemographicsMission, playerOrID, None, -1)):
                    return False

    if askingPlayer.getTeam() == askedPlayer.getTeam():
        return True
    if askedTeam.isAVassal() and not askedTeam.isVassal(askingTeam.getID()):
        return False
    return TradeUtil.canTrade(askingPlayer, askedPlayer)
 def onBeginActivePlayerTurn(self, argsList):
     if (not Civ4lertsOpt.isShowGoldPerTurnTradeAlert()):
         return
     if len(self.maxGoldPerTurnTrade) == 0:
         return
     playerID = PlayerUtil.getActivePlayerID()
     for rival in TradeUtil.getGoldTradePartners(playerID):
         rivalID = rival.getID()
         oldMaxGoldPerTurnTrade = self._getMaxGoldPerTurnTrade(
             playerID, rivalID)
         newMaxGoldPerTurnTrade = rival.AI_maxGoldPerTurnTrade(playerID)
         deltaMaxGoldPerTurnTrade = newMaxGoldPerTurnTrade - oldMaxGoldPerTurnTrade
         if (deltaMaxGoldPerTurnTrade >=
                 Civ4lertsOpt.getGoldPerTurnTradeThreshold()):
             message = localText.getText(
                 "TXT_KEY_CIV4LERTS_ON_GOLD_PER_TURN_TRADE",
                 (rival.getCivilizationShortDescription(0),
                  newMaxGoldPerTurnTrade))
             addMessageNoIcon(playerID, message)
             self._setMaxGoldPerTurnTrade(playerID, rivalID,
                                          newMaxGoldPerTurnTrade)
         else:
             maxGoldPerTurnTrade = min(oldMaxGoldPerTurnTrade,
                                       newMaxGoldPerTurnTrade)
             self._setMaxGoldPerTurnTrade(playerID, rivalID,
                                          maxGoldPerTurnTrade)
Exemple #6
0
def isWHEOOH(playerOrID, askingPlayerOrID):
	"""
	Returns True if askingPlayerOrID can see that playerOrID is WHEOOH.
	
	In game terms, this is the case if the player gives the TOO_MANY_WARS denial type
	for a request to go to war against a rival.
	"""
	askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
	askingPlayer, askingTeam = getPlayerAndTeam(askingPlayerOrID)
	if not TradeUtil.canTrade(askingPlayer, askedPlayer):
		return False
	tradeData = TradeData()
	tradeData.ItemType = TradeableItems.TRADE_WAR
	for player in players(alive=True, barbarian=False, minor=False):
		eTeam = player.getTeam()
		if eTeam == askingPlayer.getTeam() or eTeam == askedPlayer.getTeam() or askedTeam.isAtWar(eTeam):
			# won't DoW your team, their team, or a team they are fighting
			continue
		if not ((askingTeam.isHasMet(eTeam) and askedTeam.isHasMet(eTeam)) or gc.getGame().isDebugMode()):
			# won't DoW someone you or they haven't met
			continue
		tradeData.iData = eTeam
		if askedPlayer.canTradeItem(askingPlayer.getID(), tradeData, False):
			denial = askedPlayer.getTradeDenial(askingPlayer.getID(), tradeData)
			if denial == DenialTypes.DENIAL_TOO_MANY_WARS:
				return True
	return False
Exemple #7
0
def getPossibleWars(playerOrID, askingPlayerOrID):
	"""
	Returns a tuple containing the WHEOOH status of the given player and 
	a list of all CyPlayers on which playerOrID will declare war in a trade.
	
	The askingPlayerOrID is used to limit the list to players they have met.
	"""
	askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
	askingPlayer, askingTeam = getPlayerAndTeam(askingPlayerOrID)
	if not TradeUtil.canTrade(askingPlayer, askedPlayer):
		return (False, ())
	wheooh = False
	wars = []
	tradeData = TradeData()
	tradeData.ItemType = TradeableItems.TRADE_WAR
	for player in players(alive=True, barbarian=False, minor=False):
		eTeam = player.getTeam()
		if eTeam == askingPlayer.getTeam() or eTeam == askedPlayer.getTeam() or askedTeam.isAtWar(eTeam):
			# won't DoW your team, their team, or a team they are fighting
			continue
		if not ((askingTeam.isHasMet(eTeam) and askedTeam.isHasMet(eTeam)) or gc.getGame().isDebugMode()):
			# won't DoW someone you or they haven't met
			continue
		tradeData.iData = eTeam
		if askedPlayer.canTradeItem(askingPlayer.getID(), tradeData, False):
			denial = askedPlayer.getTradeDenial(askingPlayer.getID(), tradeData)
			if denial == DenialTypes.NO_DENIAL:
				wars.append(player)
			elif denial == DenialTypes.DENIAL_TOO_MANY_WARS:
				wheooh = True
	return (wheooh, wars)
Exemple #8
0
def getPossibleEmbargos(playerOrID, askingPlayerOrID):
    """
    Returns a list of all CyPlayers with which playerOrID will stop trading.

    The askingPlayerOrID is used to limit the list to players they have met.
    """
    askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
    askingPlayer, askingTeam = getPlayerAndTeam(askingPlayerOrID)
    if not TradeUtil.canTrade(askingPlayer, askedPlayer):
        return ()
    embargos = []
    tradeData = TradeData()
    tradeData.ItemType = TradeableItems.TRADE_EMBARGO
    for player in players(alive=True, barbarian=False, minor=False):
        eTeam = player.getTeam()
        if eTeam == askingPlayer.getTeam() or eTeam == askedPlayer.getTeam(
        ) or askedTeam.isAtWar(eTeam):
            # won't embargo your team, their team, or a team they are fighting
            continue
        if not ((askingTeam.isHasMet(eTeam) and askedTeam.isHasMet(eTeam))
                or gc.getGame().isDebugMode()):
            # won't embargo someone you or they haven't met
            continue
        tradeData.iData = eTeam
        if askedPlayer.canTradeItem(askingPlayer.getID(), tradeData, True):
            embargos.append(player)
    return embargos
Exemple #9
0
def getPossibleWars(playerOrID, askingPlayerOrID):
    """
    Returns a tuple containing the WHEOOH status of the given player and
    a list of all CyPlayers on which playerOrID will declare war in a trade.

    The askingPlayerOrID is used to limit the list to players they have met.
    """
    askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
    askingPlayer, askingTeam = getPlayerAndTeam(askingPlayerOrID)
    if not TradeUtil.canTrade(askingPlayer, askedPlayer):
        return (False, ())
    wheooh = False
    wars = []
    tradeData = TradeData()
    tradeData.ItemType = TradeableItems.TRADE_WAR
    for player in players(alive=True, barbarian=False, minor=False):
        eTeam = player.getTeam()
        if eTeam == askingPlayer.getTeam() or eTeam == askedPlayer.getTeam(
        ) or askedTeam.isAtWar(eTeam):
            # won't DoW your team, their team, or a team they are fighting
            continue
        if not ((askingTeam.isHasMet(eTeam) and askedTeam.isHasMet(eTeam))
                or gc.getGame().isDebugMode()):
            # won't DoW someone you or they haven't met
            continue
        tradeData.iData = eTeam
        if askedPlayer.canTradeItem(askingPlayer.getID(), tradeData, False):
            denial = askedPlayer.getTradeDenial(askingPlayer.getID(),
                                                tradeData)
            if denial == DenialTypes.NO_DENIAL:
                wars.append(player)
            elif denial == DenialTypes.DENIAL_TOO_MANY_WARS:
                wheooh = True
    return (wheooh, wars)
Exemple #10
0
def isWHEOOH(playerOrID, askingPlayerOrID):
    """
    Returns True if askingPlayerOrID can see that playerOrID is WHEOOH.

    In game terms, this is the case if the player gives the TOO_MANY_WARS denial type
    for a request to go to war against a rival.
    """
    askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
    askingPlayer, askingTeam = getPlayerAndTeam(askingPlayerOrID)
    if not TradeUtil.canTrade(askingPlayer, askedPlayer):
        return False
    tradeData = TradeData()
    tradeData.ItemType = TradeableItems.TRADE_WAR
    for player in players(alive=True, barbarian=False, minor=False):
        eTeam = player.getTeam()
        if eTeam == askingPlayer.getTeam() or eTeam == askedPlayer.getTeam(
        ) or askedTeam.isAtWar(eTeam):
            # won't DoW your team, their team, or a team they are fighting
            continue
        if not ((askingTeam.isHasMet(eTeam) and askedTeam.isHasMet(eTeam))
                or gc.getGame().isDebugMode()):
            # won't DoW someone you or they haven't met
            continue
        tradeData.iData = eTeam
        if askedPlayer.canTradeItem(askingPlayer.getID(), tradeData, False):
            denial = askedPlayer.getTradeDenial(askingPlayer.getID(),
                                                tradeData)
            if denial == DenialTypes.DENIAL_TOO_MANY_WARS:
                return True
    return False
Exemple #11
0
def getPossibleEmbargos(playerOrID, askingPlayerOrID):
	"""
	Returns a list of all CyPlayers with which playerOrID will stop trading.
	
	The askingPlayerOrID is used to limit the list to players they have met.
	"""
	askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
	askingPlayer, askingTeam = getPlayerAndTeam(askingPlayerOrID)
	if not TradeUtil.canTrade(askingPlayer, askedPlayer):
		return ()
	embargos = []
	tradeData = TradeData()
	tradeData.ItemType = TradeableItems.TRADE_EMBARGO
	for player in players(alive=True, barbarian=False, minor=False):
		eTeam = player.getTeam()
		if eTeam == askingPlayer.getTeam() or eTeam == askedPlayer.getTeam() or askedTeam.isAtWar(eTeam):
			# won't embargo your team, their team, or a team they are fighting
			continue
		if not ((askingTeam.isHasMet(eTeam) and askedTeam.isHasMet(eTeam)) or gc.getGame().isDebugMode()):
			# won't embargo someone you or they haven't met
			continue
		tradeData.iData = eTeam
		if askedPlayer.canTradeItem(askingPlayer.getID(), tradeData, True):
			embargos.append(player)
	return embargos
Exemple #12
0
def getProposedTrade():
	trade = TradeUtil.Trade(PlayerUtil.getActivePlayerID(), diplo.getWhoTradingWith())
	if not diplo.ourOfferEmpty():
		getProposedTradeData(diplo.getPlayerTradeOffer, trade.addTrade)
	if not diplo.theirOfferEmpty():
		getProposedTradeData(diplo.getTheirTradeOffer, trade.addOtherTrade)
	BugUtil.debug("DiplomacyUtil.getProposedTrade - %r", trade)
	return trade
Exemple #13
0
	def getBonusSales(self, player):
		r = {}
		playerGoldTr = gc.getTeam(player.getTeam()).isGoldTrading()
		for other in TradeUtil.getBonusTradePartners(player):
			if other.isHuman():
				continue
			if not playerGoldTr and not gc.getTeam(other.getTeam()).isGoldTrading():
				continue
			if other.AI_maxGoldPerTurnTrade(player.getID()) <= 2:
				continue
			# As getBonusTrades, but switch the parameters in this call:
			will, wont = TradeUtil.getTradeableBonuses(player, other)
			r[other.getID()] = set()
			for iBonus in will.intersection(TradeUtil.getDesiredBonuses(other)):
				if player.getNumTradeableBonuses(iBonus) > 1 and player.AI_corporationBonusVal(iBonus) <= 0:
					r[other.getID()].add(iBonus)
		return r # </advc.210e>
def getProposedTrade():
    trade = TradeUtil.Trade(GAME.getActivePlayer(), diplo.getWhoTradingWith())
    if not diplo.ourOfferEmpty():
        getProposedTradeData(diplo.getPlayerTradeOffer, trade.addTrade)
    if not diplo.theirOfferEmpty():
        getProposedTradeData(diplo.getTheirTradeOffer, trade.addOtherTrade)
    print "DiplomacyUtil.getProposedTrade - %r" % trade
    return trade
def onHelpDemanded(argsList):
    eDemandPlayer, eTargetPlayer, pTrade = argsList
    of = GC.getPlayer(eDemandPlayer).getName()
    to = GC.getPlayer(eTargetPlayer).getName()
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems += TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    print "DiplomacyUtil - %s requests help (%s) from %s" % (of, szItems, to)
Exemple #16
0
def onHelpAccepted(argsList):
    #BugUtil.debug("DiplomacyUtil::onHelpAccepted %s" %(str(argsList)))
    eTargetPlayer, eDemandPlayer, pTrade = argsList
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    BugUtil.debug("DiplomacyUtil - %s agrees to give help (%s) to %s",
                  PlayerUtil.getPlayer(eTargetPlayer).getName(), szItems,
                  PlayerUtil.getPlayer(eDemandPlayer).getName())
Exemple #17
0
def onTributeDemanded(argsList):
    #BugUtil.debug("DiplomacyUtil::onTributeDemanded %s" %(str(argsList)))
    eDemandPlayer, eTargetPlayer, pTrade = argsList
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    BugUtil.debug("DiplomacyUtil - %s demands a tribute (%s) from %s",
                  PlayerUtil.getPlayer(eDemandPlayer).getName(), szItems,
                  PlayerUtil.getPlayer(eTargetPlayer).getName())
Exemple #18
0
def onTributeRejected(argsList):
    #BugUtil.debug("DiplomacyUtil::onTributeRejected %s" %(str(argsList)))
    eTargetPlayer, eDemandPlayer, pTrade = argsList
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    BugUtil.debug("DiplomacyUtil - %s refuses to give tribute (%s) to %s",
                  PlayerUtil.getPlayer(eTargetPlayer).getName(), szItems,
                  PlayerUtil.getPlayer(eDemandPlayer).getName())
def onTributeRejected(argsList):
    eTargetPlayer, eDemandPlayer, pTrade = argsList
    to = GC.getPlayer(eTargetPlayer).getName()
    of = GC.getPlayer(eDemandPlayer).getName()
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    print "DiplomacyUtil - %s refuses to give tribute (%s) to %s" % (
        to, szItems, of)
def onTributeDemanded(argsList):
    eDemandPlayer, eTargetPlayer, pTrade = argsList
    of = GC.getPlayer(eDemandPlayer).getName()
    to = GC.getPlayer(eTargetPlayer).getName()
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    print "DiplomacyUtil - %s demands a tribute (%s) from %s" % (of, szItems,
                                                                 to)
def onHelpAccepted(argsList):
    eTargetPlayer, eDemandPlayer, pTrade = argsList
    to = GC.getPlayer(eTargetPlayer).getName()
    of = GC.getPlayer(eDemandPlayer).getName()
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    print "DiplomacyUtil - %s agrees to give help (%s) to %s" % (to, szItems,
                                                                 of)
Exemple #22
0
	def _reset(self):
		self.maxGoldPerTurnTrade = {}
		# <advc.106c>
		for playerID in range(gc.getMAX_PLAYERS()):
			self.maxGoldPerTurnTrade[playerID] = {}
			for rivalID in range(gc.getMAX_PLAYERS()):
				self._setMaxGoldPerTurnTrade(playerID, rivalID, 0)
			for rival in TradeUtil.getGoldTradePartners(playerID):
				rivalID = rival.getID()
				self._setMaxGoldPerTurnTrade(playerID, rivalID, rival.AI_maxGoldPerTurnTrade(playerID))
Exemple #23
0
def onHelpAccepted(argsList):
	#BugUtil.debug("DiplomacyUtil::onHelpAccepted %s" %(str(argsList)))
	eTargetPlayer, eDemandPlayer, pTrade = argsList
	szItems = ""
	for i in range(pTrade.getCount()):
		szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
	BugUtil.debug("DiplomacyUtil - %s agrees to give help (%s) to %s",
			PlayerUtil.getPlayer(eTargetPlayer).getName(), 
			szItems,
			PlayerUtil.getPlayer(eDemandPlayer).getName())
Exemple #24
0
def onHelpDemanded(argsList):
	#BugUtil.debug("DiplomacyUtil::onHelpDemanded %s" %(str(argsList)))
	eDemandPlayer, eTargetPlayer, pTrade = argsList
	szItems = ""
	for i in range(pTrade.getCount()):
		szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
	BugUtil.debug("DiplomacyUtil - %s requests help (%s) from %s",
			PlayerUtil.getPlayer(eDemandPlayer).getCivilizationShortDescription(0), 
			szItems,
			PlayerUtil.getPlayer(eTargetPlayer).getCivilizationShortDescription(0))
Exemple #25
0
def onTributeAccepted(argsList):
	#BugUtil.debug("DiplomacyUtil::onTributeAccepted %s" %(str(argsList)))
	eTargetPlayer, eDemandPlayer, pTrade = argsList
	szItems = ""
	for i in range(pTrade.getCount()):
		szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
	BugUtil.debug("DiplomacyUtil - %s agrees to give tribute (%s) to %s",
			PlayerUtil.getPlayer(eTargetPlayer).getCivilizationShortDescription(0), 
			szItems,
			PlayerUtil.getPlayer(eDemandPlayer).getCivilizationShortDescription(0))
Exemple #26
0
def onTributeRejected(argsList):
	#BugUtil.debug("DiplomacyUtil::onTributeRejected %s" %(str(argsList)))
	eTargetPlayer, eDemandPlayer, pTrade = argsList
	szItems = ""
	for i in range(pTrade.getCount()):
		szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
	BugUtil.debug("DiplomacyUtil - %s refuses to give tribute (%s) to %s",
			PlayerUtil.getPlayer(eTargetPlayer).getName(), 
			szItems,
			PlayerUtil.getPlayer(eDemandPlayer).getName())
Exemple #27
0
def onTributeDemanded(argsList):
	#BugUtil.debug("DiplomacyUtil::onTributeDemanded %s" %(str(argsList)))
	eDemandPlayer, eTargetPlayer, pTrade = argsList
	szItems = ""
	for i in range(pTrade.getCount()):
		szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
	BugUtil.debug("DiplomacyUtil - %s demands a tribute (%s) from %s",
			PlayerUtil.getPlayer(eDemandPlayer).getName(), 
			szItems,
			PlayerUtil.getPlayer(eTargetPlayer).getName())
Exemple #28
0
	def getWarTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_WAR
		currentTrades = set()
		for loopPlayer in TradeUtil.getWarTraders(player):
			if player.canTradeWith(loopPlayer.getID()):
				###print "LOOP PLAYER: %s %d"%(gc.getLeaderHeadInfo(loopPlayer.getLeaderType()).getDescription(), loopPlayer.getID())
				canDoTrade = false
				for pPlayer in TradeUtil.getWarTraders(loopPlayer):
					if TradeUtil.canTrade(player, pPlayer):
						tradeData.iData = pPlayer.getID()
						###print "      %s DENIAL: %d"%(gc.getLeaderHeadInfo(pPlayer.getLeaderType()).getDescription(), loopPlayer.getTradeDenial(iPlayerID, tradeData))					
						if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL):
							canDoTrade = true				
					if canDoTrade:
						currentTrades.add(loopPlayer.getID())
						break
		return currentTrades
Exemple #29
0
	def getPeaceTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_PEACE_TREATY
		tradeData.iData = PEACE_TREATY_LENGTH
		currentTrades = set()
		for loopPlayer in TradeUtil.getPeaceTradePartners(player):
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #30
0
	def getDefensivePactTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_DEFENSIVE_PACT
		currentTrades = set()
		for loopPlayer in TradeUtil.getDefensivePactTradePartners(player):
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #31
0
	def getPermanentAllianceTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_PERMANENT_ALLIANCE
		currentTrades = set()
		for loopPlayer in TradeUtil.getPermanentAllianceTradePartners(player):
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #32
0
	def getOpenBordersTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_OPEN_BORDERS
		currentTrades = set()
		for loopPlayer in TradeUtil.getOpenBordersTradePartners(player):
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #33
0
	def getDefensivePactTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_DEFENSIVE_PACT
		currentTrades = set()
		for loopPlayer in TradeUtil.getDefensivePactTradePartners(player):
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #34
0
	def getPermanentAllianceTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_PERMANENT_ALLIANCE
		currentTrades = set()
		for loopPlayer in TradeUtil.getPermanentAllianceTradePartners(player):
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #35
0
	def getSurrenderTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_SURRENDER
		currentTrades = set()
		for loopPlayer in TradeUtil.getCapitulationTradePartners(player):
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #36
0
	def getOpenBordersTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_OPEN_BORDERS
		currentTrades = set()
		for loopPlayer in TradeUtil.getOpenBordersTradePartners(player):
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #37
0
	def getPeaceTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_PEACE_TREATY
		tradeData.iData = PEACE_TREATY_LENGTH
		currentTrades = set()
		for loopPlayer in TradeUtil.getPeaceTradePartners(player):
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				# advc.104i: Added call to AI_isWillingToTalk; the crucial UWAI check is in there.
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL and loopPlayer.AI_isWillingToTalk(iPlayerID)): 
					currentTrades.add(loopPlayer.getID())
		return currentTrades
def onHelpDemanded(argsList):
    # BugUtil.debug("DiplomacyUtil::onHelpDemanded %s" %(str(argsList)))
    eDemandPlayer, eTargetPlayer, pTrade = argsList
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    BugUtil.debug(
        "DiplomacyUtil - %s requests help (%s) from %s",
        PlayerUtil.getPlayer(eDemandPlayer).getCivilizationShortDescription(0),
        szItems,
        PlayerUtil.getPlayer(eTargetPlayer).getCivilizationShortDescription(0),
    )
def onTributeAccepted(argsList):
    # BugUtil.debug("DiplomacyUtil::onTributeAccepted %s" %(str(argsList)))
    eTargetPlayer, eDemandPlayer, pTrade = argsList
    szItems = ""
    for i in range(pTrade.getCount()):
        szItems = szItems + TradeUtil.format(eTargetPlayer, pTrade.getTrade(i))
    BugUtil.debug(
        "DiplomacyUtil - %s agrees to give tribute (%s) to %s",
        PlayerUtil.getPlayer(eTargetPlayer).getCivilizationShortDescription(0),
        szItems,
        PlayerUtil.getPlayer(eDemandPlayer).getCivilizationShortDescription(0),
    )
Exemple #40
0
 def getWarTrades(self, player, team):
     iPlayerID = player.getID()
     tradeData = TradeData()
     tradeData.ItemType = TradeableItems.TRADE_WAR
     currentTrades = set()
     for loopPlayer in TradeUtil.getWarTraders(player):
         if player.canTradeWith(loopPlayer.getID()):
             ###print "LOOP PLAYER: %s %d"%(gc.getLeaderHeadInfo(loopPlayer.getLeaderType()).getDescription(), loopPlayer.getID())
             canDoTrade = false
             for pPlayer in TradeUtil.getWarTraders(loopPlayer):
                 if TradeUtil.canTrade(player, pPlayer):
                     tradeData.iData = pPlayer.getID()
                     ###print "      %s DENIAL: %d"%(gc.getLeaderHeadInfo(pPlayer.getLeaderType()).getDescription(), loopPlayer.getTradeDenial(iPlayerID, tradeData))
                     if (loopPlayer.getTradeDenial(
                             iPlayerID,
                             tradeData) == DenialTypes.NO_DENIAL):
                         canDoTrade = true
                 if canDoTrade:
                     currentTrades.add(loopPlayer.getID())
                     break
     return currentTrades
Exemple #41
0
	def fillTable(self, screen, table, eYield, eTileType):
		"""Fills the given GFC table control with the chosen yield values."""
		self.iRow = 0
		# Tiles
		iTotal = self.getYield(eYield, eTileType)
		self.appendTable(screen, table, False, BugUtil.getText(LABEL_KEYS[eTileType], (self.tileCounts[eTileType],)), eYield, iTotal)
		
		# Trade
		for eType in (DOMESTIC_TRADE, FOREIGN_TRADE):
			iValue = self.getYield(eYield, eType)
			if iValue != 0:
				self.appendTable(screen, table, False, BugUtil.getPlainText(LABEL_KEYS[eType]), eYield, iValue, TradeUtil.isFractionalTrade())
		iValue = self.getYield(eYield, DOMESTIC_TRADE) + self.getYield(eYield, FOREIGN_TRADE)
		if TradeUtil.isFractionalTrade():
			iValue //= 100
		iTotal += iValue
		
		# Buildings, Corporations, Specialists
		for eType in (BUILDINGS, CORPORATIONS, SPECIALISTS):
			iValue = self.getYield(eYield, eType)
			if iValue != 0:
				iTotal += iValue
				self.appendTable(screen, table, False, BugUtil.getPlainText(LABEL_KEYS[eType]), eYield, iValue)
		
		# Subtotal and Base Modifiers
		iModifier = self.getYield(eYield, BASE_MODIFIER)
		if iModifier != 0:
			# Subtotal
			self.appendTableTotal(screen, table, eYield, iTotal)
			#self.appendTable(screen, table, True, BugUtil.getPlainText("TXT_KEY_CONCEPT_SUBTOTAL"), eYield, iTotal)
			# Modifier
			iValue = (iTotal * (iModifier + 100) // 100) - iTotal
			iSubtotal = iTotal + iValue
			self.appendTable(screen, table, False, BugUtil.getText("TXT_KEY_CONCEPT_BASE_MODIFIER", (iModifier,)), eYield, iValue)
		else:
			iSubtotal = iTotal
		
		# Subtotal and Production Modifiers
		if eYield == YieldTypes.YIELD_PRODUCTION and self.iProductionModifier != 0:
			# Subtotal
			self.appendTableTotal(screen, table, eYield, iSubtotal)
			#self.appendTable(screen, table, True, BugUtil.getPlainText("TXT_KEY_CONCEPT_SUBTOTAL"), eYield, iSubtotal)
			# Total
			iTotal = iTotal * (iModifier + self.iProductionModifier + 100) // 100
			# Modifier
			iValue = iTotal - iSubtotal
			self.appendTable(screen, table, False, BugUtil.getText("TXT_KEY_CONCEPT_PRODUCTION_MODIFIER", (self.sModifierDetail, self.iProductionModifier)), eYield, iValue)
		else:
			iTotal = iSubtotal
		
		# Total
		self.appendTableTotal(screen, table, eYield, iTotal)
Exemple #42
0
 def getPeaceTrades(self, player, team):
     iPlayerID = player.getID()
     tradeData = TradeData()
     tradeData.ItemType = TradeableItems.TRADE_PEACE_TREATY
     tradeData.iData = PEACE_TREATY_LENGTH
     currentTrades = set()
     for loopPlayer in TradeUtil.getPeaceTradePartners(player):
         if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
             if (loopPlayer.getTradeDenial(
                     iPlayerID,
                     tradeData) == DenialTypes.NO_DENIAL):  # will trade
                 currentTrades.add(loopPlayer.getID())
     return currentTrades
Exemple #43
0
 def getSurrenderTrades(self, player, team):
     iPlayerID = player.getID()
     tradeData = TradeData()
     tradeData.ItemType = TradeableItems.TRADE_SURRENDER
     currentTrades = set()
     for loopPlayer in TradeUtil.getCapitulationTradePartners(player):
         #tradeData.iData = None
         if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
             if (loopPlayer.getTradeDenial(
                     iPlayerID,
                     tradeData) == DenialTypes.NO_DENIAL):  # will trade
                 currentTrades.add(loopPlayer.getID())
     return currentTrades
Exemple #44
0
	def getVassalTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_VASSAL
		currentTrades = set()
		for loopPlayer in TradeUtil.getVassalTradePartners(player):
			# <advc.135>
			if gc.getTeam(loopPlayer.getTeam()).isHuman():
				continue # </advc.135>
			#tradeData.iData = None
			if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
				if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
					currentTrades.add(loopPlayer.getID())
		return currentTrades
Exemple #45
0
	def getTechTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_TECHNOLOGIES
		techsByPlayer = {}
		for loopPlayer in TradeUtil.getTechTradePartners(player):
			techsToTrade = set()
			for iLoopTech in range(gc.getNumTechInfos()):
				tradeData.iData = iLoopTech
				if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
					if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
						techsToTrade.add(iLoopTech)
			techsByPlayer[loopPlayer.getID()] = techsToTrade
		return techsByPlayer
Exemple #46
0
	def getTechTrades(self, player, team):
		iPlayerID = player.getID()
		tradeData = TradeData()
		tradeData.ItemType = TradeableItems.TRADE_TECHNOLOGIES
		techsByPlayer = {}
		for loopPlayer in TradeUtil.getTechTradePartners(player):
			techsToTrade = set()
			for iLoopTech in range(gc.getNumTechInfos()):
				tradeData.iData = iLoopTech
				if (loopPlayer.canTradeItem(iPlayerID, tradeData, False)):
					if (loopPlayer.getTradeDenial(iPlayerID, tradeData) == DenialTypes.NO_DENIAL): # will trade
						techsToTrade.add(iLoopTech)
			techsByPlayer[loopPlayer.getID()] = techsToTrade
		return techsByPlayer
Exemple #47
0
	def onBeginActivePlayerTurn(self, argsList):
		if (not Civ4lertsOpt.isShowGoldTradeAlert()):
			return
		playerID = PlayerUtil.getActivePlayerID()
		for rival in TradeUtil.getGoldTradePartners(playerID):
			rivalID = rival.getID()
			oldMaxGoldTrade = self._getMaxGoldTrade(playerID, rivalID)
			newMaxGoldTrade = rival.AI_maxGoldTrade(playerID)
			deltaMaxGoldTrade = newMaxGoldTrade - oldMaxGoldTrade
			if deltaMaxGoldTrade >= Civ4lertsOpt.getGoldTradeThreshold():
				message = localText.getText("TXT_KEY_CIV4LERTS_ON_GOLD_TRADE", (rival.getName(), newMaxGoldTrade))
				addMessageNoIcon(playerID, message)
				self._setMaxGoldTrade(playerID, rivalID, newMaxGoldTrade)
			elif newMaxGoldTrade < oldMaxGoldTrade:
				self._setMaxGoldTrade(playerID, rivalID, newMaxGoldTrade)
Exemple #48
0
	def onBeginActivePlayerTurn(self, argsList):
		if (not Civ4lertsOpt.isShowGoldTradeAlert()):
			return
		playerID = GAME.getActivePlayer()
		for rival in TradeUtil.getGoldTradePartners(playerID):
			rivalID = rival.getID()
			oldMaxGoldTrade = self._getMaxGoldTrade(playerID, rivalID)
			newMaxGoldTrade = rival.AI_maxGoldTrade(playerID)
			deltaMaxGoldTrade = newMaxGoldTrade - oldMaxGoldTrade
			if deltaMaxGoldTrade >= Civ4lertsOpt.getGoldTradeThreshold():
				message = TRNSLTR.getText("TXT_KEY_CIV4LERTS_ON_GOLD_TRADE", (rival.getName(), newMaxGoldTrade))
				addMessage(playerID, message)
				self._setMaxGoldTrade(playerID, rivalID, newMaxGoldTrade)
			elif newMaxGoldTrade < oldMaxGoldTrade:
				self._setMaxGoldTrade(playerID, rivalID, newMaxGoldTrade)
	def onBeginActivePlayerTurn(self, argsList):
		if not Civ4lertsOpt.isShowSlaveTradeAlert():
			return
		if len(self.maxSlaveTrade) == 0:
			return
		playerID = PlayerUtil.getActivePlayerID()
		for rival in TradeUtil.getSlaveTradePartners(playerID):
			rivalID = rival.getID()
			oldMaxSlaveTrade = self._getMaxSlaveTrade(playerID, rivalID)
			newMaxSlaveTrade = rival.getUnitClassCount(gc.getInfoTypeForString("UNITCLASS_SLAVE"))
			deltaMaxSlaveTrade = newMaxSlaveTrade - oldMaxSlaveTrade
			if deltaMaxSlaveTrade > 0:
				message = localText.getText("TXT_KEY_CIV4LERTS_ON_SLAVE_TRADE", (rival.getCivilizationShortDescription(0), newMaxSlaveTrade))
				addMessageNoIcon(playerID, message)
				self._setMaxSlaveTrade(playerID, rivalID, newMaxSlaveTrade)
			elif newMaxSlaveTrade < oldMaxSlaveTrade:
				self._setMaxSlaveTrade(playerID, rivalID, newMaxSlaveTrade)
Exemple #50
0
def canSeeCityList(playerOrID):
	"""
	Returns True if the active player can see the list of <player>'s cities.
	
	In the unmodified game, this is possible if the players have met and <player>
	is not a vassal of a rival. They must be able to contact (trade with)
	<player>, and OCC must be disabled. You can always see a teammate's cities.
	"""
	if GameUtil.isOCC():
		return False
	askedPlayer, askedTeam = getPlayerAndTeam(playerOrID)
	askingPlayer, askingTeam = getActivePlayerAndTeam()
	if askingPlayer.getTeam() == askedPlayer.getTeam():
		return True
	if askedTeam.isAVassal() and not askedTeam.isVassal(askingTeam.getID()):
		return False
	return TradeUtil.canTrade(askingPlayer, askedPlayer)
	def onBeginActivePlayerTurn(self, argsList):
		if (not Civ4lertsOpt.isShowGoldPerTurnTradeAlert()):
			return
		if len(self.maxGoldPerTurnTrade) == 0:
			return
		playerID = PlayerUtil.getActivePlayerID()
		for rival in TradeUtil.getGoldTradePartners(playerID):
			rivalID = rival.getID()
			oldMaxGoldPerTurnTrade = self._getMaxGoldPerTurnTrade(playerID, rivalID)
			newMaxGoldPerTurnTrade = rival.AI_maxGoldPerTurnTrade(playerID)
			deltaMaxGoldPerTurnTrade = newMaxGoldPerTurnTrade - oldMaxGoldPerTurnTrade
			if (deltaMaxGoldPerTurnTrade >= Civ4lertsOpt.getGoldPerTurnTradeThreshold()):
				message = localText.getText("TXT_KEY_CIV4LERTS_ON_GOLD_PER_TURN_TRADE", (rival.getCivilizationShortDescription(0), newMaxGoldPerTurnTrade))
				addMessageNoIcon(playerID, message)
				self._setMaxGoldPerTurnTrade(playerID, rivalID, newMaxGoldPerTurnTrade)
			else:
				maxGoldPerTurnTrade = min(oldMaxGoldPerTurnTrade, newMaxGoldPerTurnTrade)
				self._setMaxGoldPerTurnTrade(playerID, rivalID, maxGoldPerTurnTrade)
Exemple #52
0
	def CheckForAlerts(self, iActivePlayer, activeTeam, BeginTurn):
	##Added "else: pass" code to diagnose strange results - might be related to indent issues
		ourPop = 0
		ourLand = 0
		totalPop = 0
		totalLand = 0
		LimitPop =0
		LimitLand = 0
		DomVictory = 3
		popGrowthCount = 0
		currentTurn = gc.getGame().getGameTurn()
		activePlayer = gc.getPlayer(iActivePlayer)

		if (self.getCheckForDomPopVictory() or (BeginTurn and self.getCheckForCityBorderExpansion())):
			# Check for cultural expansion and population growth
			teamPlayerList = []
			teamPlayerList = PyGame.getCivTeamList(PyGame.getActiveTeam())
			teamPlayerList.append(PyPlayer(iActivePlayer))
			for loopPlayer in range(len(teamPlayerList)):
				lCity = []
				# EF: This looks very wrong. Above the list of players will not be 0, 1, ...
				#     but here it uses loopPlayer which is 0, 1, ...
				lCity = PyPlayer(loopPlayer).getCityList()
				for loopCity in range(len(lCity)):
					city = gc.getPlayer(loopPlayer).getCity(loopCity)
					if (city.getFoodTurnsLeft() == 1 and not city.isFoodProduction()) and not city.AI_isEmphasize(5):
						popGrowthCount = popGrowthCount + 1
					if (BeginTurn and self.getCheckForCityBorderExpansion()):
						if (city.getCultureLevel() != gc.getNumCultureLevelInfos() - 1):
							if ((city.getCulture(loopPlayer) + city.getCommerceRate(CommerceTypes.COMMERCE_CULTURE)) >= city.getCultureThreshold()):
								message = localText.getText("TXT_KEY_MORECIV4LERTS_CITY_TO_EXPAND",(city.getName(),))
								icon = "Art/Interface/Buttons/General/Warning_popup.dds"
								self._addMessageAtCity(loopPlayer, message, icon, city)
							else: pass
						else: pass #expand check
					else: pass #message check
				else: pass #end city loop
			else: pass #end activePlayer loop
		else: pass # end expansion check / pop count

		# Check Domination Limit
		if (self.getCheckForDomVictory() and gc.getGame().isVictoryValid(DomVictory)):
			
			# Population Limit
			if (self.getCheckForDomPopVictory()):
				VictoryPopPercent = 0.0
				VictoryPopPercent = gc.getGame().getAdjustedPopulationPercent(DomVictory) * 1.0
				totalPop = gc.getGame().getTotalPopulation()
				LimitPop = int((totalPop * VictoryPopPercent) / 100.0)
				ourPop = activeTeam.getTotalPopulation()
				if (totalPop > 0):
					popPercent = (ourPop * 100.0) / totalPop
					NextpopPercent = ((ourPop + popGrowthCount) * 100.0) / totalPop
				else:
					popPercent = 0.0
					NextpopPercent = 0.0

				if (totalPop > 1 and (currentTurn <> self.lastDomLimitMsgTurn or (ourPop + popGrowthCount) <> self.lastPopCount)):
					self.lastPopCount = ourPop + popGrowthCount
					if (popPercent >= VictoryPopPercent):
						message = localText.getText("TXT_KEY_MORECIV4LERTS_POP_EXCEEDS_LIMIT",
						   		(ourPop, (u"%.2f%%" % popPercent), LimitPop, (u"%.2f%%" % VictoryPopPercent)))
						self._addMessageNoIcon(iActivePlayer, message)

					elif (popGrowthCount > 0 and NextpopPercent >= VictoryPopPercent):
						message = localText.getText("TXT_KEY_MORECIV4LERTS_POP_GROWTH_EXCEEDS_LIMIT",
						   		(ourPop, popGrowthCount, (u"%.2f%%" % NextpopPercent), LimitPop, (u"%.2f%%" % VictoryPopPercent)))
						self._addMessageNoIcon(iActivePlayer, message)

					elif (popGrowthCount > 0 and (VictoryPopPercent - NextpopPercent < self.getPopThreshold())):
						message = localText.getText("TXT_KEY_MORECIV4LERTS_POP_GROWTH_CLOSE_TO_LIMIT",
						   		(ourPop, popGrowthCount, (u"%.2f%%" % NextpopPercent), LimitPop, (u"%.2f%%" % VictoryPopPercent)))
						self._addMessageNoIcon(iActivePlayer, message)

## .005 			elif (VictoryPopPercent - popPercent < self.getPopThreshold()):
					elif (popGrowthCount > 0 and (VictoryPopPercent - popPercent < self.getPopThreshold())):
						message = localText.getText("TXT_KEY_MORECIV4LERTS_POP_CLOSE_TO_LIMIT",
						   		(ourPop, (u"%.2f%%" % popPercent), LimitPop, (u"%.2f%%" % VictoryPopPercent)))
						self._addMessageNoIcon(iActivePlayer, message)
					else: pass #end elif
				else: pass #end totalPop if
			else: pass #end pop limit if

			# Land Limit
			if (self.getCheckForDomLandVictory()):
				VictoryLandPercent = 0.0
				VictoryLandPercent = gc.getGame().getAdjustedLandPercent(DomVictory) * 1.0
				totalLand = gc.getMap().getLandPlots()
				LimitLand = int((totalLand * VictoryLandPercent) / 100.0)
				ourLand = activeTeam.getTotalLand()
				if (totalLand > 0):
					landPercent = (ourLand * 100.0) / totalLand
				else:
					landPercent = 0.0
				if (currentTurn <> self.lastDomLimitMsgTurn or ourLand <> self.lastLandCount):
					self.lastLandCount = ourLand
					if (landPercent > VictoryLandPercent):
						message = localText.getText("TXT_KEY_MORECIV4LERTS_LAND_EXCEEDS_LIMIT",
								(ourLand, (u"%.2f%%" % landPercent), LimitLand, (u"%.2f%%" % VictoryLandPercent)))
						self._addMessageNoIcon(iActivePlayer, message)
					elif (VictoryLandPercent - landPercent < self.getLandThreshold()):
						message = localText.getText("TXT_KEY_MORECIV4LERTS_LAND_CLOSE_TO_LIMIT",
								(ourLand, (u"%.2f%%" % landPercent), LimitLand, (u"%.2f%%" % VictoryLandPercent)))
						self._addMessageNoIcon(iActivePlayer, message)
					else: pass #end elif
				else: pass #end currentTurn if
			else: pass #end land limit if
		else: pass #end dom limt if
	
		#save turn num
		if (self.getCheckForDomVictory()):
			self.lastDomLimitMsgTurn = currentTurn

		# tech trades
		if (BeginTurn and self.getCheckForTechs()):
			researchTechs = set()
			for iTech in range(gc.getNumTechInfos()):
				if (activePlayer.canResearch(iTech, True)):
					researchTechs.add(iTech)
			techsByPlayer = self.getTechTrades(activePlayer, activeTeam)
			for iLoopPlayer, currentTechs in techsByPlayer.iteritems():

				#Did he have trades avail last turn
				if (self.PrevAvailTechTrades.has_key(iLoopPlayer)):
					previousTechs = self.PrevAvailTechTrades[iLoopPlayer]
				else:
					previousTechs = set()
					
				#Determine new techs
				newTechs = currentTechs.difference(previousTechs).intersection(researchTechs)
				if (newTechs):
					szNewTechs = self.buildTechString(newTechs)
					message = localText.getText("TXT_KEY_MORECIV4LERTS_NEW_TECH_AVAIL",	
												(gc.getPlayer(iLoopPlayer).getName(), szNewTechs))
					self._addMessageNoIcon(iActivePlayer, message)
				
				#Determine removed techs
				removedTechs = previousTechs.difference(currentTechs).intersection(researchTechs)
				if (removedTechs):
					szRemovedTechs = self.buildTechString(removedTechs)
					message = localText.getText("TXT_KEY_MORECIV4LERTS_TECH_NOT_AVAIL",	
												(gc.getPlayer(iLoopPlayer).getName(), szRemovedTechs))
					self._addMessageNoIcon(iActivePlayer, message)
				
			else: pass #end activePlayer loop

			#save curr trades for next time
			self.PrevAvailTechTrades = techsByPlayer

		else: pass #end new trades if
		
		# bonus trades
		if (BeginTurn and self.getCheckForBonuses()):
			desiredBonuses = TradeUtil.getDesiredBonuses(activePlayer)
			tradesByPlayer = self.getBonusTrades(activePlayer, activeTeam)
			for iLoopPlayer, currentTrades in tradesByPlayer.iteritems():

				#Did he have trades avail last turn
				if (self.PrevAvailBonusTrades.has_key(iLoopPlayer)):
					previousTrades = self.PrevAvailBonusTrades[iLoopPlayer]
				else:
					previousTrades = set()
					
				#Determine new bonuses
				newTrades = currentTrades.difference(previousTrades).intersection(desiredBonuses)
				if (newTrades):
					szNewTrades = self.buildBonusString(newTrades)
					message = localText.getText("TXT_KEY_MORECIV4LERTS_NEW_BONUS_AVAIL",	
												(gc.getPlayer(iLoopPlayer).getName(), szNewTrades))
					self._addMessageNoIcon(iActivePlayer, message)
				
				#Determine removed bonuses
				removedTrades = previousTrades.difference(currentTrades).intersection(desiredBonuses)
				if (removedTrades):
					szRemovedTrades = self.buildBonusString(removedTrades)
					message = localText.getText("TXT_KEY_MORECIV4LERTS_BONUS_NOT_AVAIL",	
												(gc.getPlayer(iLoopPlayer).getName(), szRemovedTrades))
					self._addMessageNoIcon(iActivePlayer, message)

			#save curr trades for next time
			self.PrevAvailBonusTrades = tradesByPlayer
		
		if (BeginTurn and self.getCheckForMap()):
			currentTrades = self.getMapTrades(activePlayer, activeTeam)
			newTrades = currentTrades.difference(self.PrevAvailMapTrades)
			self.PrevAvailMapTrades = currentTrades
			if (newTrades):
				players = self.buildPlayerString(newTrades)
				message = localText.getText("TXT_KEY_MORECIV4LERTS_MAP", (players,))
				self._addMessageNoIcon(iActivePlayer, message)
		
		if (BeginTurn and self.getCheckForOpenBorders()):
			currentTrades = self.getOpenBordersTrades(activePlayer, activeTeam)
			newTrades = currentTrades.difference(self.PrevAvailOpenBordersTrades)
			self.PrevAvailOpenBordersTrades = currentTrades
			if (newTrades):
				players = self.buildPlayerString(newTrades)
				message = localText.getText("TXT_KEY_MORECIV4LERTS_OPEN_BORDERS", (players,))
				self._addMessageNoIcon(iActivePlayer, message)
		
		if (BeginTurn and self.getCheckForDefensivePact()):
			currentTrades = self.getDefensivePactTrades(activePlayer, activeTeam)
			newTrades = currentTrades.difference(self.PrevAvailDefensivePactTrades)
			self.PrevAvailDefensivePactTrades = currentTrades
			if (newTrades):
				players = self.buildPlayerString(newTrades)
				message = localText.getText("TXT_KEY_MORECIV4LERTS_DEFENSIVE_PACT", (players,))
				self._addMessageNoIcon(iActivePlayer, message)
		
		if (BeginTurn and self.getCheckForPermanentAlliance()):
			currentTrades = self.getPermanentAllianceTrades(activePlayer, activeTeam)
			newTrades = currentTrades.difference(self.PrevAvailPermanentAllianceTrades)
			self.PrevAvailPermanentAllianceTrades = currentTrades
			if (newTrades):
				players = self.buildPlayerString(newTrades)
				message = localText.getText("TXT_KEY_MORECIV4LERTS_PERMANENT_ALLIANCE", (players,))
				self._addMessageNoIcon(iActivePlayer, message)
		
		if (BeginTurn and self.getCheckForVassal()):
			currentTrades = self.getVassalTrades(activePlayer, activeTeam)
			newTrades = currentTrades.difference(self.PrevAvailVassalTrades)
			self.PrevAvailVassalTrades = currentTrades
			if (newTrades):
				players = self.buildPlayerString(newTrades)
				message = localText.getText("TXT_KEY_MORECIV4LERTS_VASSAL", (players,))
				self._addMessageNoIcon(iActivePlayer, message)
		
		if (BeginTurn and self.getCheckForSurrender()):
			currentTrades = self.getSurrenderTrades(activePlayer, activeTeam)
			newTrades = currentTrades.difference(self.PrevAvailSurrenderTrades)
			self.PrevAvailSurrenderTrades = currentTrades
			if (newTrades):
				players = self.buildPlayerString(newTrades)
				message = localText.getText("TXT_KEY_MORECIV4LERTS_SURRENDER", (players,))
				self._addMessageNoIcon(iActivePlayer, message)
		
		if (BeginTurn and self.getCheckForPeace()):
			currentTrades = self.getPeaceTrades(activePlayer, activeTeam)
			newTrades = currentTrades.difference(self.PrevAvailPeaceTrades)
			self.PrevAvailPeaceTrades = currentTrades
			if (newTrades):
				players = self.buildPlayerString(newTrades)
				message = localText.getText("TXT_KEY_MORECIV4LERTS_PEACE_TREATY", (players,))
				self._addMessageNoIcon(iActivePlayer, message)
Exemple #53
0
	def getBonusTrades(self, player, team):
		bonusesByPlayer = {}
		for loopPlayer in TradeUtil.getBonusTradePartners(player):
			will, wont = TradeUtil.getTradeableBonuses(loopPlayer, player)
			bonusesByPlayer[loopPlayer.getID()] = will
		return bonusesByPlayer