home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / Screens / CvDebugInfoScreen.py < prev    next >
Encoding:
Python Source  |  2005-11-09  |  14.8 KB  |  515 lines
  1. ## Sid Meier's Civilization 4
  2. ## Copyright Firaxis Games 2005
  3. from CvPythonExtensions import *
  4. import CvUtil
  5. import PyHelpers
  6. import ScreenInput
  7. import CvScreenEnums
  8. import CvMapGeneratorUtil
  9. import CvGFCScreen
  10.  
  11. PyPlayer = PyHelpers.PyPlayer
  12.  
  13. # globals
  14. gc = CyGlobalContext()
  15. ArtFileMgr = CyArtFileMgr()
  16.  
  17. list_Widget = []
  18. g_iLastScreen = 0
  19.  
  20. class CvDebugInfoScreen(CvGFCScreen.CvGFCScreen):
  21.     'Debug Information Screen'
  22.     
  23.     def __init__(self):
  24.         self.setScreenValues("DebugInfoScreen", CvScreenEnums.DEBUG_INFO_SCREEN)
  25.         
  26.         self.DebugInfoMap = {
  27.                      0 : { 'DESC':    "Team Relations",             'DATA':    self.drawTeamRelations }, 
  28.                      1 : { 'DESC':    "Player Attitudes",         'DATA':    self.drawPlayerAttitudes },
  29.                      2 : { 'DESC':    "Civic Info",                 'DATA':    self.drawPlayerCivics },
  30.                      3 : { 'DESC':    "Civ Info",                 'DATA':    self.drawPlayerOverviewInfo },
  31.                      4 : { 'DESC':    "AI Types",                 'DATA':    self.drawPlayerUnitAITypes },
  32.                      5 : { 'DESC':    "Available Bonuses",         'DATA':    self.drawPlayerAvailableResources },
  33.                      6 : { 'DESC':    "Map Details",                'DATA': self.generateBonusDistributionList },
  34.                      }
  35.         self.CivInfoItems = ["Power", "Assets","Gold Reserve", "Gold Commerce", "Research Rate", "Total Maintenance", "Civic Upkeep", "Unit Cost", "Unit Supply", 
  36.                         "# Cities", "# Units", "# Citizens", "# Plots", "Current Tech"]
  37.  
  38.         self.WIDGET_ID = "DebugInfoScreenWidget"
  39.         self.nWidgetCount = 0
  40.  
  41.         self.szDebugInfoPulldownID = "DebugInfoScreenSelectType"
  42.         self.bTeam = false
  43.         self.bAttitude = false
  44.         self.iNumPlayers = -1
  45.         self.iNumTeams = -1
  46.  
  47.         self.W_CHART = 800
  48.         self.H_CHART = 400
  49.         
  50.         self.TITLE_TEXT_X = 502
  51.         self.TITLE_TEXT_Y = 8
  52.         self.TITLE_TEXT_Z = -2.5
  53.         
  54.         self.EXIT_TEXT_X = 502
  55.         self.EXIT_TEXT_Y = 12
  56.         self.EXIT_TEXT_Z = -2.6
  57.         
  58.         self.DROPDOWN_INFOTYPE_X = 405
  59.         self.DROPDOWN_INFOTYPE_Y = 47
  60.         
  61.         self.TABLE_START_X = 30
  62.         self.TABLE_START_Y = 70
  63.             
  64.     def interfaceScreen(self):
  65.         ' Create the screen '
  66.         global g_iLastScreen
  67.         screen = self.getScreen()
  68.         screen.showScreen(PopupStates.POPUPSTATE_IMMEDIATE, False)
  69.         screen.addDDSGFC("DebugInfoScreen", ArtFileMgr.getInterfaceArtInfo("SCREEN_BG_OPAQUE").getPath(), 0, 0, 1024, 768, WidgetTypes.WIDGET_GENERAL, -1, -1 )
  70.         #screen.addPanel( "DebugInfoMainTable", u"Debug Info", u"Debug Information", 
  71.         #                  0, 1, 
  72.         #                  self.TABLE_START_X,self.TABLE_START_Y, 
  73.         #                  900, 600, 
  74.         #                  PanelStyles.PANEL_STYLE_BLUELARGE )
  75.         
  76.         screen.setExitText( u"EXIT SCREEN", 
  77.                             CvUtil.FONT_RIGHT_JUSTIFY, 
  78.                             self.EXIT_TEXT_X, self.EXIT_TEXT_Y, self.EXIT_TEXT_Z, 
  79.                             FontTypes.TITLE_FONT )
  80.  
  81.         # Header...
  82.         screen.setText( "DebugInfoTitleHeader", "Background", u"DEBUG INFO", 
  83.                         CvUtil.FONT_CENTER_JUSTIFY, 
  84.                         self.TITLE_TEXT_X, self.TITLE_TEXT_Y, self.TITLE_TEXT_Z, 
  85.                         FontTypes.TITLE_FONT, 
  86.                         WidgetTypes.WIDGET_GENERAL, -1, -1 )
  87.         
  88.         # Create Drop Down so the user can select the screen they want
  89.         screen.addDropDownBoxGFC(self.szDebugInfoPulldownID,
  90.                                 self.DROPDOWN_INFOTYPE_X, self.DROPDOWN_INFOTYPE_Y, 300,
  91.                                 WidgetTypes.WIDGET_GENERAL, -1, -1,FontTypes.GAME_FONT )
  92.         
  93.         # adds the screen names to the drop down using the DebugInfoMap - always selects the last one that was selected
  94.         bSelected = false
  95.         
  96.         for i in range(len(self.DebugInfoMap)):
  97.             if i == g_iLastScreen:
  98.                 bSelected = true
  99.             
  100.             strInfoName = self.DebugInfoMap[i].get('DESC')
  101.             
  102.             screen.addPullDownString( self.szDebugInfoPulldownID, strInfoName, i, -1, bSelected )
  103.             bSelected = false
  104.         #draw the contents with the last selected screen
  105.         self.drawContents(g_iLastScreen)
  106.  
  107.     def drawContents(self, iInfoType = 0):
  108.         'Based on dropdown selection the screen will draw the appropriate info screen'
  109.         global g_iLastScreen
  110.         g_iLastScreen = iInfoType
  111.         
  112.         entry = self.DebugInfoMap.get(iInfoType)
  113.         entry.get('DATA')()
  114.             
  115.     def drawTeamRelations(self):
  116.         ' draws a table showing the relations of teams '
  117.         #CvUtil.pyPrint('CvDebugInfoScreen->drawTeamRelations')
  118.         d_TableData = {}
  119.         d_TableData[0] = self.setTeams()
  120.         
  121.         strBuffer = ""
  122.         iconName = "Error"
  123.         entry = "None"
  124.         list_loopRowData = []
  125.         
  126.         for x in range(self.iNumTeams):
  127.             
  128.             strBuffer = gc.getTeam(x).getName()
  129.             list_loopRowData.append(strBuffer)
  130.             strBuffer = ""
  131.             
  132.             for y in range(self.iNumTeams):
  133.                 pTeamX = gc.getTeam(x)
  134.                 pTeamY = gc.getTeam(y)
  135.                                 
  136.                 # if the same team
  137.                 if ( not x == y ):
  138.                     
  139.                     # if teams have met
  140.                     if pTeamX.isHasMet(y):
  141.                     
  142.                         # if at peace
  143.                         if not pTeamX.isAtWar(y):
  144.                         
  145.                             # if open borders
  146.                             if pTeamX.isDefensivePact(y):
  147.                                 strBuffer = "DefensivePact"
  148.                             
  149.                             # if open borders
  150.                             elif pTeamX.isOpenBorders(y):
  151.                                 strBuffer = "OpenBorders"
  152.                             
  153.                             # else use peace icon
  154.                             else:
  155.                                 strBuffer = "Peace"
  156.                                 
  157.                         # else indicate at War
  158.                         else:
  159.                             strBuffer = "War"
  160.                     
  161.                     # else they have not met
  162.                     else:
  163.                         strBuffer = "NotMet"
  164.                 
  165.                 # else use ally icon
  166.                 else:
  167.                     strBuffer = "Team"
  168.                 
  169.                 list_loopRowData.append(strBuffer)
  170.             
  171.             d_TableData[x+1] = list_loopRowData
  172.             list_loopRowData = []
  173.         
  174.         # add data to table
  175.         self.setTableData(d_TableData)
  176.  
  177.         return 0
  178.     
  179.     def drawPlayerAttitudes(self):
  180.         ' draws a table showing the attitudes between players '
  181.         #CvUtil.pyPrint('CvDebugInfoScreen->drawPlayerAttitudes')
  182.         self.bAttitude = True
  183.         d_TableData = {}
  184.         d_TableData[0] = self.setPlayers()
  185.         
  186.         strBuffer = ""
  187.         iconName = "None"
  188.         list_loopRowData = []
  189.         
  190.         for x in range(self.iNumPlayers):
  191.             
  192.             strBuffer = gc.getPlayer(x).getName()
  193.             list_loopRowData.append(strBuffer)
  194.             strBuffer = ""
  195.             
  196.             for y in range(self.iNumPlayers):
  197.                 pPlayerX = gc.getPlayer(x)
  198.                 pPlayerY = gc.getPlayer(y)
  199.                 
  200.                 pTeamX = gc.getTeam(pPlayerX.getTeam())
  201.                 pTeamY = gc.getTeam(pPlayerY.getTeam())
  202.                 
  203.                 # if the same Player
  204.                 if ( not x == y ):
  205.                     
  206.                     # if teams have met
  207.                     if pTeamX.isHasMet(y):
  208.                     
  209.                         iPlayerXAttitudeTowardPlayerY = pPlayerX.AI_getAttitude(y)
  210.                                                 
  211.                         strBuffer = "%s" %(gc.getAttitudeInfo(iPlayerXAttitudeTowardPlayerY).getDescription(),)
  212.                         list_loopRowData.append(strBuffer)
  213.                         strBuffer = ""
  214.                         continue # prevents the value from getting overwritten by a font icon
  215.                     
  216.                     # else they have not met
  217.                     else:
  218.                         strBuffer = "NotMet"
  219.                         
  220.                 # else use ally icon
  221.                 else:
  222.                     strBuffer = "Ally"
  223.                 
  224.                 list_loopRowData.append(strBuffer)
  225.                 strBuffer = ""
  226.             
  227.             d_TableData[x+1] = list_loopRowData
  228.             list_loopRowData = []
  229.         
  230.         # add data to table
  231.         self.setTableData(d_TableData)
  232.         
  233.         return 0
  234.     
  235.     def drawPlayerCivics(self):
  236.         d_TableData = {}
  237.         strName = ""
  238.         list_loopRowData = []
  239.         
  240.         d_TableData[0] = self.setPlayers("Civics")    
  241.         
  242.         for i in range( gc.getNumCivicOptionInfos() ):
  243.             strName = gc.getCivicOptionInfo(i).getDescription()
  244.             list_loopRowData.append(strName)
  245.             
  246.             for j in range( self.iNumPlayers ):
  247.                 strName = gc.getCivicInfo( int(gc.getPlayer(j).getCivics(i)) ).getDescription()
  248.                 list_loopRowData.append(strName)
  249.             
  250.             d_TableData[i+1] = list_loopRowData
  251.             list_loopRowData = []
  252.         
  253.         self.setTableData(d_TableData)
  254.         
  255.         return 0
  256.     
  257.     def drawPlayerOverviewInfo(self):
  258.         d_TableData = {}
  259.         strName = ""
  260.         list_loopRowData = []
  261.         
  262.         d_TableData[0] = self.setPlayers("Civ Info")
  263.         
  264.         for i in range( len(self.CivInfoItems) ):
  265.             strName = self.CivInfoItems[i]
  266.             list_loopRowData.append(strName)
  267.             
  268.             for j in range( self.iNumPlayers ):
  269.                 player = PyPlayer(j)
  270.                 pPlayer = gc.getPlayer(j)
  271.                 
  272.                 CivInfoFnx = [pPlayer.getPower(),pPlayer.getAssets(),player.getGold(), player.getGoldCommerceRate(), player.calculateResearchRate(), player.getTotalMaintenance(),
  273.                     player.getCivicUpkeep(), player.calculateUnitCost(), player.calculateUnitSupply(), player.getNumCities(),
  274.                     player.getNumUnits(), player.getTotalPopulation(), player.getTotalLand(), player.getCurrentTechName()]
  275.  
  276.                 strName = str(CivInfoFnx[i])
  277.                 list_loopRowData.append(strName)
  278.             
  279.             d_TableData[i+1] = list_loopRowData
  280.             list_loopRowData = []
  281.         
  282.         self.setTableData(d_TableData)
  283.         
  284.         return 0
  285.     
  286.     def drawPlayerUnitAITypes(self):
  287.         self.TITLE_X = 200
  288.         self.COLUMN_X = 75
  289.         
  290.         d_TableData = {}
  291.         strName = ""
  292.         list_loopRowData = []
  293.         
  294.         d_TableData[0] = self.setPlayers("Unit AI")
  295.         
  296.         for i in range( UnitAITypes.NUM_UNITAI_TYPES ):
  297.             strName = gc.getUnitAIInfo(i).getDescription()
  298.             strName.strip("UNITAI_")
  299.             list_loopRowData.append(strName)
  300.             
  301.             for j in range( self.iNumPlayers ):        
  302.                 strName = "%s" %( int(gc.getPlayer(j).AI_getNumAIUnits(i)), )
  303.                 list_loopRowData.append(strName)
  304.             
  305.             d_TableData[i+1] = list_loopRowData
  306.             list_loopRowData = []
  307.         
  308.         self.setTableData(d_TableData)
  309.         
  310.         return 0
  311.         
  312.     def drawPlayerAvailableResources(self):
  313.         ' Draws a table showing how many of each resource the player can trade '
  314.         d_TableData = {}
  315.         list_loopRowData = []
  316.         
  317.         d_TableData[0] = self.setPlayers("Available Bonuses")
  318.         
  319.         for i in range( gc.getNumBonusInfos() ):
  320.             list_loopRowData.append(gc.getBonusInfo(i).getDescription())
  321.             
  322.             for j in range( self.iNumPlayers ):
  323.                 list_loopRowData.append( int(gc.getPlayer(j).getNumAvailableBonuses(i)) )
  324.             d_TableData[i+1] = list_loopRowData
  325.             list_loopRowData = []
  326.  
  327.         self.setTableData(d_TableData)
  328.         
  329.         return 0
  330.  
  331.     def generateBonusDistributionList(self):
  332.         "Displays Bonus Advisor Popup"
  333.         d_TableData = {}
  334.         
  335.         map = CyMap()
  336.     
  337.         areas = CvMapGeneratorUtil.getAreas()
  338.         area_sizes = [(area.getNumTiles(), area) for area in areas]
  339.         area_sizes.sort() # sort by size -- biggest area last
  340.         area_sizes.reverse() # biggest area first
  341.         areas = [area for (area_size, area) in area_sizes]
  342.  
  343.         bonus_infos = [gc.getBonusInfo(i) for i in range(gc.getNumBonusInfos())]
  344.         title_list = [u"BonusDistro"] + [u"Area"] + [u"Size"] + [u"Starting Plots"] + [u"Unique Bonus Types"] + [u"Total Bonuses"] 
  345.         
  346.         bonusList = ""
  347.         for bonus in bonus_infos:
  348.             print bonus.getChar()
  349.             bonusChar = "%c" % bonus.getChar()
  350.             bonusList += CvUtil.convertToUnicode(bonusChar)
  351.         title_list += bonusList
  352.  
  353.         d_TableData[0] = title_list
  354.         
  355.         total = 0
  356.         loopRowData = []
  357.         for i in range(len(areas)):
  358.             area = areas[i]
  359.             area_string = "%d" % area.getID()
  360.             if area.isWater():
  361.                 area_string = "w" + area_string
  362.                 
  363.             loopRowData.append(area_string)
  364.             loopRowData.append("%d" % area.getNumTiles())
  365.             start_plots = area.getNumStartingPlots()
  366.             if start_plots > 0:
  367.                 loopRowData.append("%d" % start_plots)
  368.             else:
  369.                 loopRowData.append("")
  370.             num_unique = area.countNumUniqueBonusTypes()
  371.             if num_unique > 0:
  372.                 loopRowData.append("%d" % num_unique)
  373.             else:
  374.                 loopRowData.append("")
  375.     
  376.             total_in_area = area.getNumTotalBonuses()
  377.             total += total_in_area
  378.             loopRowData.append("%d" % total_in_area)
  379.       
  380.             for j in range(len(bonus_infos)):
  381.                 quantity = area.getNumBonuses(j)
  382.                 if quantity > 0:
  383.                     loopRowData.append("%d" % quantity)
  384.                 else:
  385.                     loopRowData.append("")
  386.             d_TableData[i+1] = loopRowData
  387.             loopRowData = []
  388.     
  389.         # Add last row of totals:
  390.         last_row = len(areas) + 1
  391.         loopRowData.append("Total")
  392.         loopRowData.append(map.numPlots())
  393.         loopRowData.append("")
  394.         loopRowData.append("")
  395.         loopRowData.append("%d" % total)
  396.         for j in range(len(bonus_infos)):
  397.             quantity = map.getNumBonuses(j)
  398.             if quantity > 0:
  399.                 loopRowData.append("%d" % quantity)
  400.             else:
  401.                 loopRowData.append("-")
  402.         iLastRow = len(d_TableData)
  403.         d_TableData[iLastRow] = loopRowData
  404.         
  405.         #print d_TableData
  406.         self.setTableData(d_TableData)
  407.     
  408.     def setTeams(self, strTitle = "Teams"):
  409.         self.bTeam = true
  410.         self.iNumTeams = gc.getGame().countCivTeamsEverAlive()
  411.         return self.buildTeamTitleData(strTitle)
  412.  
  413.     def setPlayers(self, strTitle = "Players"):
  414.         self.iNumPlayers = gc.getGame().countCivPlayersEverAlive()
  415.         return self.buildPlayerTitleData(strTitle)
  416.         
  417.     def setTableData(self, d_TableData):
  418.         ' adds the Table Data to the screen '
  419.         screen = self.getScreen()
  420.         
  421.         numColumns = len(d_TableData[0])
  422.         
  423.         #print "NumColumns = %d" %numColumns
  424.         #print d_TableData
  425.         
  426.         #scrollPanel = self.getNextWidgetName()
  427.         #screen.addScrollPanel(scrollPanel, u"", 0, 100, 1000,580, PanelStyles.PANEL_STYLE_DEFAULT)
  428.         
  429.         szTableName = self.getNextWidgetName()
  430.         #screen.attachTableControlGFC(scrollPanel, szTableName, numColumns, True, True, 32,32,TableStyles.TABLE_STYLE_STANDARD)
  431.         screen.addTableControlGFC(szTableName, numColumns, 0, 100, 1000, 580, True, True, 32,32,TableStyles.TABLE_STYLE_STANDARD)
  432.         
  433.         columnHeaders = d_TableData[0]
  434.         
  435.         for i in range(len(columnHeaders)):
  436.             columnWidth = 70
  437.             if i == 0:
  438.                 columnWidth = 150
  439.             screen.setTableColumnHeader(szTableName, i, columnHeaders[i], columnWidth)
  440.         i=0
  441.         for i in range(len(d_TableData)-1):
  442.             screen.appendTableRow(szTableName)
  443.         i=0
  444.         for i in range(len(d_TableData)-1):
  445.             rowData = d_TableData[i+1]
  446.             for j in range(len(rowData)):
  447.                 #print rowData[j]
  448.                 screen.setTableText(szTableName, j, i, u"%s" %rowData[j], "", WidgetTypes.WIDGET_GENERAL,-1,-1, CvUtil.FONT_LEFT_JUSTIFY)
  449.  
  450.     def buildTeamTitleData(self, strTitle):
  451.         ' return a '
  452.         title_list = []
  453.         
  454.         for i in range( self.iNumTeams ):
  455.             strName = gc.getTeam(i).getName()
  456.  
  457.             title_list.append( strName )
  458.     
  459.         title_list.insert( 0,strTitle )
  460.         
  461.         return title_list
  462.  
  463.     def buildPlayerTitleData(self, strTitle):
  464.         ' return a '
  465.         title_list = []
  466.         
  467.         for i in range( self.iNumPlayers ):
  468.             strName = gc.getPlayer(i).getName()
  469.             title_list.append( strName )
  470.     
  471.         title_list.insert( 0,strTitle )
  472.         
  473.         return title_list
  474.  
  475.     # returns a unique ID for a widget in this screen
  476.     def getNextWidgetName(self):
  477.         szName = self.WIDGET_ID + str(self.nWidgetCount)
  478.         self.nWidgetCount += 1
  479.         return szName
  480.         
  481.     def deleteAllWidgets(self, iNumPermanentWidgets = 0):
  482.         screen = self.getScreen()
  483.         i = self.nWidgetCount - 1
  484.         while (i >= iNumPermanentWidgets):
  485.             self.nWidgetCount = i
  486.             screen.deleteWidget(self.getNextWidgetName())
  487.             i -= 1
  488.         
  489.         self.nWidgetCount = iNumPermanentWidgets
  490.         self.yMessage = 5
  491.  
  492.     def InfoType (self, inputClass):
  493.         screen = self.getScreen()
  494.         'called when the player activates the drop down box'
  495.         #print inputClass.getNotifyCode()
  496.         
  497.         if ( inputClass.getNotifyCode() == int(NotifyCode.NOTIFY_LISTBOX_ITEM_SELECTED) ) :
  498.             #return
  499.             szPulldownID = str(inputClass.getID())
  500.             # Get the ID that was selected...
  501.             iSelectedID = screen.getSelectedPullDownID( self.szDebugInfoPulldownID )
  502.             self.deleteAllWidgets()
  503.             self.drawContents(iSelectedID)
  504.  
  505.     def handleInput (self, inputClass):
  506.         'Calls function mapped in FinanceAdvisorInputMap'
  507.         functionName = inputClass.getFunctionName()
  508.         print functionName
  509.         if ( functionName == self.szDebugInfoPulldownID ):
  510.             self.InfoType(inputClass)
  511.         return 0
  512.  
  513.     def update(self, fDelta):
  514.         return
  515.