Changeset 300

Show
Ignore:
Timestamp:
03/26/2012 10:36:49 PM (2 years ago)
Author:
ecoughlan
Message:

Finished editing style in files

Location:
src
Files:
28 modified

Legend:

Unmodified
Added
Removed
  • src/alert.py

    r293 r300  
    66 
    77from window import Window 
    8 from rectanlge import Rectangle 
     8from rectangle import Rectangle 
    99from text import Text 
    1010from simpleButton import SimpleButton 
     11from globals import * 
    1112 
    1213 
     
    1920        Window.__init__(self, pos, visible) 
    2021        self.rectangles.append(Rectangle(self.pos, 500, 150, YELLOW)) 
    21         self.text.append(Text((self.pos[0] + 10, self.pos[1] + 20), 'MESSAGE', MD_TEXT, FAKEBLACK)) 
     22        self.text.append(Text((self.pos[0] + 10, self.pos[1] + 20), 'MESSAGE', 
     23                              MD_TEXT, FAKEBLACK)) 
    2224        self.text.append(Text((30, 60), message, MD_TEXT, FAKEBLACK, 400)) 
    2325 
    2426        if canCancel: 
    25             self.subwindows.append(SimpleButton((self.pos[0] + (500 - 2 * 56 - 10), self.pos[1] + 150 - 30), True, "OK"))  
    26             self.subwindows.append(SimpleButton((self.pos[0] + (500 - 56 - 5), self.pos[1] + 150 - 30), True, "Cancel")) 
     27            self.subwindows.append(SimpleButton((self.pos[0] + 
     28                                                 (500 - 2 * 56 - 10), 
     29                                                 self.pos[1] + 150 - 30), 
     30                                                True, "OK")) 
     31            self.subwindows.append(SimpleButton((self.pos[0] + (500 - 56 - 5), 
     32                                                 self.pos[1] + 150 - 30), 
     33                                                True, "Cancel")) 
    2734 
    2835        else: 
    29             self.subwindows.append(SimpleButton((self.pos[0] + (500 - 56 - 5), self.pos[1] + 150 - 30), True, "OK")) 
     36            self.subwindows.append(SimpleButton((self.pos[0] + (500 - 56 - 5), 
     37                                                 self.pos[1] + 150 - 30), 
     38                                                True, "OK")) 
  • src/background.py

    r286 r300  
    77from window import Window 
    88from image import Image 
    9 from rectangle import Rectangle 
    10 from text import Text 
    119from globals import * 
    1210 
     11 
    1312class Background(Window): 
    14     def __init__(self,pos,visible,image, doRestore = False): 
     13    def __init__(self, pos, visible, image, doRestore=False): 
    1514        """ 
    1615            initializes the components of the Background subclass 
    17      
     16 
    1817            input type: int((x,y)), bool(visible), str(image) 
    1918        """ 
    2019        Window.__init__(self, pos, visible) 
    21          
     20 
    2221        icon = pygame.image.load(iconDir + image) 
    23         self.images.append(Image(self.pos, 1080,792, icon)) 
     22        self.images.append(Image(self.pos, 1080, 792, icon)) 
    2423        self.restore = doRestore 
    25          
    26     def isCollision(self,pos): 
     24 
     25    def isCollision(self, pos): 
    2726        """ 
    2827            returns false. Period. 
    29              
     28 
    3029            input type: (int, int) 
    3130            return type: False 
    3231        """ 
    3332        return False 
    34      
     33 
    3534    def openWindow(self): 
    3635        self.visible = True 
  • src/block.py

    r292 r300  
    77from window import Window 
    88from image import Image 
    9 from rectangle import Rectangle 
    10 from text import Text 
    119from globals import * 
    1210from leftRight import LeftRight 
    1311from mapBuilding import MapBuilding 
    1412 
     13 
    1514class Block(Window): 
    16     def __init__(self,pos,visible,ID,responses): 
     15    def __init__(self, pos, visible, ID, responses): 
    1716        """ 
    1817            Initializes a Block 
     
    2221        Window.__init__(self, pos, visible) 
    2322        self.ID = ID 
    24          
    25         landscapeArt = pygame.image.load(os.path.abspath(landscapeDir + os.sep + "landscape-0" + str(self.ID + 1) + ".png")) 
    26         self.images.append(Image(self.pos,MAP_W,MAP_H ,landscapeArt)) 
    27          
    28         right = LeftRight((self.pos[0] + 10, self.pos[1] + MAP_H - 50),True, False) 
     23 
     24        landscapeArt = pygame.image.load(os.path.abspath(landscapeDir + 
     25                                                         os.sep + 
     26                                                         "landscape-0" + 
     27                                                         str(self.ID + 1) + 
     28                                                         ".png")) 
     29        self.images.append(Image(self.pos, MAP_W, MAP_H, landscapeArt)) 
     30 
     31        right = LeftRight((self.pos[0] + 10, self.pos[1] + MAP_H - 50), 
     32                          True, False) 
    2933        right.addResponse(responses[0]) 
    30         left = LeftRight((self.pos[0] + MAP_W - 60, self.pos[1] + MAP_H - 50), True, True) 
     34        left = LeftRight((self.pos[0] + MAP_W - 60, self.pos[1] + MAP_H - 50), 
     35                         True, True) 
    3136        left.addResponse(responses[1]) 
    32             
     37 
    3338        self.subwindows.append(right) 
    3439        self.subwindows.append(left) 
    35          
     40 
    3641    def openWindow(self): 
    3742        """ 
    3843            Opens the block and all the subwindows 
    39              
     44 
    4045            input type: None 
    4146            return type: None 
     
    4853        """ 
    4954            Updates the block by adding new buildings 
    50              
     55 
    5156            input type: State(state) 
    5257            return type: None 
     
    5459        # remove all but arrows 
    5560        self.subwindows = self.subwindows[0:2] 
    56          
     61 
    5762        blockBuildings = state.getBlockBuildings(self.ID) 
    5863        for i in range(len(blockBuildings)): 
    59             self.addWindow(MapBuilding((self.pos[0] + 20, 250), True, self.ID, i, blockBuildings[i])) 
    60          
     64            self.addWindow(MapBuilding((self.pos[0] + 20, 250), True, self.ID, 
     65                                       i, blockBuildings[i])) 
  • src/buildMenu.py

    r287 r300  
    55''' 
    66 
    7 from window import Window 
    87from globals import * 
    98from inGameMenu import InGameMenu 
    109from buildables import buildingLUT 
    1110from buildMenuEntry import BuildMenuEntry 
     11 
    1212 
    1313class BuildMenu(InGameMenu): 
     
    1616            initializes the components of the InGameMenu subclass 
    1717            title is the name of the menu (i.e. research or build) 
    18      
     18 
    1919            input type: int((x,y)), bool(visible), str(title), str(image) 
    2020        """ 
     
    2626            if building.buildingType == self.category: 
    2727                catBuildings.append(building) 
    28                  
     28 
    2929        # here you will check how many of category buildings there are 
    30          
    31         for i,building in enumerate(catBuildings): 
     30 
     31        for i, building in enumerate(catBuildings): 
    3232            print building.name 
    3333            entry = BuildMenuEntry((40, 100 + ENTRY_SHIFT * i), True, building) 
    3434            entry.setYesResponse(buildResponse) 
    3535            self.subwindows.append(entry) 
    36          
  • src/buildables.py

    r299 r300  
    88    buildingFiles = os.listdir(buildingDir) 
    99    for f in buildingFiles: 
    10         fileName, fileExt = os.path.splitext(f) 
     10        fileExt = os.path.splitext(f)[1] 
    1111        if fileExt == buildExt: 
    1212            building = loadBuilding(f) 
  • src/building.py

    r292 r300  
    88from buildingStats import * 
    99 
     10 
    1011class Building: 
    1112    """ Contains data and stats object for each building """ 
    12      
     13 
    1314    def __init__(self, name, buildingType, stats, threshold): 
    1415        """ 
    1516            initializes a Building 
    16      
    17             input type: str(name), int(buildingType), BuildingStat(stats),  
     17 
     18            input type: str(name), int(buildingType), BuildingStat(stats), 
    1819                        (int(power), int(transportation), int(materials)) 
    1920        """ 
     
    2526        self.detailedDescript = None 
    2627 
    27  
    2828        # Note that this should not include 
    2929        # the path to directories, just the file name. 
     
    3232        self.imageFileName = None 
    3333 
    34          
    3534    def setMenuDescript(self, text): 
    3635        """ 
    3736            changes the menu description of the Building 
    38      
     37 
    3938            input type: str(text) 
    4039            return type: None 
    4140        """ 
    4241        self.menuDescript = text 
    43      
     42 
    4443    def setDetailedDescript(self, text): 
    4544        """ 
    4645            changes the detailed description of the Building 
    47      
     46 
    4847            input type: str(text) 
    4948            return type: None 
    5049        """ 
    5150        self.detailedDescript = text 
    52      
     51 
    5352    def setImageFileName(self, fileName): 
    5453        """ 
    5554            changes the image file name of the Building 
    56      
     55 
    5756            input type: str(filename) 
    5857            return type: None 
    5958        """ 
    6059        self.imageFileName = fileName 
    61      
     60 
    6261    def getThreshold(self): 
    6362        """ 
    6463            returns the research threshold of the building 
    65      
     64 
    6665            input type: None 
    6766            return type: (int(power), int(transportation), int(materials)) 
    6867        """ 
    6968        return self.threshold 
    70          
     69 
    7170    def getStats(self): 
    7271        """ 
    7372            returns the stats for the building 
    74      
     73 
    7574            input type: None 
    7675            return type: BuildingStat(self.stats) 
     
    7877        return self.stats 
    7978 
     79 
    8080def saveBuilding(building): 
    8181    """ 
    8282        Saves the building to a .trek file 
    83          
     83 
    8484        input type: Building(building) 
    8585        return type: bool 
     
    9494        buildingData.close() 
    9595        return True 
    96      
     96 
     97 
    9798def loadBuilding(fullFileName): 
    9899    """ 
    99100        Loads the building from a .trek file 
    100          
     101 
    101102        input type: str(fullFileName) 
    102103        return type: Building(building) 
     
    110111        building = cPickle.load(buildingData) 
    111112        return building 
    112  
    113  
  • src/buildingDescription.py

    r292 r300  
    55''' 
    66 
    7 from window import Window 
    8 from rectangle import Rectangle 
    9 from text import Text 
    10 from image import Image 
    11 from description import Description 
    127from detailedDescription import DetailedDescription 
    138from simpleButton import SimpleButton 
    149from globals import * 
     10 
    1511 
    1612class BuildDescription(DetailedDescription): 
     
    1814        """ 
    1915            Creates a building description window 
    20              
     16 
    2117            input type: Description(description) 
    2218        """ 
    2319        DetailedDescription.__init__(self, pos, visible, False, description) 
    2420 
    25         yesButton = SimpleButton((self.pos[0] + 215, self.pos[1] + 200), False, "Build") 
    26         noButton = SimpleButton((self.pos[0] + 285, self.pos[1] + 200), False, "Cancel") 
     21        yesButton = SimpleButton((self.pos[0] + 215, self.pos[1] + 200), 
     22                                 False, "Build") 
     23        noButton = SimpleButton((self.pos[0] + 285, self.pos[1] + 200), 
     24                                False, "Cancel") 
    2725        yesButton.addResponse((self.closeWindow,)) 
    28         noButton.addResponse((self.closeWindow,))  
    29          
     26        noButton.addResponse((self.closeWindow,)) 
     27 
    3028        self.subwindows.append(yesButton) 
    3129        self.subwindows.append(noButton) 
    3230 
    33     def setYesResponse(self,response): 
     31    def setYesResponse(self, response): 
    3432        """ 
    3533            Sets the response of the yes button 
    36              
     34 
    3735            input type: function pointer 
    3836            return type: None 
    3937        """ 
    4038        self.subwindows[0].addResponse((response[0],)) 
    41          
    42     def setNoResponse(self,response): 
     39 
     40    def setNoResponse(self, response): 
    4341        """ 
    4442            Sets the response of the no button 
    45              
     43 
    4644            input type: function pointer 
    4745            return type: None 
    4846        """ 
    4947        self.subwindows[1].addResponse(response) 
    50      
     48 
    5149    def toggle(self): 
    5250        """ 
     
    5755        for window in self.subwindows: 
    5856            window.toggle() 
    59          
     57 
    6058    def openWindow(self): 
    6159        """ 
  • src/buildingStats.py

    r224 r300  
    77from spec import * 
    88 
     9 
    910class BuildingStats(): 
    1011    """ Stats for each building """ 
     
    1314        """ 
    1415            initializes a BuildingStat 
    15      
     16 
    1617            input type: None 
    1718        """ 
    1819        # positive values, subtracted 
    19         self.oneTimeSpecs = Spec(0,0,0,0,0) 
    20         self.contSpecs = Spec(0,0,0,0,0) 
    21          
    22     def setOneTime(self,newSpec): 
     20        self.oneTimeSpecs = Spec(0, 0, 0, 0, 0) 
     21        self.contSpecs = Spec(0, 0, 0, 0, 0) 
     22 
     23    def setOneTime(self, newSpec): 
    2324        """ 
    2425            changes the initial spec of the BuildingStat 
    25      
     26 
    2627            input type: Spec(newSpec) 
    2728            return type: None 
    2829        """ 
    2930        self.oneTimeSpecs = newSpec 
    30          
    31     def setCont(self,newSpec): 
     31 
     32    def setCont(self, newSpec): 
    3233        """ 
    3334            changes the continous spec of the BuildingStat 
    34      
     35 
    3536            input type: Spec(newSpec) 
    3637            return type: None 
     
    4142        """ 
    4243            returns the initial Spec 
    43      
     44 
    4445            input type: None 
    4546            return type: Spec(self.initSpecs) 
    4647        """ 
    4748        return self.oneTimeSpecs 
    48      
     49 
    4950    def getCont(self): 
    5051        """ 
    5152            returns the continuous Spec 
    52      
     53 
    5354            input type: None 
    5455            return type: Spec(self.contSpecs) 
  • src/leftRight.py

    r265 r300  
    55""" 
    66 
    7 import pygame 
    87from window import Window 
     8from image import Image 
    99from globals import * 
    10 from image import Image 
    11 from text import Text 
    12 from rectangle import Rectangle 
     10 
    1311 
    1412class LeftRight(Window): 
     
    2220 
    2321        self.images.append(Image(self.pos, ARROW_SIZE, ARROW_SIZE, icon)) 
    24  
  • src/map.py

    r292 r300  
    66 
    77from window import Window 
    8 from image import Image 
    9 from rectangle import Rectangle 
    10 from text import Text 
    11 from globals import * 
    128from block import Block 
    139from mapButton import MapButton 
     10from globals import * 
     11 
    1412 
    1513class Map(Window): 
    16     def __init__(self,pos,visible): 
     14    def __init__(self, pos, visible): 
    1715        """ 
    1816            Initializes the Map 
     
    2119        """ 
    2220        Window.__init__(self, pos, visible) 
    23          
     21 
    2422        self.currentBlock = 0 
    2523        self.numBlocks = START_BLOCKS 
    26          
    27         responseList = [(self.moveLeft,),(self.moveRight,)] 
     24 
     25        responseList = [(self.moveLeft,), (self.moveRight,)] 
    2826        print self.pos[1] + MAP_H + 10 
    29          
     27 
    3028        for i in range(self.numBlocks): 
    3129            if i == self.currentBlock: 
    32                 self.subwindows.append(Block(self.pos,True,i,responseList)) 
    33                  
     30                self.subwindows.append(Block(self.pos, True, i, responseList)) 
     31 
    3432            else: 
    35                 self.subwindows.append(Block(self.pos,False,i,responseList)) 
    36                  
     33                self.subwindows.append(Block(self.pos, False, i, responseList)) 
     34 
    3735        for i in range(self.numBlocks): 
    3836            if i == self.currentBlock: 
    39                 minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * i, self.pos[1] + MAP_H + 5),True,i,True) 
    40                 minButton.addResponse((self.jumpToBlock,i)) 
     37                minButton = MapButton((self.pos[0] + 420 / self.numBlocks * i, 
     38                                       self.pos[1] + MAP_H + 5), 
     39                                      True, i, True) 
     40                minButton.addResponse((self.jumpToBlock, i)) 
    4141                self.subwindows.append(minButton) 
    4242            else: 
    43                 minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * i, self.pos[1] + MAP_H + 10),True,i,False) 
    44                 minButton.addResponse((self.jumpToBlock,i)) 
     43                minButton = MapButton((self.pos[0] + 420 / self.numBlocks * i, 
     44                                       self.pos[1] + MAP_H + 10), 
     45                                      True, i, False) 
     46                minButton.addResponse((self.jumpToBlock, i)) 
    4547                self.subwindows.append(minButton) 
    46                  
     48 
    4749    def moveLeft(self): 
    4850        """ 
     
    5153        if self.currentBlock > 0: 
    5254            self.subwindows[self.currentBlock].closeWindow() 
    53             minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * self.currentBlock, self.pos[1] + MAP_H + 10),True,self.currentBlock,False) 
    54             minButton.addResponse((self.jumpToBlock,self.currentBlock)) 
    55             self.subwindows[self.currentBlock+self.numBlocks] = minButton 
     55            minButton = MapButton((self.pos[0] + 420 / self.numBlocks * 
     56                                   self.currentBlock, 
     57                                   self.pos[1] + MAP_H + 10), 
     58                                  True, self.currentBlock, False) 
     59            minButton.addResponse((self.jumpToBlock, self.currentBlock)) 
     60            self.subwindows[self.currentBlock + self.numBlocks] = minButton 
    5661            self.currentBlock -= 1 
    5762            print self.pos[1] + MAP_H + 10 
    5863            self.subwindows[self.currentBlock].openWindow() 
    59             minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * self.currentBlock, self.pos[1] + MAP_H + 5),True,self.currentBlock,True) 
    60             minButton.addResponse((self.jumpToBlock,self.currentBlock)) 
    61             self.subwindows[self.currentBlock+self.numBlocks] = minButton 
    62             print 'left '+ str(self.currentBlock) 
    63              
     64            minButton = MapButton((self.pos[0] + 420 / self.numBlocks * 
     65                                   self.currentBlock, 
     66                                   self.pos[1] + MAP_H + 5), 
     67                                  True, self.currentBlock, True) 
     68            minButton.addResponse((self.jumpToBlock, self.currentBlock)) 
     69            self.subwindows[self.currentBlock + self.numBlocks] = minButton 
     70            print 'left ' + str(self.currentBlock) 
     71 
    6472    def moveRight(self): 
    6573        """ 
     
    6876        if self.currentBlock < self.numBlocks - 1: 
    6977            self.subwindows[self.currentBlock].closeWindow() 
    70             minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * self.currentBlock, self.pos[1] + MAP_H + 10),True,self.currentBlock,False) 
    71             minButton.addResponse((self.jumpToBlock,self.currentBlock)) 
    72             self.subwindows[self.currentBlock+self.numBlocks] = minButton 
     78            minButton = MapButton((self.pos[0] + 420 / self.numBlocks * 
     79                                   self.currentBlock, 
     80                                   self.pos[1] + MAP_H + 10), 
     81                                  True, self.currentBlock, False) 
     82            minButton.addResponse((self.jumpToBlock, self.currentBlock)) 
     83            self.subwindows[self.currentBlock + self.numBlocks] = minButton 
    7384            self.currentBlock += 1 
    7485            self.subwindows[self.currentBlock].openWindow() 
    75             minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * self.currentBlock, self.pos[1] + MAP_H + 5),True,self.currentBlock,True) 
    76             minButton.addResponse((self.jumpToBlock,self.currentBlock)) 
    77             self.subwindows[self.currentBlock+self.numBlocks] = minButton 
    78             print 'right '+ str(self.currentBlock) 
    79              
    80     def jumpToBlock(self,index): 
     86            minButton = MapButton((self.pos[0] + 420 / self.numBlocks * 
     87                                   self.currentBlock, 
     88                                   self.pos[1] + MAP_H + 5), 
     89                                  True, self.currentBlock, True) 
     90            minButton.addResponse((self.jumpToBlock, self.currentBlock)) 
     91            self.subwindows[self.currentBlock + self.numBlocks] = minButton 
     92            print 'right ' + str(self.currentBlock) 
     93 
     94    def jumpToBlock(self, index): 
    8195        """ 
    8296            Moves to the specified block 
    83              
     97 
    8498            input type: int(index) 
    8599        """ 
    86100        self.subwindows[self.currentBlock].closeWindow() 
    87         minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * self.currentBlock, self.pos[1] + MAP_H + 10),True,self.currentBlock,False) 
    88         minButton.addResponse((self.jumpToBlock,self.currentBlock)) 
    89         self.subwindows[self.currentBlock+self.numBlocks] = minButton 
     101        minButton = MapButton((self.pos[0] + 420 / self.numBlocks * 
     102                               self.currentBlock, 
     103                               self.pos[1] + MAP_H + 10), 
     104                              True, self.currentBlock, False) 
     105        minButton.addResponse((self.jumpToBlock, self.currentBlock)) 
     106        self.subwindows[self.currentBlock + self.numBlocks] = minButton 
    90107        self.currentBlock = index 
    91108        self.subwindows[self.currentBlock].openWindow() 
    92         minButton = MapButton((self.pos[0]  + 420 / self.numBlocks * self.currentBlock, self.pos[1] + MAP_H + 5),True,self.currentBlock,True) 
    93         minButton.addResponse((self.jumpToBlock,self.currentBlock)) 
    94         self.subwindows[self.currentBlock+self.numBlocks] = minButton 
    95          
    96              
    97     def event(self,e): 
     109        minButton = MapButton((self.pos[0] + 420 / self.numBlocks * 
     110                               self.currentBlock, 
     111                               self.pos[1] + MAP_H + 5), 
     112                              True, self.currentBlock, True) 
     113        minButton.addResponse((self.jumpToBlock, self.currentBlock)) 
     114        self.subwindows[self.currentBlock + self.numBlocks] = minButton 
     115 
     116    def event(self, e): 
    98117        """ 
    99             Checks if event applies to visible child windows. If so, return  
     118            Checks if event applies to visible child windows. If so, return 
    100119            true. 
    101              
     120 
    102121            Otherwise, checks if events apply to this object. If they do, 
    103122            return true and take appropriate action. 
    104              
     123 
    105124            Else, returns false. 
    106              
     125 
    107126            input type: pygame.event 
    108              
     127 
    109128            output type: boolean 
    110129        """ 
     
    112131            if window.isVisible() == True and window.event(e) == True: 
    113132                return True 
    114              
     133 
    115134        if self.response(e) == True: 
    116135            return True 
    117          
    118136        else: 
    119137            return False 
    120      
     138 
    121139    def openWindow(self): 
    122140        self.visible = True 
     
    124142        for i in range(self.numBlocks): 
    125143            self.subwindows[i + self.numBlocks].openWindow() 
    126           
     144 
    127145    def update(self, state): 
    128146        for window in self.subwindows: 
    129147            window.update(state) 
    130              
    131  
    132          
    133          
  • src/mapBuilding.py

    r292 r300  
    11''' 
    22    Created on Mar 25, 2012 
    3      
     3 
    44    @author: TechTrek 
    55''' 
     
    88from globals import * 
    99 
     10 
    1011class MapBuilding(Window): 
    1112    def __init__(self, pos, visible, blockNum, buildingSpace, buildArt): 
     
    1314        self.blockNum = blockNum 
    1415        self.buildingSpace = buildingSpace 
    15          
    16         self.images.append(Image((self.pos[0] + buildingSpace * ENTRY_SHIFT, pos[1]), ICON_SIZE, ICON_SIZE, buildArt)) 
    17          
    1816 
    19                                       
    20  
     17        self.images.append(Image((self.pos[0] + buildingSpace * 
     18                                  ENTRY_SHIFT, pos[1]), 
     19                                 ICON_SIZE, ICON_SIZE, buildArt)) 
  • src/mapButton.py

    r257 r300  
    55""" 
    66 
    7 import pygame 
    87from window import Window 
    98from image import Image 
    109from globals import * 
     10 
    1111 
    1212class MapButton(Window): 
     
    1515        self.number = number 
    1616        self.big = isBig 
    17          
    18         icon = pygame.image.load(landscapeDir + "landscape-0" + str(number+1) + ".png")  
    19          
     17 
     18        icon = pygame.image.load(landscapeDir + "landscape-0" + str(number + 1) + ".png")  
     19 
    2020        if self.big: 
    21             self.images.append(Image(self.pos, IMG_SM-10, IMG_SM-10, icon)) 
     21            self.images.append(Image(self.pos, IMG_SM - 10, IMG_SM - 10, icon)) 
    2222        else: 
    23             self.images.append(Image(self.pos, IMG_SM-20, IMG_SM-20, icon)) 
    24  
    25  
     23            self.images.append(Image(self.pos, IMG_SM - 20, IMG_SM - 20, icon)) 
  • src/menuEntry.py

    r285 r300  
    88from rectangle import Rectangle 
    99from text import Text 
     10from image import Image 
    1011from globals import * 
    11 from image import Image 
     12 
    1213 
    1314class MenuEntry(Window): 
     
    1516        Window.__init__(self, pos, visible) 
    1617 
    17         self.rectangles.append(Rectangle(self.pos,ENTRY_W,ENTRY_H,CYAN)) 
    18         self.text.append(Text((self.pos[0] + 10, self.pos[1] + 10), description.title.upper(), MD_TEXT, WHITE)) 
    19         self.text.append(Text((self.pos[0] + 10, self.pos[1] + 40), description.text, MD_TEXT, WHITE)) 
    20         self.images.append(Image((self.pos[0] + 370, self.pos[1] + 10), ICON_SIZE, ICON_SIZE, description.icon)) 
     18        self.rectangles.append(Rectangle(self.pos, ENTRY_W, ENTRY_H, CYAN)) 
     19        self.text.append(Text((self.pos[0] + 10, self.pos[1] + 10), 
     20                              description.title.upper(), MD_TEXT, WHITE)) 
     21        self.text.append(Text((self.pos[0] + 10, self.pos[1] + 40), 
     22                              description.text, MD_TEXT, WHITE)) 
     23        self.images.append(Image((self.pos[0] + 370, self.pos[1] + 10), 
     24                                 ICON_SIZE, ICON_SIZE, description.icon)) 
  • src/onScreenButton.py

    r263 r300  
    55""" 
    66 
    7 import pygame 
    87from window import Window 
    98from rectangle import Rectangle 
     
    1110from globals import * 
    1211 
     12 
    1313class OnScreenButton(Window): 
    1414    def __init__(self, pos, visible, text): 
    1515        Window.__init__(self, pos, visible) 
    1616 
    17         self.rectangles.append(Rectangle(self.pos,160,50,BLUE)) 
    18         self.text.append(Text((self.pos[0], self.pos[1] + (50 - SM_TEXT) *.75), text, SM_TEXT, WHITE, 160, True)) 
    19          
     17        self.rectangles.append(Rectangle(self.pos, 160, 50, BLUE)) 
     18        self.text.append(Text((self.pos[0], 
     19                               self.pos[1] + (50 - SM_TEXT) * .75), 
     20                              text, SM_TEXT, WHITE, 160, True)) 
  • src/rectangle.py

    r224 r300  
    55''' 
    66 
    7 import pygame 
    8 from pygame.locals import * 
    97from globals import * 
    108 
     9 
    1110class Rectangle: 
    12     """ wrapped class for pygame.Rect that contains all info needed to render """ 
    13     def __init__(self, pos, width, height, color = (0,0,0), thickness = 0): 
    14         """  
     11    """ wrapped class for pygame.Rect that contains all 
     12        info needed to render """ 
     13    def __init__(self, pos, width, height, color=(0, 0, 0), thickness=0): 
     14        """ 
    1515            initializes values 
    16              
     16 
    1717            input type: (int, int), int, int, (int, int, int), int 
    1818        """ 
    19         self.pos = (self.left,self.top) = pos 
     19        self.pos = (self.left, self.top) = pos 
    2020        self.width = width 
    2121        self.height = height 
    2222        self.color = color 
    2323        self.thickness = thickness 
    24          
     24 
    2525        self.origPos = (self.origLeft, self.origTop) = pos 
    2626        self.origWidth = width 
    2727        self.origHeight = height 
    28      
    29     def resize(self, xScale, yScale):            
     28 
     29    def resize(self, xScale, yScale): 
    3030        self.left = int(self.origLeft * xScale) 
    3131        self.top = int(self.origTop * yScale) 
     
    3333        self.width = int(self.origWidth * xScale) 
    3434        self.height = int(self.origHeight * yScale) 
    35              
     35 
    3636    def getRect(self): 
    37         return pygame.Rect(self.left,self.top,self.width,self.height) 
    38          
    39     def render(self,surface): 
    40         """  
     37        return pygame.Rect(self.left, self.top, self.width, self.height) 
     38 
     39    def render(self, surface): 
     40        """ 
    4141            wrapper for pygame's render function 
    42              
     42 
    4343            input type: pygame.Surface 
    4444            return type: None 
    4545        """ 
    46         pygame.draw.rect(surface,self.color, self.getRect()) 
     46        pygame.draw.rect(surface, self.color, self.getRect()) 
  • src/researchDescription.py

    r286 r300  
    55''' 
    66 
    7 from window import Window 
    8 from rectangle import Rectangle 
    9 from text import * 
    10 from image import Image 
    11 from description import Description 
    127from detailedDescription import DetailedDescription 
    138from simpleButton import SimpleButton 
    149from spinner import Spinner 
    1510 
     11 
    1612class ResearchDescription(DetailedDescription): 
    1713    def __init__(self, pos, visible, description): 
    1814        DetailedDescription.__init__(self, pos, visible, True, description) 
    19          
    20         yesButton = SimpleButton((self.pos[0] + 215, self.pos[1] + 200), False, "Research") 
    21         noButton = SimpleButton((self.pos[0] + 285, self.pos[1] + 200), False, "Cancel") 
     15 
     16        yesButton = SimpleButton((self.pos[0] + 215, self.pos[1] + 200), 
     17                                 False, "Research") 
     18        noButton = SimpleButton((self.pos[0] + 285, self.pos[1] + 200), 
     19                                False, "Cancel") 
    2220        yesButton.addResponse((self.closeWindow,)) 
    23         noButton.addResponse((self.closeWindow,))         
    24          
     21        noButton.addResponse((self.closeWindow,)) 
     22 
    2523        self.subwindows.append(yesButton) 
    2624        self.subwindows.append(noButton) 
    2725 
    28          
    29         self.subwindows.append(Spinner((self.pos[0] + 100, self.pos[1] + 150), False)) 
     26        self.subwindows.append(Spinner((self.pos[0] + 100, self.pos[1] + 150), 
     27                                      False)) 
    3028 
    3129    def toggle(self): 
     
    3432        for window in self.subwindows: 
    3533            window.toggle() 
    36          
     34 
    3735    def openWindow(self): 
    3836        self.visible = True 
    3937        for window in self.subwindows: 
    4038            window.openWindow() 
    41              
    42     def setYesResponse(self,response): 
     39 
     40    def setYesResponse(self, response): 
    4341        spinnerIndex = self.getElement(Spinner) 
    44         self.subwindows[0].addResponse((response[0],response[1],self.subwindows[spinnerIndex].getValue)) 
    45          
    46     def setNoResponse(self,response): 
     42        self.subwindows[0].addResponse((response[0], response[1], 
     43                                        self.subwindows[spinnerIndex].getValue)) 
     44 
     45    def setNoResponse(self, response): 
    4746        self.subwindows[1].addResponse(response) 
  • src/researchStats.py

    r252 r300  
    66 
    77from window import Window 
    8 from image import Image 
    98from rectangle import Rectangle 
    109from text import Text 
    1110from globals import * 
    1211 
     12 
    1313class ResearchStats(Window): 
    14     def __init__(self,pos,visible,values): 
     14    def __init__(self, pos, visible, values): 
    1515        Window.__init__(self, pos, visible) 
    16          
    17         self.rectangles.append(Rectangle((0,0),460,150,GRAY)) 
    18         self.text.append(Text((5,10),'Research Values', LG_TEXT,FAKEBLACK)) 
    19          
     16 
     17        self.rectangles.append(Rectangle((0, 0), 460, 150, GRAY)) 
     18        self.text.append(Text((5, 10), 'Research Values', LG_TEXT, FAKEBLACK)) 
     19 
    2020        for i, cat in enumerate(CAT_LUT): 
    21             self.text.append(Text((5+150*i,60), cat.upper()+": "+str(values[i]), SM_TEXT, WHITE, 150+150*i, True, 150*i)) 
    22             self.text.append(Text((5+150*i,80), "Some text about what can be unlocked next.", SM_TEXT, WHITE, 150, False, 150*i)) 
    23              
    24      
    25     def isCollision(self,pos): 
     21            self.text.append(Text((5 + 150 * i, 60), 
     22                                  cat.upper() + ": " + str(values[i]), SM_TEXT, 
     23                                  WHITE, 150 + 150 * i, True, 150 * i)) 
     24            self.text.append(Text((5 + 150 * i, 80), 
     25                                  "Some text about what can be unlocked next.", 
     26                                  SM_TEXT, WHITE, 150, False, 150 * i)) 
     27 
     28    def isCollision(self, pos): 
    2629        """ 
    2730            returns false. Period. 
    28              
     31 
    2932            input type: (int, int) 
    3033            return type: False 
  • src/simpleButton.py

    r268 r300  
    55""" 
    66 
    7 import pygame 
    87from window import Window 
    98from rectangle import Rectangle 
    109from text import Text 
    1110from globals import * 
     11 
    1212 
    1313class SimpleButton(Window): 
     
    1616 
    1717        self.rectangles.append(Rectangle(self.pos, 56, 25, GRAY)) 
    18         self.text.append(Text((self.pos[0], self.pos[1] + 5), message, XSM_TEXT, FAKEBLACK, 56, True)) 
     18        self.text.append(Text((self.pos[0], self.pos[1] + 5), message, 
     19                              XSM_TEXT, FAKEBLACK, 56, True)) 
  • src/spec.py

    r281 r300  
    44@author: TechTrek 
    55''' 
     6 
     7import copy 
    68from globals import * 
    7 from fileio import * 
    8 import copy 
     9 
    910 
    1011class Spec(): 
    11      
     12 
    1213    def copy(self): 
    1314        """ 
    1415            returns a copy of the Spec 
    15      
     16 
    1617            input type: None 
    1718            output type: Spec(copy) 
    1819        """ 
    1920        return copy.deepcopy(self) 
    20      
     21 
    2122    def __init__(self, 
    22                  money = START_MONEY, 
    23                  power = START_POWER, 
    24                  material = START_MATERIAL, 
    25                  space = START_SPACE, 
    26                  pollution = START_POLLUTION): 
     23                 money=START_MONEY, 
     24                 power=START_POWER, 
     25                 material=START_MATERIAL, 
     26                 space=START_SPACE, 
     27                 pollution=START_POLLUTION): 
    2728        """ 
    2829            initializes a Spec with the given values 
    29      
    30             input type: int(money), int(power), int(material), int(space), int(pollution) 
     30 
     31            input type: int(money), int(power), int(material), 
     32                        int(space), int(pollution) 
    3133        """ 
    3234        self.money = money 
     
    3537        self.space = space 
    3638        self.pollution = pollution 
    37          
    38          
     39 
    3940    def getMoney(self): 
    4041        """ 
    4142            returns the amount of money 
    42      
     43 
    4344            input type: None 
    4445            return type: int(self.money) 
    4546        """ 
    4647        return self.money 
    47      
    48     def setMoney(self,newMoney): 
     48 
     49    def setMoney(self, newMoney): 
    4950        """ 
    5051            changes the money stat of the spec 
    51      
     52 
    5253            input type: int(newMoney) 
    5354            return type: None 
    5455        """ 
    5556        self.money = newMoney 
    56          
     57 
    5758    def getPower(self): 
    5859        """ 
    5960            returns the amount of power 
    60      
     61 
    6162            input type: None 
    6263            return type: int(self.power) 
    6364        """ 
    6465        return self.power 
    65      
    66     def setPower(self,newPower): 
     66 
     67    def setPower(self, newPower): 
    6768        """ 
    6869            changes the power stat of the spec 
    69      
     70 
    7071            input type: int(newPower) 
    7172            return type: None 
    7273        """ 
    7374        self.power = newPower 
    74          
     75 
    7576    def getMaterial(self): 
    7677        """ 
    7778            returns the amount of material 
    78      
     79 
    7980            input type: None 
    8081            return type: int(self.material) 
    8182        """ 
    8283        return self.material 
    83      
    84     def setMaterial(self,newMaterial): 
     84 
     85    def setMaterial(self, newMaterial): 
    8586        """ 
    8687            changes the material stat of the spec 
    87      
     88 
    8889            input type: int(newMaterial) 
    8990            return type: None 
    9091        """ 
    9192        self.material = newMaterial 
    92          
     93 
    9394    def getSpace(self): 
    9495        """ 
    9596            returns the amount of space 
    96      
     97 
    9798            input type: None 
    9899            return type: int(self.space) 
    99100        """ 
    100101        return self.space 
    101      
    102     def setSpace(self,newSpace): 
     102 
     103    def setSpace(self, newSpace): 
    103104        """ 
    104105            changes the space stat of the spec 
    105      
     106 
    106107            input type: int(newSpace) 
    107108            return type: None 
    108109        """ 
    109110        self.space = newSpace 
    110          
     111 
    111112    def getPollution(self): 
    112113        """ 
    113114            returns the amount of pollution 
    114      
     115 
    115116            input type: None 
    116117            return type: int(self.pollution) 
    117118        """ 
    118119        return self.pollution 
    119      
    120     def setPollution(self,newPollution): 
     120 
     121    def setPollution(self, newPollution): 
    121122        """ 
    122123            changes the pollution stat of the spec 
    123      
     124 
    124125            input type: int(newPollution) 
    125126            return type: None 
    126127        """ 
    127128        self.pollution = newPollution 
    128          
     129 
    129130    def getAllStats(self): 
    130131        """ 
    131132            returns all the stats names, values, and relative colors 
    132      
     133 
    133134            input type: None 
    134             return type: [(str('money'), int(self.money), (int(red),int(green),int(blue))) 
    135                         (str('power'), int(self.power), (int(red),int(green),int(blue))) 
    136                         (str('material'), int(self.material), (int(red),int(green),int(blue))) 
    137                         (str('space'), int(self.space), (int(red),int(green),int(blue))) 
    138                         (str('pollution'), int(self.pollution), (int(red),int(green),int(blue))) 
     135            return type: [(str('money'), int(self.money), bool(isBad)) 
     136                        (str('power'), int(self.power), bool(isBad)) 
     137                        (str('material'), int(self.material), bool(isBad))) 
     138                        (str('space'), int(self.space), bool(isBad)) 
     139                        (str('pollution'), int(self.pollution), bool(isBad)) 
    139140        """ 
    140         return [('money', self.money, False), # ideally these colors should be dynamic with relative magnitude 
    141                 ('power', self.power, False),  
    142                 ('material', self.material, False),  
    143                 ('space', self.space, False),  
     141        return [('money', self.money, False), 
     142                ('power', self.power, False), 
     143                ('material', self.material, False), 
     144                ('space', self.space, False), 
    144145                ('pollution', self.pollution, True)] 
    145      
    146     def __isub__(self,otherSpec): 
     146 
     147    def __isub__(self, otherSpec): 
    147148        """ 
    148149            subtracts one spec from another 
    149      
     150 
    150151            input type: Spec(otherSpec) 
    151152            return type: Spec(self) 
     
    157158        self.setPollution(self.getPollution() - otherSpec.getPollution()) 
    158159        return self 
    159          
    160     def __iadd__(self,otherSpec): 
     160 
     161    def __iadd__(self, otherSpec): 
    161162        """ 
    162163            adds one spec from another 
    163      
     164 
    164165            input type: Spec(otherSpec) 
    165166            return type: Spec(self) 
     
    171172        self.setPollution(self.getPollution() + otherSpec.getPollution()) 
    172173        return self 
    173      
     174 
    174175    def stringToValue(self, statID): 
    175176        """ 
    176177            gets the value associated with the given statID 
    177      
     178 
    178179            input type: str(statID) 
    179180            return type: int(statValue) 
  • src/spinner.py

    r292 r300  
    11""" 
    2 Created 23 Mar 2012  
     2Created 23 Mar 2012 
    33 
    44@TechTrek 
     
    77from window import Window 
    88from upDown import UpDown 
    9 from image import Image 
    10 from rectangle import Rect 
    119from text import Text 
    1210from globals import * 
    1311 
     12 
    1413class Spinner(Window): 
    15      
    16     def __init__(self, pos, visible, startValue = 0, maximum = 1000, minimum = 0, step = 10): 
     14 
     15    def __init__(self, pos, visible, startValue=0, 
     16                 maximum=1000, minimum=0, step=10): 
    1717        print 'initialized spinner early: ' + str(self) 
    1818        Window.__init__(self, pos, visible) 
     
    2222        self.min = minimum 
    2323        self.step = step 
    24          
     24 
    2525        up = UpDown(self.pos, False, True) 
    2626        down = UpDown((self.pos[0], self.pos[1] + 50), True, False) 
    27         up.addResponse((self.updateValue,True)) 
    28         down.addResponse((self.updateValue,False)) 
    29  
     27        up.addResponse((self.updateValue, True)) 
     28        down.addResponse((self.updateValue, False)) 
    3029 
    3130        self.subwindows.append(up) 
    3231        self.subwindows.append(down) 
    33         self.text.append(Text((pos[0] + 60, pos[1] + 25), str(self.value), MD_TEXT, FAKEBLACK)) 
    34          
     32        self.text.append(Text((pos[0] + 60, pos[1] + 25), 
     33                              str(self.value), MD_TEXT, FAKEBLACK)) 
    3534 
    36     def updateValue(self,isUp): 
     35    def updateValue(self, isUp): 
    3736        """ 
    3837            Updates the value of the spinner 
    39              
     38 
    4039            input type: bool(isUp) 
    4140        """ 
     
    4544            self.value -= self.step 
    4645 
    47  
    48 #    def response(self,event): 
    49 #        if self.subwindows[0].isVisible() == True and self.subwindows[0].event(e) == True: 
     46#    def response(self, e): 
     47#        if self.subwindows[0].isVisible() == True and \ 
     48#        self.subwindows[0].event(e) == True: 
    5049#            self.updateValue(True) 
    51 #        if self.subwindows[1].isVisible() == True and self.subwindows[1].event(e) == True: 
     50#        if self.subwindows[1].isVisible() == True and \ 
     51#        self.subwindows[1].event(e) == True: 
    5252#            self.updateValue(False) 
    5353 
    54     def update(self,state): 
     54    def update(self, state): 
    5555        self.max = state.getMoney() 
    5656        self.text = [] 
    57         self.text.append(Text((self.pos[0] + 60, self.pos[1] + 25), str(self.value), MD_TEXT, FAKEBLACK)) 
    58          
     57        self.text.append(Text((self.pos[0] + 60, self.pos[1] + 25), 
     58                              str(self.value), MD_TEXT, FAKEBLACK)) 
     59 
    5960    def openWindow(self): 
    6061        print 'opening: ' + str(self) 
     
    6465        self.value = self.min 
    6566 
    66              
    6767    def closeWindow(self): 
    6868        self.visible = False 
     
    7070            window.closeWindow() 
    7171 
    72          
    7372    def getValue(self): 
    7473        return self.value 
  • src/state.py

    r290 r300  
    77''' 
    88 
    9 from globals import * 
    109from spec import Spec 
    1110from buildables import * 
    1211from window import Window 
    13 from fileio import * 
    1412from buildables import buildingLUT 
     13from globals import * 
     14 
    1515 
    1616class State(): 
    17     """ keeps track of stats, buildings that have been built and research values"""  
    18     def __init__(self,newSpec): 
    19         """ 
    20             initializes a state object with the given spec and no buildings or research 
    21              
    22             input type: Spec(newSpec) 
    23         """ 
     17    """ keeps track of stats, buildings that have been built and 
     18        research values"""  
     19    def __init__(self, newSpec): 
     20        """ 
     21            initializes a state object with the given spec and no buildings 
     22            or research 
     23 
     24            input type: Spec(newSpec) 
     25        """ 
    2426        self.specs = newSpec 
    2527        self.currentBuildings = [] 
    2628        self.buildingsToAdd = [] 
    27         self.currentResearch = [0,0,0] 
     29        self.currentResearch = [0, 0, 0] 
    2830        for i in range(START_BLOCKS): 
    2931            self.currentBuildings.append([]) 
    3032            self.buildingsToAdd.append([]) 
    3133        self.buildingLUT = buildingLUT 
    32      
    33     def checkThresh(self,building): 
    34         """ 
    35             checks the thresholds of the given building to see if it can be built 
    36              
    37             input type: Building(str) 
    38             return type: Bool 
    39         """ 
     34 
     35    def checkThresh(self, building): 
     36        """ 
     37            checks the thresholds of the given building to see if it can 
     38            be built 
     39 
     40            input type: Building(str) 
     41            return type: Bool 
     42        """ 
    4043        stats = self.buildingLUT[building].getStats() 
    4144        thresholds = self.buildingLUT[building].getThreshold() 
     
    4851                    return True 
    4952        return False 
    50      
     53 
    5154    # ONE DOES NOT SIMPLY ADD A BUILDING!!! 
    52     def addBuilding(self,building,blockNumber): 
    53         """  
    54             adds a building to current buildings and updates stats 
    55              
    56             input type: Building(str) 
    57             return type: None 
    58         """ 
     55    def addBuilding(self, building, blockNumber): 
     56        """ 
     57            adds a building to current buildings and updates stats 
     58 
     59            input type: Building(str) 
     60            return type: None 
     61        """ 
    5962        self.buildingsToAdd[blockNumber].append(building) 
    6063        buildingSpec = building.getStats().getOneTime() 
    6164        self.updateSpec(buildingSpec) 
    6265        if DEBUG == 0 or DEBUG == 1 or DEBUG == 2: 
    63             print "Added:", building, " Current buildings: ", self.currentBuildings  
    64      
    65     def deleteBuilding(self,blockNumber,indexNumber): 
     66            print "Added:", building, 
     67            print " Current buildings: ", self.currentBuildings 
     68 
     69    def deleteBuilding(self, blockNumber, indexNumber): 
    6670        """ 
    6771            removes a building from the current buildings 
    68              
     72 
    6973            input type: Building(building) 
    7074            return type: None 
    7175        """ 
    7276        self.currentBuildings[blockNumber].pop(indexNumber) 
    73      
    74     def research(self,researchType,amount): 
    75         """ 
    76             adjusts money based on research 
    77              
    78             input type: int(researchType), int(amount) 
    79             return type: None 
    80         """ 
    81         change = Spec(amount,0,0,0,0) 
     77 
     78    def research(self, researchType, amount): 
     79        """ 
     80            adjusts money based on research 
     81 
     82            input type: int(researchType), int(amount) 
     83            return type: None 
     84        """ 
     85        change = Spec(amount, 0, 0, 0, 0) 
    8286        self.specs -= change 
    8387        self.currentResearch[researchType] += amount 
    84      
     88 
    8589#    def getResearchValues(self): 
    8690#        """ 
    8791#            gets the research values for each category 
    88 #             
     92# 
    8993#            return type: [power,transportation,material] 
    9094#        """ 
    9195#        return self.currentResearch 
    92          
     96 
    9397#    def getBuildings(self): 
    9498#        """ 
    9599#            gets the current buildings 
    96 #             
     100# 
    97101#            return type: [Buildings] 
    98102#        """ 
    99103#        return self.currentBuildings 
    100       
     104 
    101105    def calcTurnChange(self): 
    102106        """ 
    103107            returns the updated states for the end of a turn/week 
    104              
     108 
    105109            return type: Spec(spec) 
    106110        """ 
    107         spec = Spec(END_TURN_MONEY,0,0,0,0) 
     111        spec = Spec(END_TURN_MONEY, 0, 0, 0, 0) 
    108112        for block in self.currentBuildings: 
    109113            for building in block: 
    110114                spec += building.getStats().getCont() 
    111115        return spec 
    112      
    113     def updateSpec(self,changeSpec): 
     116 
     117    def updateSpec(self, changeSpec): 
    114118        """ 
    115119            updates spec with the given change 
    116              
     120 
    117121            input type: Spec(changeSpec) 
    118122            return type: None 
    119123        """ 
    120124        self.specs += changeSpec 
    121      
     125 
    122126    def getMoney(self): 
    123127        """ 
    124128            gets money 
    125              
     129 
    126130            return type: int 
    127131        """ 
     
    131135        """ 
    132136            gets the stat bar for specs 
    133             
     137 
    134138            input type: None 
    135139            return type: Window(statbars) 
     
    140144#        """ 
    141145#            creates a description of the stat 
    142 #             
     146# 
    143147#            input type: str(statID) 
    144148#            return type: Window(stat) 
    145149#        """ 
    146 #        stat = Window('',600, 480) 
    147 #        stat.setDefaultResponse(Response('windows',[], True, True)) 
    148 #        details = WindowEntry(Response('windows',[], True, True)) 
    149 #        details.addRectangle(Rectangle((40,50), STAT_W - 80, 70, MAUVE)) 
    150 #        statDescription = statID.capitalize() + ": " + str(self.specs.stringToValue(statID)) + " - " 
     150#        stat = Window('', 600, 480) 
     151#        stat.setDefaultResponse(Response('windows', [], True, True)) 
     152#        details = WindowEntry(Response('windows', [], True, True)) 
     153#        details.addRectangle(Rectangle((40, 50), STAT_W - 80, 70, MAUVE)) 
     154#        statDescription = statID.capitalize() + ": " 
     155#        statDescription += str(self.specs.stringToValue(statID)) + " - " 
    151156#        # this text will eventually be dynamic 
    152 #        statDescription = statDescription + "To improve this stat, try researching in something intelligent." 
    153 #        details.addText(Text((40,50), statDescription, MD_TEXT, WHITE, STAT_W - 80)) 
    154 #         
     157#        statDescription = statDescription + "To improve this stat, " 
     158#        statDescription += "try researching in something intelligent." 
     159#        details.addText(Text((40, 50), statDescription, 
     160#                             MD_TEXT, WHITE, STAT_W - 80)) 
     161# 
    155162#        stat.addEntry(details) 
    156163#        return stat 
    157      
     164 
    158165    def checkLoseConditions(self): 
    159166        """ 
    160167            check if lose conditions have been passed 
    161              
     168 
    162169            return type: [Bool,Bool,Bool,Bool] 
    163170        """ 
    164171        # [alert pollution, alert food, end poll, end food] 
    165         warnings = [False,False,False,False] 
     172        warnings = [False, False, False, False] 
    166173        if self.specs.getPollution() > 150: 
    167174            warnings[0] = True 
     
    173180            warnings[3] = True 
    174181        return warnings 
    175      
     182 
    176183    def checkWinConditions(self): 
    177184        """ 
    178185            check if win condition has been meet 
    179              
     186 
    180187            return type: Bool 
    181188        """ 
     
    186193                return True 
    187194        return False 
    188      
     195 
    189196    def __repr__(self): 
    190197        """ 
     
    197204                output += i + ", " 
    198205        output += "\n Specs: " 
    199          
     206 
    200207        for i in self.specs.getAllStats(): 
    201208            statString = i[0] + ': ' + str(i[1]) + ', ' 
    202209            output += statString 
    203210        return output 
    204      
    205     def getBlockBuildings(self,blockNumber): 
     211 
     212    def getBlockBuildings(self, blockNumber): 
    206213        """ 
    207214            returns the images associated with the buildings that exist in the 
    208215            designated block. 
    209              
     216 
    210217            input type: blockNumber(int) 
    211218            return type: none 
     
    215222            images.append(pygame.image.load(os.path.abspath(iconDir + self.buildingLUT[building.name].imageFileName))) 
    216223        return images 
    217      
     224 
    218225    def endTurn(self): 
    219226        """ 
    220227            ends the turn, updating the states as necessary. 
    221              
     228 
    222229            input type: none 
    223230            return type: none 
     
    228235        for i in range(len(self.currentBuildings)): 
    229236            self.buildingsToAdd.append([]) 
    230              
     237 
    231238    def getSpec(self): 
    232239        """ 
    233240            returns the spec containing values of current resources. 
    234              
     241 
    235242            input type: none 
    236243            return type: spec 
    237244        """ 
    238245        return self.specs.getAllStats() 
    239      
    240     def blockHasSpace(self,blockNumber): 
     246 
     247    def blockHasSpace(self, blockNumber): 
    241248        """ 
    242249            returns whether the designated block has space for a building. 
    243              
     250 
    244251            input type: blockNumber(int) 
    245252            return type: boolean 
    246253        """ 
    247         if len(self.currentBuildings[blockNumber]) + len(self.buildingsToAdd[blockNumber]) < MAX_BUILDINGS: 
     254        if len(self.currentBuildings[blockNumber]) +\ 
     255        len(self.buildingsToAdd[blockNumber]) < MAX_BUILDINGS: 
    248256            return True 
    249257        else: 
  • src/stats.py

    r290 r300  
    66 
    77from window import Window 
    8 from image import Image 
     8 
    99from rectangle import Rectangle 
    10 from text import Text 
     10import statusBar 
    1111from globals import * 
    12 import statusBar 
     12 
    1313 
    1414class Stats(Window): 
    15     def __init__(self,pos,visible,spec): 
     15    def __init__(self, pos, visible, spec): 
    1616        Window.__init__(self, pos, visible) 
    17          
     17 
    1818        self.spec = spec 
    19          
    20         self.rectangles.append(Rectangle(self.pos,STAT_W,STAT_H,GRAY)) 
    21          
     19 
     20        self.rectangles.append(Rectangle(self.pos, STAT_W, STAT_H, GRAY)) 
     21 
    2222        i = 0 
    2323        for (name, value, isBad) in self.spec: 
    2424            barPos = (self.pos[0] + 15 + STAT_SHIFT * i, self.pos[1] + 30) 
    25             self.subwindows.append(statusBar.StatusBar(barPos, True, name, value, isBad)) 
     25            self.subwindows.append(statusBar.StatusBar(barPos, True, name, 
     26                                                       value, isBad)) 
    2627            i += 1 
    27      
     28 
    2829    def openWindow(self): 
    2930        self.visible = True 
     
    3132            window.openWindow() 
    3233 
    33     def update(self,state): 
     34    def update(self, state): 
    3435        for window in self.subwindows: 
    3536            window.update(state) 
  • src/statusBar.py

    r297 r300  
    55""" 
    66 
    7 import pygame 
    87from window import Window 
    98from rectangle import Rectangle 
    10 from text import Text 
    119from image import Image 
    1210from globals import * 
     
    1412 
    1513class StatusBar(Window): 
    16     def __init__(self, pos, visible, category, value, isBad=False):  # good used for coloring 
     14    def __init__(self, pos, visible, category, value, isBad=False): 
     15        """ 
     16            Initializes the status bar.  The isBad argument is 
     17            used for coloring the bar. 
     18        """ 
     19 
    1720        Window.__init__(self, pos, visible) 
    1821        self.category = category 
     
    2023        self.isBad = isBad 
    2124 
    22         self.rectangles.append(Rectangle(self.pos, STAT_BAR_W, STAT_BAR_H, FAKEBLACK)) 
     25        self.rectangles.append(Rectangle(self.pos, STAT_BAR_W, 
     26                                         STAT_BAR_H, FAKEBLACK)) 
    2327        icon = pygame.image.load(iconDir + category + '.png') 
    24         self.images.append(Image((self.pos[0] + 20, self.pos[1] + STAT_BAR_H), STAT_ICON_SIZE, STAT_ICON_SIZE, icon)) 
     28        self.images.append(Image((self.pos[0] + 20, self.pos[1] + STAT_BAR_H), 
     29                                 STAT_ICON_SIZE, STAT_ICON_SIZE, icon)) 
    2530 
    2631        self.progress() 
     
    3439        self.value = min(value, 200) 
    3540        self.rectangles = [] 
    36         self.rectangles.append(Rectangle(self.pos, STAT_BAR_W, STAT_BAR_H, FAKEBLACK)) 
     41        self.rectangles.append(Rectangle(self.pos, STAT_BAR_W, 
     42                                         STAT_BAR_H, FAKEBLACK)) 
    3743        self.progress() 
    3844 
     
    4248        print "constant ", STAT_BAR_H 
    4349        print "particular ", height 
    44         self.rectangles.append(Rectangle((self.pos[0], self.pos[1] + (STAT_BAR_H - height)), STAT_BAR_W, height, dynamicColor(self.value, self.isBad))) 
     50        self.rectangles.append(Rectangle((self.pos[0], 
     51                                          self.pos[1] + (STAT_BAR_H - height)), 
     52                                         STAT_BAR_W, 
     53                                         height, 
     54                                         dynamicColor(self.value, self.isBad))) 
    4555 
    4656    def update(self, state): 
  • src/still.py

    r239 r300  
    66 
    77from window import Window 
    8 from rectangle import Rectangle 
    98from text import Text 
     9from image import Image 
    1010from globals import * 
    1111 
     12 
    1213class Still(Window): 
    13     def __init__(self,pos,visible,text,image): 
     14    def __init__(self, pos, visible, text, image): 
    1415        """ 
    1516            initializes the components of the Still subclass 
    16      
     17 
    1718            input type: int((x,y)), bool(visible), str(text), str(image) 
    1819        """ 
     
    2122        scene = pygame.image.load(sequenceDir + image) 
    2223        self.images.append(Image(self.pos, SCREEN_W, SCREEN_H, scene)) 
    23         self.text.append(Text((10, 17), text, LG_TEXT, WHITE, ORIG_SCREEN_W - 20)) 
     24        self.text.append(Text((10, 17), text, LG_TEXT, 
     25                              WHITE, ORIG_SCREEN_W - 20)) 
  • src/text.py

    r285 r300  
    55''' 
    66 
    7 import pygame, os 
    87from pygame.locals import * 
    98from globals import * 
    109from itertools import chain 
    11 from font import * 
     10 
    1211 
    1312class Text: 
    1413    """ class that contains information necessary to render text """ 
    15      
    16     def __init__(self, pos, text, size, color, width = SCREEN_W-20, center = False, shift = 0): 
    17         """  
     14 
     15    def __init__(self, pos, text, size, color, 
     16                 width=SCREEN_W - 20, center=False, shift=0): 
     17        """ 
    1818            initialize values: 
    1919                -width determines how to wrap the text 
    20                 -shift is the amount the text should always be shifted from the edge of the window 
    21                 since width is in the relative coordinate and may not start where the text starts 
    22                 -center determines if the text should be centered  
    23                  
     20                -shift is the amount the text should always be shifted 
     21                 from the edge of the window 
     22                since width is in the relative coordinate and may not 
     23                 start where the text starts 
     24                -center determines if the text should be centered 
     25 
    2426            input type: (int, int), str, int, (int,int,int), int, bool, int 
    2527        """ 
     
    3537        self.shift = shift 
    3638        self.origShift = shift 
    37         self.font = pygame.font.Font(FONT_FILE,self.size) 
    38          
    39     def render(self,surface): 
    40         """  
     39        self.font = pygame.font.Font(FONT_FILE, self.size) 
     40 
     41    def render(self, surface): 
     42        """ 
    4143            draw text to surface 
    42                  
     44 
    4345            input type: pygame.Surface 
    4446            return type: None 
     
    4850        #print self.text 
    4951        wrapped = self.wrapMultiLine() 
    50          
    51          
     52 
    5253        if self.center: 
    5354            # render each line 
     
    5657                text = self.font.render(wrapped[i], True, self.color) 
    5758                # move rectangle to center 
    58                 textRect = text.get_rect(centerx = self.left + (self.maxWidth-self.shift) / 2) 
    59                 surface.blit(text, pygame.Rect(textRect.x + self.shift, self.top + (self.size) * i, 0, 0)) 
     59                textRect = text.get_rect(centerx=self.left +\ 
     60                                         (self.maxWidth - self.shift) / 2) 
     61                surface.blit(text, pygame.Rect(textRect.x + self.shift, 
     62                                               self.top + (self.size) * i, 
     63                                               0, 0)) 
    6064        else: 
    6165            # render each line 
    6266            for i in range(len(wrapped)): 
    6367                surface.blit(self.font.render(wrapped[i], True, self.color), 
    64                              pygame.Rect(self.left, self.top + (self.size) * i, 0, 0)) 
    65          
     68                             pygame.Rect(self.left, 
     69                                         self.top + (self.size) * i, 
     70                                         0, 0)) 
     71 
    6672    def resize(self, xScale, yScale): 
    67         """  
     73        """ 
    6874            resize text based off of screen size 
    69                  
     75 
    7076            input type: (int, int) 
    7177            return type: none 
    7278        """ 
    73          
     79 
    7480        # calculate and update values 
    75         self.size = int(min(xScale,yScale) * self.origSize) 
     81        self.size = int(min(xScale, yScale) * self.origSize) 
    7682        self.maxWidth = int(self.origMaxWidth * xScale) 
    7783        self.left = int(self.origPos[0] * xScale) 
    7884        self.top = int(self.origPos[1] * yScale) 
    79         self.pos = (self.left,self.top) 
    80         self.font = pygame.font.Font(FONT_FILE,self.size) 
     85        self.pos = (self.left, self.top) 
     86        self.font = pygame.font.Font(FONT_FILE, self.size) 
    8187        self.shift = int(xScale * self.origShift) 
    82          
     88 
    8389    def truncLine(self, text): 
    84         """  
    85             adapted from http://pygame.org/wiki/TextWrapping   
    86              
    87             helper function for wrapping a line by truncating it at correct location 
    88          
     90        """ 
     91            adapted from http://pygame.org/wiki/TextWrapping 
     92 
     93            helper function for wrapping a line by truncating it at 
     94            correct location 
     95 
    8996            input type: string 
    9097            return type: int, bool, str 
    9198        """ 
    92         lineLength = len(text)        
    93         stext = text            
    94         l=self.font.size(text)[0] 
     99        lineLength = len(text) 
     100        stext = text 
     101        l = self.font.size(text)[0] 
    95102        cut = 0 
    96         a = 0                   
     103        a = 0 
    97104        done = 1 
    98         while l > self.maxWidth:  
     105        while l > self.maxWidth: 
    99106            a = a + 1 
    100             n=text.rsplit(None, a)[0] 
     107            n = text.rsplit(None, a)[0] 
    101108            if stext == n: 
    102109                cut += 1 
     
    104111            else: 
    105112                stext = n 
    106             l=self.font.size(stext)[0] 
    107             lineLength = len(stext)                
    108             done=0                         
    109         return lineLength, done, stext              
    110      
    111     def wrapLine(self, line):  
    112         """  
    113             adapted from http://pygame.org/wiki/TextWrapping   
    114              
     113            l = self.font.size(stext)[0] 
     114            lineLength = len(stext) 
     115            done = 0 
     116        return lineLength, done, stext 
     117 
     118    def wrapLine(self, line): 
     119        """ 
     120            adapted from http://pygame.org/wiki/TextWrapping 
     121 
    115122            helper function for wrapping a single line 
    116          
     123 
    117124            input type: str 
    118125            return type: [str] 
    119126        """ 
    120         done = 0                       
    121         wrapped = []                   
    122                                     
    123         while not done:              
    124             nl, done, stext = self.truncLine(line)  
    125             wrapped.append(stext.strip())                   
    126             line = line[nl:]                                  
     127        done = 0 
     128        wrapped = [] 
     129 
     130        while not done: 
     131            nl, done, stext = self.truncLine(line) 
     132            wrapped.append(stext.strip()) 
     133            line = line[nl:] 
    127134        return wrapped 
    128      
     135 
    129136    def wrapMultiLine(self): 
    130         """  
    131             adapted from http://pygame.org/wiki/TextWrapping   
    132              
     137        """ 
     138            adapted from http://pygame.org/wiki/TextWrapping 
     139 
    133140            wraps multiline text strings 
    134          
     141 
    135142            input type: None 
    136143            return type: [str] 
     
    138145        lines = chain(*(self.wrapLine(line) for line in self.text.splitlines())) 
    139146        return list(lines) 
    140  
  • src/top.py

    r295 r300  
    99 
    1010import dimensions 
    11 import pygame 
    12 import os 
    1311import sys 
    1412import cPickle 
     
    5048                self.subwindows.insert(0, window) 
    5149                self.update(self.gameData.currentState) 
    52                 self.resize(float(dimensions.SCREEN_W) / float(ORIG_SCREEN_W), float(dimensions.SCREEN_H) / float(ORIG_SCREEN_H)) 
     50                self.resize(float(dimensions.SCREEN_W) / float(ORIG_SCREEN_W), 
     51                            float(dimensions.SCREEN_H) / float(ORIG_SCREEN_H)) 
    5352                self.render(self.surface) 
    5453 
     
    6160        if e.type == VIDEORESIZE: 
    6261 
    63             # set the global values of screen width and height to the new values 
     62            # set the global values to new screen width and new height 
    6463            global SCREEN_W 
    6564            dimensions.SCREEN_W = e.w 
     
    7069            # game resizes correctly. 
    7170            for window in self.subwindows: 
    72                 window.resize(float(e.w) / float(ORIG_SCREEN_W), float(e.h) / float(ORIG_SCREEN_H)) 
     71                window.resize(float(e.w) / float(ORIG_SCREEN_W), 
     72                              float(e.h) / float(ORIG_SCREEN_H)) 
    7373 
    7474            # rerender the screen with the new dimensions 
    75             screenSurface = pygame.display.set_mode((dimensions.SCREEN_W, dimensions.SCREEN_H), RESIZABLE) 
     75            screenSurface = pygame.display.set_mode((dimensions.SCREEN_W, 
     76                                                     dimensions.SCREEN_H), 
     77                                                    RESIZABLE) 
    7678            screenSurface.fill(BLACK) 
    7779            self.render(screenSurface) 
     
    162164    def build(self, building): 
    163165        """ 
    164             first, checks that there is room in the current block, then builds the building. 
     166            first, checks that there is room in the current block, 
     167            then builds the building. 
    165168 
    166169            input type: building(str) 
  • src/upDown.py

    r265 r300  
    55""" 
    66 
    7 import pygame 
    87from window import Window 
     8from image import Image 
    99from globals import * 
    10 from image import Image 
     10 
    1111 
    1212class UpDown(Window): 
  • src/window.py

    r285 r300  
    55''' 
    66from pygame.locals import * 
    7 import pygame 
    8 from image import Image 
    9 from text import Text 
    10 from rectangle import Rectangle 
     7 
    118 
    129class Window: 
    13     ''' Window is a basic window class with basic implementation. Can  
     10    ''' Window is a basic window class with basic implementation. Can 
    1411        be used as a template, or for inheritance by another class.''' 
    1512 
    16  
    17     def __init__(self,pos,visible = False): 
     13    def __init__(self, pos, visible=False): 
    1814        """ 
    1915            initializes a window 
     
    2622        self.responseFunctions = [] 
    2723        self.pos = pos 
    28          
    29     def event(self,e): 
    30         """ 
    31             Checks if event applies to visible child windows. If so, return  
     24 
     25    def event(self, e): 
     26        """ 
     27            Checks if event applies to visible child windows. If so, return 
    3228            true. 
    33              
     29 
    3430            Otherwise, checks if events apply to this object. If they do, 
    3531            return true and take appropriate action. 
    36              
     32 
    3733            Else, returns false. 
    38              
     34 
    3935            input type: pygame.event 
    40              
     36 
    4137            output type: boolean 
    4238        """ 
     
    4440            if window.isVisible() == True and window.event(e) == True: 
    4541                self.subwindows.remove(window) 
    46                 self.subwindows.insert(0,window) 
     42                self.subwindows.insert(0, window) 
    4743                return True 
    48              
     44 
    4945        if self.response(e) == True: 
    5046            return True 
    51          
     47 
    5248        else: 
    5349            return False 
    54          
    55     def isCollision(self,pos): 
     50 
     51    def isCollision(self, pos): 
    5652        """ 
    5753            Checks if the given position collides with this window. 
    58          
     54 
    5955            input type: pos 
    60              
     56 
    6157            output type: boolean 
    6258        """ 
     
    6460            if rectangle.getRect().collidepoint(pos) == True: 
    6561                return True 
    66          
     62 
    6763        for image in self.images: 
    6864            if image.getRect().collidepoint(pos) == True: 
    6965                return True 
    70              
     66 
    7167        else: 
    7268            return False 
    73          
     69 
    7470    def render(self, surface): 
    7571        """ 
     
    8985            for window in reversed(self.subwindows): 
    9086                window.render(surface) 
    91          
     87 
    9288    def addText(self, text): 
    9389        """ 
     
    9894        """ 
    9995        self.text.append(text) 
    100      
     96 
    10197    def addImage(self, image): 
    10298        """ 
     
    107103        """ 
    108104        self.images.append(image) 
    109          
     105 
    110106    def addRectangle(self, rectangle): 
    111107        """ 
     
    117113        """ 
    118114        self.rectangles.append(rectangle) 
    119          
     115 
    120116    def resize(self, xScale, yScale): 
    121117        """ 
     
    130126 
    131127        for i in self.images: 
    132             i.resize(xScale, yScale)  
    133          
     128            i.resize(xScale, yScale) 
     129 
    134130        for t in self.text: 
    135131            t.resize(xScale, yScale) 
    136              
     132 
    137133        for window in self.subwindows: 
    138134            window.resize(xScale, yScale) 
    139              
     135 
    140136    def addResponse(self, functionTuple): 
    141137        """ 
    142138            adds a function pointer to be called when a response is required. 
    143              
     139 
    144140            input type: (function pointer, parameters) 
    145141            return type: none 
    146142        """ 
    147143        self.responseFunctions.append(functionTuple) 
    148          
    149     def response(self,e): 
    150         """ 
    151             runs the windows response by calling all functions in the  
     144 
     145    def response(self, e): 
     146        """ 
     147            runs the windows response by calling all functions in the 
    152148            response functions list. 
    153              
     149 
    154150            input type: none 
    155151            return type: boolean 
    156152        """ 
    157         if e.type == MOUSEBUTTONDOWN and e.dict.has_key('button'): 
     153        if e.type == MOUSEBUTTONDOWN and 'button' in e.dict: 
    158154            if e.dict['button'] == 1: 
    159155                if self.isCollision(e.pos): 
     
    164160        else: 
    165161            return False 
    166          
     162 
    167163    def closeWindow(self): 
    168164        """ 
    169165            closes the window, rendering it not-visible. 
    170              
     166 
    171167            input type: none 
    172168            return type: none 
     
    175171        self.closeSubWindows() 
    176172 
    177          
    178173    def closeSubWindows(self): 
    179174        """ 
    180175            closes subwindows 
    181              
     176 
    182177            input type: none 
    183178            return type: none 
     
    185180        for window in self.subwindows: 
    186181            window.closeWindow() 
    187      
     182 
    188183    def toggle(self): 
    189184        """ 
    190185            toggles the visibility of the window. 
    191              
     186 
    192187            input type: none 
    193188            return type: none 
     
    197192        else: 
    198193            self.closeWindow() 
    199          
     194 
    200195    def openWindow(self): 
    201196        """ 
    202197            opens the window, rendering it visible. 
    203              
     198 
    204199            input type: none 
    205200            return type: none 
     
    207202        #print 'opening: ' + str(self) 
    208203        self.visible = True 
    209          
    210     def addWindow(self,window): 
     204 
     205    def addWindow(self, window): 
    211206        """ 
    212207            adds a window to the list of subwindows. 
    213              
     208 
    214209            input type: Window 
    215210            return type: none 
    216211        """ 
    217212        self.subwindows.append(window) 
    218          
    219     def setPos(self,pos): 
     213 
     214    def setPos(self, pos): 
    220215        """ 
    221216            sets the position of the window relative to the parent window. 
    222              
     217 
    223218            input type: (int, int) 
    224219            output type: none 
    225220        """ 
    226221        self.pos = pos 
    227          
     222 
    228223    def getPos(self): 
    229224        """ 
    230225            gets the position of the window relative to the parent window. 
    231              
     226 
    232227            input type: none 
    233228            return type: none 
    234229        """ 
    235230        return self.pos 
    236          
    237     def update(self,state): 
     231 
     232    def update(self, state): 
    238233        """ 
    239234            takes in a state and updates window as neccesary. 
    240              
     235 
    241236            input type: state 
    242237            return type: none 
     
    244239        for window in self.subwindows: 
    245240            window.update(state) 
    246              
     241 
    247242    def isVisible(self): 
    248243        """ 
    249244            returns whether the window is visible. 
    250              
     245 
    251246            input type: none 
    252247            return type: boolean 
    253248        """ 
    254249        return self.visible 
    255      
    256     def getElement(self,windowType): 
     250 
     251    def getElement(self, windowType): 
    257252        """ 
    258253            returns the first subwindow of this window with the given type. 
    259              
     254 
    260255            input type: windowType(type) 
    261256            return type: window 
    262257        """ 
    263258        print windowType 
    264         for i,window in enumerate(self.subwindows): 
     259        for i, window in enumerate(self.subwindows): 
    265260            print type(window) 
    266             if isinstance(window,windowType): 
     261            if isinstance(window, windowType): 
    267262                return i 
    268263        print 'window doesn\'t exist!'