Changeset 300


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

Finished editing style in files

Location:
src
Files:
28 edited

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!'
Note: See TracChangeset for help on using the changeset viewer.