home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / Screens / CvCivicsScreen.py < prev    next >
Encoding:
Python Source  |  2005-11-09  |  14.4 KB  |  370 lines
  1. ## Sid Meier's Civilization 4
  2. ## Copyright Firaxis Games 2005
  3. from CvPythonExtensions import *
  4. import CvUtil
  5. import ScreenInput
  6. import CvScreenEnums
  7. import string
  8.  
  9. # globals
  10. gc = CyGlobalContext()
  11. ArtFileMgr = CyArtFileMgr()
  12. localText = CyTranslator()
  13.  
  14. class CvCivicsScreen:
  15.     "Civics Screen"
  16.  
  17.     def __init__(self):
  18.         self.SCREEN_NAME = "CivicsScreen"
  19.         self.CANCEL_NAME = "CivicsCancel"
  20.         self.EXIT_NAME = "CivicsExit"
  21.         self.TITLE_NAME = "CivicsTitleHeader"
  22.         self.BUTTON_NAME = "CivicsScreenButton"
  23.         self.TEXT_NAME = "CivicsScreenText"
  24.         self.AREA_NAME = "CivicsScreenArea"
  25.         self.HELP_AREA_NAME = "CivicsScreenHelpArea"
  26.         self.HELP_IMAGE_NAME = "CivicsScreenCivicOptionImage"
  27.         self.DEBUG_DROPDOWN_ID =  "CivicsDropdownWidget"
  28.         self.BACKGROUND_ID = "CivicsBackground"
  29.         self.HELP_HEADER_NAME = "CivicsScreenHeaderName"
  30.  
  31.         self.HEADINGS_WIDTH = 199
  32.         self.HEADINGS_TOP = 70
  33.         self.HEADINGS_SPACING = 5
  34.         self.HEADINGS_BOTTOM = 280
  35.         self.HELP_TOP = 350
  36.         self.HELP_BOTTOM = 610
  37.         self.TEXT_MARGIN = 15
  38.         self.BUTTON_SIZE = 24
  39.         self.BIG_BUTTON_SIZE = 64
  40.         self.BOTTOM_LINE_TOP = 630
  41.         self.BOTTOM_LINE_WIDTH = 1014
  42.         self.BOTTOM_LINE_HEIGHT = 60
  43.  
  44.         self.X_EXIT = 994
  45.         self.Y_EXIT = 726
  46.  
  47.         self.X_CANCEL = 552
  48.         self.Y_CANCEL = 726
  49.  
  50.         self.X_SCREEN = 500
  51.         self.Y_SCREEN = 396
  52.         self.W_SCREEN = 1024
  53.         self.H_SCREEN = 768
  54.         self.Z_SCREEN = -6.1
  55.         self.Y_TITLE = 8        
  56.         self.Z_TEXT = self.Z_SCREEN - 0.2
  57.  
  58.         self.CivicsScreenInputMap = {
  59.             self.BUTTON_NAME        : self.CivicsButton,
  60.             self.TEXT_NAME            : self.CivicsButton,
  61.             self.EXIT_NAME            : self.Revolution,
  62.             self.CANCEL_NAME        : self.Cancel,
  63.             }
  64.  
  65.         self.iActivePlayer = -1
  66.  
  67.         self.m_paeCurrentCivics = []
  68.         self.m_paeDisplayCivics = []
  69.         self.m_paeOriginalCivics = []
  70.  
  71.     def getScreen(self):
  72.         return CyGInterfaceScreen(self.SCREEN_NAME, CvScreenEnums.CIVICS_SCREEN)
  73.  
  74.     def setActivePlayer(self, iPlayer):
  75.  
  76.         self.iActivePlayer = iPlayer
  77.         activePlayer = gc.getPlayer(iPlayer)
  78.  
  79.         self.m_paeCurrentCivics = []
  80.         self.m_paeDisplayCivics = []
  81.         self.m_paeOriginalCivics = []
  82.         for i in range (gc.getNumCivicOptionInfos()):
  83.             self.m_paeCurrentCivics.append(activePlayer.getCivics(i));
  84.             self.m_paeDisplayCivics.append(activePlayer.getCivics(i));
  85.             self.m_paeOriginalCivics.append(activePlayer.getCivics(i));
  86.  
  87.     def interfaceScreen (self):
  88.  
  89.         screen = self.getScreen()
  90.         if screen.isActive():
  91.             return
  92.         screen.setRenderInterfaceOnly(True);
  93.         screen.showScreen( PopupStates.POPUPSTATE_IMMEDIATE, False)
  94.     
  95.         # Set the background and exit button, and show the screen
  96.         screen.setDimensions(screen.centerX(0), screen.centerY(0), self.W_SCREEN, self.H_SCREEN)
  97.         screen.addDDSGFC(self.BACKGROUND_ID, ArtFileMgr.getInterfaceArtInfo("MAINMENU_SLIDESHOW_LOAD").getPath(), 0, 0, self.W_SCREEN, self.H_SCREEN, WidgetTypes.WIDGET_GENERAL, -1, -1 )
  98.         screen.addPanel( "TechTopPanel", u"", u"", True, False, 0, 0, self.W_SCREEN, 55, PanelStyles.PANEL_STYLE_TOPBAR )
  99.         screen.addPanel( "TechBottomPanel", u"", u"", True, False, 0, 713, self.W_SCREEN, 55, PanelStyles.PANEL_STYLE_BOTTOMBAR )
  100.         screen.showWindowBackground(False)
  101.         screen.setText(self.CANCEL_NAME, "Background", u"<font=4>" + localText.getText("TXT_KEY_SCREEN_CANCEL", ()).upper() + u"</font>", CvUtil.FONT_CENTER_JUSTIFY, self.X_CANCEL, self.Y_CANCEL, self.Z_TEXT, FontTypes.TITLE_FONT, WidgetTypes.WIDGET_GENERAL, 1, 0)
  102.  
  103.         # Header...
  104.         screen.setText(self.TITLE_NAME, "Background", u"<font=4b>" + localText.getText("TXT_KEY_CIVICS_SCREEN_TITLE", ()).upper() + u"</font>", CvUtil.FONT_CENTER_JUSTIFY, self.X_SCREEN, self.Y_TITLE, self.Z_TEXT, FontTypes.TITLE_FONT, WidgetTypes.WIDGET_GENERAL, -1, -1)
  105.         
  106.         self.setActivePlayer(gc.getGame().getActivePlayer())                        
  107.  
  108.         if (CyGame().isDebugMode()):
  109.             self.szDropdownName = self.DEBUG_DROPDOWN_ID
  110.             screen.addDropDownBoxGFC(self.szDropdownName, 22, 12, 300, WidgetTypes.WIDGET_GENERAL, -1, -1, FontTypes.GAME_FONT)
  111.             for j in range(gc.getMAX_PLAYERS()):
  112.                 if (gc.getPlayer(j).isAlive()):
  113.                     screen.addPullDownString(self.szDropdownName, gc.getPlayer(j).getName(), j, j, False )
  114.  
  115.         screen.addPanel("CivicsBottomLine", "", "", True, True, self.HEADINGS_SPACING, self.BOTTOM_LINE_TOP, self.BOTTOM_LINE_WIDTH, self.BOTTOM_LINE_HEIGHT, PanelStyles.PANEL_STYLE_MAIN)
  116.  
  117.         # Draw Contents
  118.         self.drawContents()
  119.  
  120.         return 0
  121.  
  122.     # Draw the contents...
  123.     def drawContents(self):
  124.     
  125.         # Draw the radio buttons
  126.         self.drawAllButtons()
  127.                 
  128.         # Draw Help Text
  129.         self.drawAllHelpText()
  130.         
  131.         # Update Maintenance/anarchy/etc.
  132.         self.updateAnarchy()
  133.  
  134.     def drawCivicOptionButtons(self, iCivicOption):
  135.  
  136.         activePlayer = gc.getPlayer(self.iActivePlayer)
  137.         screen = self.getScreen()
  138.         
  139.         for j in range(gc.getNumCivicInfos()):
  140.  
  141.             if (gc.getCivicInfo(j).getCivicOptionType() == iCivicOption):                                        
  142.                 screen.setState(self.getCivicsButtonName(j), self.m_paeCurrentCivics[iCivicOption] == j)
  143.                             
  144.                 if (self.m_paeDisplayCivics[iCivicOption] == j):
  145.                     #screen.setState(self.getCivicsButtonName(j), True)
  146.                     screen.show(self.getCivicsButtonName(j))
  147.                 elif (activePlayer.canDoCivics(j)):
  148.                     #screen.setState(self.getCivicsButtonName(j), False)
  149.                     screen.show(self.getCivicsButtonName(j))
  150.                 else:
  151.                     screen.hide(self.getCivicsButtonName(j))
  152.                                 
  153.     # Will draw the radio buttons (and revolution)
  154.     def drawAllButtons(self):                
  155.  
  156.         for i in range(gc.getNumCivicOptionInfos()):
  157.         
  158.             fX = self.HEADINGS_SPACING  + (self.HEADINGS_WIDTH + self.HEADINGS_SPACING) * i
  159.             fY = self.HEADINGS_TOP
  160.             szAreaID = self.AREA_NAME + str(i)
  161.             screen = self.getScreen()
  162.             screen.addPanel(szAreaID, "", "", True, True, fX, fY, self.HEADINGS_WIDTH, self.HEADINGS_BOTTOM - self.HEADINGS_TOP, PanelStyles.PANEL_STYLE_MAIN)
  163.             screen.setLabel("", "Background",  u"<font=3>" + gc.getCivicOptionInfo(i).getDescription().upper() + u"</font>", CvUtil.FONT_CENTER_JUSTIFY, fX + self.HEADINGS_WIDTH/2, self.HEADINGS_TOP + self.TEXT_MARGIN, 0, FontTypes.GAME_FONT, WidgetTypes.WIDGET_GENERAL, -1, -1 )
  164.  
  165.             fY += self.TEXT_MARGIN
  166.             
  167.             for j in range(gc.getNumCivicInfos()):
  168.                 if (gc.getCivicInfo(j).getCivicOptionType() == i):                                        
  169.                     fY += 2 * self.TEXT_MARGIN
  170.                     screen.addCheckBoxGFC(self.getCivicsButtonName(j), gc.getCivicInfo(j).getButton(), ArtFileMgr.getInterfaceArtInfo("BUTTON_HILITE_SQUARE").getPath(), fX + self.BUTTON_SIZE/2, fY, self.BUTTON_SIZE, self.BUTTON_SIZE, WidgetTypes.WIDGET_GENERAL, -1, -1, ButtonStyles.BUTTON_STYLE_LABEL)
  171.                     screen.setText(self.getCivicsTextName(j), "", gc.getCivicInfo(j).getDescription(), CvUtil.FONT_LEFT_JUSTIFY, fX + self.BUTTON_SIZE + self.TEXT_MARGIN, fY, 0, FontTypes.SMALL_FONT, WidgetTypes.WIDGET_GENERAL, -1, -1)
  172.  
  173.             self.drawCivicOptionButtons(i)
  174.                     
  175.                             
  176.     def highlight(self, iCivic):
  177.         iCivicOption = gc.getCivicInfo(iCivic).getCivicOptionType()
  178.         if self.m_paeDisplayCivics[iCivicOption] != iCivic:
  179.             self.m_paeDisplayCivics[iCivicOption] = iCivic
  180.             self.drawCivicOptionButtons(iCivicOption)
  181.             return True
  182.         return False
  183.         
  184.     def unHighlight(self, iCivic):        
  185.         iCivicOption = gc.getCivicInfo(iCivic).getCivicOptionType()
  186.         if self.m_paeDisplayCivics[iCivicOption] != self.m_paeCurrentCivics[iCivicOption]:
  187.             self.m_paeDisplayCivics[iCivicOption] = self.m_paeCurrentCivics[iCivicOption]
  188.             self.drawCivicOptionButtons(iCivicOption)
  189.             return True
  190.         return False
  191.         
  192.     def select(self, iCivic):
  193.         activePlayer = gc.getPlayer(self.iActivePlayer)
  194.         if (not activePlayer.canDoCivics(iCivic)):
  195.             # If you can't even do this, get out....
  196.             return 0
  197.             
  198.         iCivicOption = gc.getCivicInfo(iCivic).getCivicOptionType()
  199.         
  200.         # Set the previous widget
  201.         iCivicPrev = self.m_paeCurrentCivics[iCivicOption]
  202.         
  203.         # Switch the widgets
  204.         self.m_paeCurrentCivics[iCivicOption] = iCivic
  205.         
  206.         # Unighlight the previous widget
  207.         self.unHighlight(iCivicPrev)
  208.         self.getScreen().setState(self.getCivicsButtonName(iCivicPrev), False)
  209.  
  210.         # highlight the new widget
  211.         self.highlight(iCivic)        
  212.         self.getScreen().setState(self.getCivicsButtonName(iCivic), True)
  213.         
  214.         return 0
  215.  
  216.     def CivicsButton(self, inputClass):
  217.     
  218.         if (inputClass.getNotifyCode() == NotifyCode.NOTIFY_CLICKED) :
  219.             # Select button
  220.             self.select(inputClass.getID())
  221.             self.drawHelpText(gc.getCivicInfo(inputClass.getID()).getCivicOptionType())
  222.             self.updateAnarchy()
  223.         elif (inputClass.getNotifyCode() == NotifyCode.NOTIFY_CURSOR_MOVE_ON) :
  224.             # Highlight this button
  225.             if self.highlight(inputClass.getID()):
  226.                 self.drawHelpText(gc.getCivicInfo(inputClass.getID()).getCivicOptionType())
  227.                 self.updateAnarchy()
  228.         elif (inputClass.getNotifyCode() == NotifyCode.NOTIFY_CURSOR_MOVE_OFF) :
  229.             if self.unHighlight(inputClass.getID()):
  230.                 self.drawHelpText(gc.getCivicInfo(inputClass.getID()).getCivicOptionType())
  231.                 self.updateAnarchy()
  232.  
  233.         return 0
  234.  
  235.         
  236.     def drawHelpText(self, iCivicOption):
  237.         
  238.         activePlayer = gc.getPlayer(self.iActivePlayer)
  239.         iCivic = self.m_paeDisplayCivics[iCivicOption]
  240.  
  241.         szPaneID = "CivicsHelpTextBackground" + str(iCivicOption)
  242.         screen = self.getScreen()
  243.  
  244.         szHelpText = u""
  245.  
  246.         # Upkeep string
  247.         if ((gc.getCivicInfo(iCivic).getUpkeep() != -1) and not activePlayer.isNoCivicUpkeep(iCivicOption)):
  248.             szHelpText = gc.getUpkeepInfo(gc.getCivicInfo(iCivic).getUpkeep()).getDescription()
  249.         else:
  250.             szHelpText = localText.getText("TXT_KEY_CIVICS_SCREEN_NO_UPKEEP", ())
  251.  
  252.         szHelpText += CyGameTextMgr().parseCivicInfo(iCivic, True, True)
  253.  
  254.         fX = self.HEADINGS_SPACING  + (self.HEADINGS_WIDTH + self.HEADINGS_SPACING) * iCivicOption
  255.  
  256.         screen.setLabel(self.HELP_HEADER_NAME + str(iCivicOption), "Background",  u"<font=3>" + gc.getCivicInfo(self.m_paeDisplayCivics[iCivicOption]).getDescription().upper() + u"</font>", CvUtil.FONT_CENTER_JUSTIFY, fX + self.HEADINGS_WIDTH/2, self.HELP_TOP + self.TEXT_MARGIN, 0, FontTypes.GAME_FONT, WidgetTypes.WIDGET_GENERAL, -1, -1 )
  257.  
  258.         fY = self.HELP_TOP - self.BIG_BUTTON_SIZE
  259.         szHelpImageID = self.HELP_IMAGE_NAME + str(iCivicOption)        
  260.         screen.setImageButton(szHelpImageID, gc.getCivicInfo(iCivic).getButton(), fX + self.HEADINGS_WIDTH/2 - self.BIG_BUTTON_SIZE/2, fY, self.BIG_BUTTON_SIZE, self.BIG_BUTTON_SIZE, WidgetTypes.WIDGET_PEDIA_JUMP_TO_CIVIC, iCivic, 1)
  261.  
  262.         fY = self.HELP_TOP + 3 * self.TEXT_MARGIN
  263.         szHelpAreaID = self.HELP_AREA_NAME + str(iCivicOption)        
  264.         screen.addMultilineText(szHelpAreaID, szHelpText, fX+5, fY, self.HEADINGS_WIDTH-7, self.HELP_BOTTOM - fY-2, WidgetTypes.WIDGET_GENERAL, -1, -1, CvUtil.FONT_LEFT_JUSTIFY)                
  265.         
  266.         
  267.     # Will draw the help text
  268.     def drawAllHelpText(self):
  269.         for i in range (gc.getNumCivicOptionInfos()):        
  270.  
  271.             fX = self.HEADINGS_SPACING  + (self.HEADINGS_WIDTH + self.HEADINGS_SPACING) * i
  272.  
  273.             szPaneID = "CivicsHelpTextBackground" + str(i)
  274.             screen = self.getScreen()
  275.             screen.addPanel(szPaneID, "", "", True, True, fX, self.HELP_TOP, self.HEADINGS_WIDTH, self.HELP_BOTTOM - self.HELP_TOP, PanelStyles.PANEL_STYLE_MAIN)
  276.  
  277.             self.drawHelpText(i)
  278.  
  279.  
  280.     # Will Update the maintenance/anarchy/etc
  281.     def updateAnarchy(self):
  282.  
  283.         screen = self.getScreen()
  284.  
  285.         activePlayer = gc.getPlayer(self.iActivePlayer)
  286.  
  287.         bChange = False
  288.         i = 0
  289.         while (i  < gc.getNumCivicOptionInfos() and not bChange):
  290.             if (self.m_paeCurrentCivics[i] != self.m_paeOriginalCivics[i]):
  291.                 bChange = True
  292.             i += 1        
  293.         
  294.         # Make the revolution button
  295.         screen.deleteWidget(self.EXIT_NAME)
  296.         if (activePlayer.canRevolution(0) and bChange):            
  297.             screen.setText(self.EXIT_NAME, "Background", u"<font=4>" + localText.getText("TXT_KEY_CONCEPT_REVOLUTION", ( )).upper() + u"</font>", CvUtil.FONT_RIGHT_JUSTIFY, self.X_EXIT, self.Y_EXIT, self.Z_TEXT, FontTypes.TITLE_FONT, WidgetTypes.WIDGET_REVOLUTION, 1, 0)
  298.             screen.show(self.CANCEL_NAME)
  299.         else:
  300.             screen.setText(self.EXIT_NAME, "Background", u"<font=4>" + localText.getText("TXT_KEY_PEDIA_SCREEN_EXIT", ( )).upper() + u"</font>", CvUtil.FONT_RIGHT_JUSTIFY, self.X_EXIT, self.Y_EXIT, self.Z_TEXT, FontTypes.TITLE_FONT, WidgetTypes.WIDGET_GENERAL, 1, -1)
  301.             screen.hide(self.CANCEL_NAME)
  302.  
  303.         # Anarchy
  304.         iTurns = activePlayer.getCivicAnarchyLength(self.m_paeDisplayCivics);
  305.         
  306.         if (activePlayer.canRevolution(0)):
  307.             szText = localText.getText("TXT_KEY_ANARCHY_TURNS", (iTurns, ))
  308.         else:
  309.             szText = CyGameTextMgr().setRevolutionHelp(self.iActivePlayer)
  310.  
  311.         screen.setLabel("CivicsRevText", "", u"<font=3>" + szText + u"</font>", CvUtil.FONT_CENTER_JUSTIFY, self.X_SCREEN, self.BOTTOM_LINE_TOP + self.TEXT_MARGIN//2, 0, FontTypes.GAME_FONT, WidgetTypes.WIDGET_GENERAL, -1, -1)
  312.  
  313.         # Maintenance        
  314.         szText = localText.getText("TXT_KEY_CIVIC_SCREEN_UPKEEP", (activePlayer.getCivicUpkeep(self.m_paeDisplayCivics, True), ))
  315.         screen.setLabel("CivicsUpkeepText", "", u"<font=3>" + szText + u"</font>", CvUtil.FONT_CENTER_JUSTIFY, self.X_SCREEN, self.BOTTOM_LINE_TOP + self.BOTTOM_LINE_HEIGHT - 2 * self.TEXT_MARGIN, 0, FontTypes.GAME_FONT, WidgetTypes.WIDGET_GENERAL, -1, -1)
  316.         
  317.     # Revolution!!!
  318.     def Revolution(self, inputClass):
  319.  
  320.         activePlayer = gc.getPlayer(self.iActivePlayer)
  321.  
  322.         if (inputClass.getNotifyCode() == NotifyCode.NOTIFY_CLICKED) :
  323.             if (activePlayer.canRevolution(0)):
  324.                 messageControl = CyMessageControl()
  325.                 messageControl.sendUpdateCivics(self.m_paeDisplayCivics)            
  326.             screen = self.getScreen()
  327.             screen.hideScreen()
  328.  
  329.  
  330.     def Cancel(self, inputClass):
  331.         screen = self.getScreen()
  332.         if (inputClass.getNotifyCode() == NotifyCode.NOTIFY_CLICKED) :
  333.             for i in range (gc.getNumCivicOptionInfos()):
  334.                 self.m_paeCurrentCivics[i] = self.m_paeOriginalCivics[i]
  335.                 self.m_paeDisplayCivics[i] = self.m_paeOriginalCivics[i]
  336.             
  337.             self.drawContents()
  338.             
  339.     def getCivicsButtonName(self, iCivic):
  340.         szName = self.BUTTON_NAME + str(iCivic)
  341.         return szName
  342.  
  343.     def getCivicsTextName(self, iCivic):
  344.         szName = self.TEXT_NAME + str(iCivic)
  345.         return szName
  346.  
  347.     # Will handle the input for this screen...
  348.     def handleInput(self, inputClass):
  349.         if (inputClass.getNotifyCode() == NotifyCode.NOTIFY_LISTBOX_ITEM_SELECTED):
  350.             screen = self.getScreen()
  351.             iIndex = screen.getSelectedPullDownID(self.DEBUG_DROPDOWN_ID)
  352.             self.setActivePlayer(screen.getPullDownData(self.DEBUG_DROPDOWN_ID, iIndex))
  353.             self.drawContents()
  354.             return 1
  355.         elif (self.CivicsScreenInputMap.has_key(inputClass.getFunctionName())):    
  356.             'Calls function mapped in CvCivicsScreen'
  357.             # only get from the map if it has the key        
  358.  
  359.             # get bound function from map and call it
  360.             self.CivicsScreenInputMap.get(inputClass.getFunctionName())(inputClass)
  361.             return 1
  362.         return 0
  363.         
  364.     def update(self, fDelta):
  365.         return
  366.  
  367.  
  368.  
  369.  
  370.