Example #1
0
    def __init__(self, num):
        self.num = num

        numOfCols = int(
            math.ceil(float(num) / float(CHARACTER_SELECT_PANELS_PER_COL)))

        numOfPanelsInCol = []
        for i in range(numOfCols):
            numOfPanelsInCol.append(0)

        count = 0
        currCol = 0
        while count < num:
            numOfPanelsInCol[currCol] += 1
            count += 1
            currCol += 1
            if currCol == numOfCols:
                currCol = 0

        self.characterPanels = []
        for i in range(len(numOfPanelsInCol)):
            colMid = (SCREEN_SIZE[0] / (len(numOfPanelsInCol) + 1)) * (i + 1)
            for j in range(numOfPanelsInCol[i]):
                rect = Rect((0, 0), CHARACTER_SELECT_PANEL_SIZE)
                rect.centerx = colMid
                rect.top = (CHARACTER_SELECT_GROUP_FROM_TOP +
                            ((CHARACTER_SELECT_PANEL_SIZE[1] +
                              CHARACTER_SELECT_GROUP_SPACING) * j))

                self.characterPanels.append(CharacterPanel(rect, None))
Example #2
0
    def __init__(self, num):
        self.num = num

        numOfCols = int(math.ceil(float(num) / float(CHARACTER_SELECT_PANELS_PER_COL)))

        numOfPanelsInCol = []
        for i in range(numOfCols):
            numOfPanelsInCol.append(0)

        count = 0
        currCol = 0
        while count < num:
            numOfPanelsInCol[currCol] += 1
            count += 1
            currCol += 1
            if currCol == numOfCols:
                currCol = 0

        self.characterPanels = []
        for i in range(len(numOfPanelsInCol)):
            colMid = (SCREEN_SIZE[0] / (len(numOfPanelsInCol) + 1)) * (i + 1)
            for j in range(numOfPanelsInCol[i]):
                rect = Rect((0, 0), CHARACTER_SELECT_PANEL_SIZE)
                rect.centerx = colMid
                rect.top = CHARACTER_SELECT_GROUP_FROM_TOP + (
                    (CHARACTER_SELECT_PANEL_SIZE[1] + CHARACTER_SELECT_GROUP_SPACING) * j
                )

                self.characterPanels.append(CharacterPanel(rect, None))
Example #3
0
    def __init__(self, fade):
        super(Model, self).__init__()

        self.bg = pygame.Surface(SCREEN_SIZE)
        self.bg = scrollingbackground.ScrollingBackground(Rect((0, 0), SCREEN_SIZE), MAIN_MENU_BACKGROUND_IMAGE, [0.2, 0.5])
        
        tempRect = Rect( (50, 50), (200, 0) )
        menuOptions = ["Play Single Player", "Play via Network",
                       "Character Setup", "Options", "Credits", "Exit"]
        self.menu = minimenu.MiniMenu(tempRect, menuOptions,
                                           MAIN_MENU_FONT, MAIN_MENU_COLOR_ON,
                                           MAIN_MENU_COLOR_OFF,
                                           MAIN_MENU_COLOR_BG)
        self.menu.center(ENTIRE_SCREEN, False, True)
        self.menu.rect.left = MAIN_MENU_OFFSET_FROM_SIDE

        self.textMessages = [ ("Fimbulvetr", 3, ALMOST_BLACK, WHITE, 1, True),
                              ("War of the Great Winter", 2, ALMOST_BLACK, WHITE, 1, True)]
        self.textRects = []
        for i in self.textMessages:
            f = FONTS[i[1]]
            size = (SCREEN_SIZE[0], f.get_linesize() + f.get_height())
            tempRect = Rect( (0, 0), size )
            self.textRects.append(textrect.render_textrect(
                i[0], f, tempRect, i[2], i[3], i[4], i[5]))

        self.transSurface = pygame.Surface(SCREEN_SIZE)
        self.transSurface.fill((INTRO_MAX_FADE, INTRO_MAX_FADE, INTRO_MAX_FADE))
        self.transAlpha = boundint.BoundInt(0, 255, 255)
        self.transChecker = True
        self.transDirection = False

        if not fade:
            self.transAlpha.value = 0
            self.transChecker = False
Example #4
0
    def createButtons(self, itemWidth, marginWidth, spacingWidth, items,
                      itemMatrix):

        self.buttons = []
        for row in range(itemMatrix[1]):
            for col in range(itemMatrix[0]):
                itemIndex = (itemMatrix[0] * row) + col
                if (itemIndex >= len(items)):
                    return

                item = items[itemIndex]

                xPos = (itemWidth * col) + (spacingWidth * (col)) + marginWidth
                yPos = (itemWidth * row) + (spacingWidth * (row)) + marginWidth

                rect = Rect((xPos, yPos), (itemWidth, itemWidth))

                if (isinstance(item, mapchar.MapChar)):
                    images = []
                    icons = [item.images[0][0], item.images[1][0]]
                    for i in range(len(icons)):
                        icon = icons[i]
                        iconRect = Rect((0, 0), icon.get_size())
                        iconRect.centerx = (rect.width / 2)
                        iconRect.centery = (rect.height / 2)
                        surface = pygame.Surface(rect.size)
                        surface.fill(CHARACTER_SELECTION_DIALOG_BUTTON_COLOR)
                        surface.blit(icon, iconRect.topleft)
                        images.append(surface)

                self.buttons.append(
                    DetailDialogButton(rect, images[0], images[1], item))
Example #5
0
 def updateStructureCount(self, fortressCount, spireCount, altarCount):
     self.fortressCount = fortressCount
     self.spireCount = spireCount
     self.altarCount = altarCount
     
     self.structureCountPanel = pygame.Surface(self.structureCountPanelRect.size)
     self.structureCountPanel.fill(UNIT_HUD_COLORS[self.team])
     
     self.structureCountPanel.blit(self.fortressIcon, self.fortressIconRect.topleft)
     self.structureCountPanel.blit(self.spireIcon, self.spireIconRect.topleft)
     self.structureCountPanel.blit(self.altarIcon, self.altarIconRect.topleft)
     
     textRect = Rect((0,0), (100, STRUCTURE_COUNT_FONT.get_height() + 4))
     
     textSurface = textrect.render_textrect(" x" + str(self.fortressCount), STRUCTURE_COUNT_FONT, textRect,
                                            ALMOST_BLACK, BLACK, 0, True)
     textRect.bottomleft = self.fortressIconRect.bottomright
     self.structureCountPanel.blit(textSurface, textRect.topleft)
     
     
     textSurface = textrect.render_textrect(" x" + str(self.spireCount), STRUCTURE_COUNT_FONT, textRect,
                                            ALMOST_BLACK, BLACK, 0, True)
     textRect.left = self.spireIconRect.right - 3
     self.structureCountPanel.blit(textSurface, textRect.topleft)
     
     textSurface = textrect.render_textrect(" x" + str(self.altarCount), STRUCTURE_COUNT_FONT, textRect,
                                            ALMOST_BLACK, BLACK, 0, True)
     textRect.left = self.altarIconRect.right - 3
     self.structureCountPanel.blit(textSurface, textRect.topleft)
Example #6
0
    def changeVal(self, val=None):
        if not val is None:
            self.val = val
        self.panel = pygame.Surface(self.rect.size)
        self.panel.blit(self.backPanel, (0, 0))

        font = CHARACTER_SELECTION_FONT
        textHeight = font.get_linesize() + 2
        tempRect = Rect((0, 0), (self.rect.width, textHeight))

        text = textrect.render_textrect(
            self.name, font, tempRect, CHARACTER_SELECTION_FONT_COLOR, ALMOST_BLACK, 0, True
        )
        tempRect = Rect((0, 0), text.get_size())
        tempRect.top = (CHARACTER_SELECT_PANEL_SIZE[1] / 2) - (tempRect.height / 2)
        loc = (tempRect.left + CHARACTER_SELECT_PANEL_BORDER_WIDTH + CHARACTER_SELECT_PANEL_BORDER_SIZE, tempRect.top)
        self.panel.blit(text, loc)

        if self.ready:
            msg = "READY"
            color = CHARACTER_SELECTION_READY_COLOR
        else:
            msg = str(self.val) + "/" + str(self.maxVal)
            color = CHARACTER_SELECTION_FONT_COLOR
        text = textrect.render_textrect(msg, font, tempRect, color, ALMOST_BLACK, 2, True)
        loc = (tempRect.left - CHARACTER_SELECT_PANEL_BORDER_WIDTH - CHARACTER_SELECT_PANEL_BORDER_SIZE, tempRect.top)
        self.panel.blit(text, loc)
Example #7
0
    def changeVal(self, val=None):
        if not val is None:
            self.val = val
        self.panel = pygame.Surface(self.rect.size)
        self.panel.blit(self.backPanel, (0, 0))

        font = CHARACTER_SELECTION_FONT
        textHeight = font.get_linesize() + 2
        tempRect = Rect((0, 0), (self.rect.width, textHeight))

        text = textrect.render_textrect(self.name, font, tempRect,
                                        CHARACTER_SELECTION_FONT_COLOR,
                                        ALMOST_BLACK, 0, True)
        tempRect = Rect((0, 0), text.get_size())
        tempRect.top = ((CHARACTER_SELECT_PANEL_SIZE[1] / 2) -
                        (tempRect.height / 2))
        loc = (tempRect.left + CHARACTER_SELECT_PANEL_BORDER_WIDTH +
               CHARACTER_SELECT_PANEL_BORDER_SIZE, tempRect.top)
        self.panel.blit(text, loc)

        if self.ready:
            msg = "READY"
            color = CHARACTER_SELECTION_READY_COLOR
        else:
            msg = str(self.val) + "/" + str(self.maxVal)
            color = CHARACTER_SELECTION_FONT_COLOR
        text = textrect.render_textrect(msg, font, tempRect, color,
                                        ALMOST_BLACK, 2, True)
        loc = (tempRect.left - CHARACTER_SELECT_PANEL_BORDER_WIDTH -
               CHARACTER_SELECT_PANEL_BORDER_SIZE, tempRect.top)
        self.panel.blit(text, loc)
Example #8
0
 def createButtons(self, itemWidth, marginWidth, spacingWidth, items, itemMatrix):
     
     self.buttons = []
     for row in range(itemMatrix[1]):
         for col in range(itemMatrix[0]):
             itemIndex = (itemMatrix[0] * row) + col
             if (itemIndex >= len(items)):
                 return
             
             item = items[itemIndex]
             
             xPos = (itemWidth * col) + (spacingWidth * (col)) + marginWidth
             yPos = (itemWidth * row) + (spacingWidth * (row)) + marginWidth
             
             rect = Rect((xPos, yPos), (itemWidth, itemWidth))
             
             if (isinstance(item, mapchar.MapChar)):
                 images = []
                 icons = [item.images[0][0], item.images[1][0]]
                 for i in range(len(icons)):
                     icon = icons[i]
                     iconRect = Rect((0, 0), icon.get_size())
                     iconRect.centerx = (rect.width / 2)
                     iconRect.centery = (rect.height / 2)
                     surface = pygame.Surface(rect.size)
                     surface.fill(CHARACTER_SELECTION_DIALOG_BUTTON_COLOR)
                     surface.blit(icon, iconRect.topleft)
                     images.append(surface)
             
             self.buttons.append(DetailDialogButton(rect, images[0], images[1], item))
Example #9
0
    def drawZoomMap(self):

        #Draw winter to Map
        winterSize = self.mapWinterImage.get_size()
        dualMap = pygame.Surface(winterSize)
        dualMap.blit(self.mapWinterImage, (0, 0))

        #Create Green Overlay
        sizeX = winterSize[0] - self.fimbulvetrPos
        sizeY = winterSize[1]
        if sizeX > 0 and sizeY > 0:
            greenOverlay = pygame.Surface((sizeX, sizeY))
            greenOverlay.blit(self.mapOrigImage, (-self.fimbulvetrPos, 0))

            #Draw green to map
            dualMap.blit(greenOverlay, (self.fimbulvetrPos, 0))

        newSize = (int(self.map.mapSize[0] * self.zoomVal),
                   int(self.map.mapSize[1] * self.zoomVal))

        if not self.mapRect is None:
            diff = ((self.mapRect.width - newSize[0]),
                    (self.mapRect.height - newSize[1]))
            newPos = ((self.mapRect.left + (diff[0] / 2)),
                      (self.mapRect.top + (diff[1] / 2)))
            self.mapRect = Rect(newPos, newSize)
        else:
            self.mapRect = Rect((0, 0), newSize)
        self.mapImage = pygame.transform.scale(dualMap, newSize)
Example #10
0
    def setRect(self, pos, size):
        oldRect = Rect(pos, size)

        if self.isRight:
            xRef = oldRect.right
        else:
            xRef = oldRect.left

        self.rect = Rect((0, 0), self.image.get_size())
        self.rect.center = (xRef, oldRect.centery)
Example #11
0
    def __init__(self, inPos, inChar):
        super(MapCharacterBar, self).__init__()

        self.character = inChar

        self.createEffectIcons()

        team = self.character.team
        b = MAP_CHAR_BAR_BORDER
        p = MAP_CHAR_BAR_PADDING
        ps = MAP_CHAR_BAR_PADDING_SMALL
        height = (MAP_CHAR_BAR_PORTRAIT_SIZE[1] + (b * 2) + (p * 2))
        width = (MAP_CHAR_BAR_PORTRAIT_SIZE[0] + (b * 2) + (p * 4) +
                 MAP_CHAR_BAR_ENERGY_BAR_SIZE[0] + EFFECT_ICON_SIZE[0])

        self.rect = Rect(inPos, (width, height))

        staticSurface = pygame.Surface((width, height))
        staticSurface.fill(MAP_CHAR_BAR_COLOR_BORDER[team])
        staticSurface.fill(MAP_CHAR_BAR_COLOR_BG[team],
                           Rect((b, b), (width - (b * 2), height - (b * 2))))

        staticSurface = staticSurface.convert()

        self.staticSurfaces = []
        for i in range(2):
            self.staticSurfaces.append(copy.copy(staticSurface))

        colorSwap(self.staticSurfaces[1], MAP_CHAR_BAR_COLOR_BORDER[team],
                  MAP_CHAR_BAR_COLOR_SELECTED, 5)

        for s in self.staticSurfaces:
            s.blit(self.character.portrait, ((b + p), (b + p)))

        x = (b + (p * 2) + MAP_CHAR_BAR_PORTRAIT_SIZE[0])
        y = (b + p + MAP_CHAR_BAR_PORTRAIT_SIZE[1] -
             MAP_CHAR_BAR_ENERGY_BAR_SIZE[1])
        tempRect = Rect((x, y), MAP_CHAR_BAR_ENERGY_BAR_SIZE)
        self.superBar = energybar.EnergyBar(
            self.character.battleChar.superEnergy, tempRect,
            MAP_CHAR_BAR_ENERGY_BAR_BORDERS, SUPER_BAR_COLORS, 2)

        y = y - ps - MAP_CHAR_BAR_ENERGY_BAR_SIZE[1]
        tempRect = Rect((x, y), MAP_CHAR_BAR_ENERGY_BAR_SIZE)
        self.healthBar = energybar.EnergyBar(self.character.battleChar.hp,
                                             tempRect,
                                             MAP_CHAR_BAR_ENERGY_BAR_BORDERS,
                                             HEALTH_BAR_COLORS, 2,
                                             self.character.name, None, 3)

        self.setActive(False)

        self.pastHP = -1
        self.pastSuperEnergy = -1
Example #12
0
 def createGoPanel(self):
     if (self.playerNum == 0 and
         (not self.readyPanels[0] is None and self.readyPanels[0].data.value == True) and
         (not self.readyPanels[1] is None and self.readyPanels[1].data.value == True)):
         
         rect = Rect((0,0), GO_PANEL_SIZE)
         rect.centerx = SCREEN_SIZE[0] / 2
         rect.bottom = SCREEN_SIZE[1] - CHARACTER_SELECTION_PANEL_SPACING
         goPanel = Panel(0, True, rect)
         goPanel.setData(GoData())
         
         self.goPanel = goPanel
Example #13
0
    def createBars(self):
        self.bars = []
        p = self.players[self.cameraPlayer]
        q = self.players[self.reverse01(self.cameraPlayer)]

        x = BATTLE_PORTRAIT_SIZE[0] + HEALTH_BAR_OFFSET[
            0] + BATTLE_PORTRAIT_OFFSET[0]
        y = HEALTH_BAR_OFFSET[1]

        self.bars.append(
            energybar.EnergyBar(p.hp, Rect(
                (x, y), HEALTH_BAR_SIZE), HEALTH_BAR_BORDERS,
                                HEALTH_BAR_COLORS, HEALTH_BAR_PULSE, p.name))

        x = SCREEN_SIZE[0] - HEALTH_BAR_OFFSET[0] - HEALTH_BAR_SIZE[
            0] - BATTLE_PORTRAIT_SIZE[0] - BATTLE_PORTRAIT_OFFSET[0]
        y = HEALTH_BAR_OFFSET[1]

        self.bars.append(
            energybar.EnergyBar(q.hp, Rect((x, y), HEALTH_BAR_SIZE),
                                HEALTH_BAR_BORDERS, HEALTH_BAR_COLORS,
                                HEALTH_BAR_PULSE, q.name, None, 2, False))

        x = (SCREEN_SIZE[0] / 2) - (RETREAT_BAR_SIZE[0] / 2)
        y = HEALTH_BAR_OFFSET[1]

        self.retreatBar = energybar.EnergyBar(self.retreatProhibitTime,
                                              Rect((x, y), RETREAT_BAR_SIZE),
                                              RETREAT_BAR_BORDERS,
                                              RETREAT_BAR_COLORS, 5, "Battle",
                                              None, 1)
        self.bars.append(self.retreatBar)

        x = BATTLE_PORTRAIT_SIZE[0] + HEALTH_BAR_OFFSET[
            0] + BATTLE_PORTRAIT_OFFSET[0]
        y = HEALTH_BAR_OFFSET[1] + HEALTH_BAR_SIZE[1] + SPECIAL_BAR_OFFSET
        if isinstance(p, hare.Hare):
            self.bars.append(
                energybar.EnergyBar(p.hareEnergy, Rect(
                    (x, y), SPECIAL_BAR_SIZE), SPECIAL_BAR_BORDERS,
                                    SPECIAL_BAR_COLORS, SPECIAL_BAR_PULSE,
                                    HARE_ENERGY_NAME, HARE_ENERGY_USAGE))

        if isinstance(p, cat.Cat):
            self.catBar = energybar.EnergyBar(p.catEnergy,
                                              Rect((x, y), SPECIAL_BAR_SIZE),
                                              SPECIAL_BAR_BORDERS,
                                              SPECIAL_BAR_COLORS,
                                              SPECIAL_BAR_PULSE,
                                              CAT_ENERGY_NAME,
                                              CAT_ENERGY_MAX + 1)
            self.bars.append(self.catBar)
Example #14
0
    def createGoPanel(self):
        if (self.playerNum == 0
                and (not self.readyPanels[0] is None
                     and self.readyPanels[0].data.value == True)
                and (not self.readyPanels[1] is None
                     and self.readyPanels[1].data.value == True)):

            rect = Rect((0, 0), GO_PANEL_SIZE)
            rect.centerx = SCREEN_SIZE[0] / 2
            rect.bottom = SCREEN_SIZE[1] - CHARACTER_SELECTION_PANEL_SPACING
            goPanel = Panel(0, True, rect)
            goPanel.setData(GoData())

            self.goPanel = goPanel
Example #15
0
 def createTriggerArea(self, zoom):
     r = int(self.triggerSize * zoom)
     d = int(r * 2)
     self.triggerArea = pygame.Surface((d, d), SRCALPHA)
     self.triggerArea.fill((0, 0, 0, 0))
     pygame.draw.circle(self.triggerArea, self.triggerColor, (r, r), r)
     self.triggerRect = Rect((0, 0), (d, d))
Example #16
0
class PageArrow(object):
    def __init__(self, isRight, page):
        self.image = INTERFACE_GRAPHICS[4].copy()
        self.isRight = isRight

        if not isRight:
            self.image = pygame.transform.flip(self.image, True, False)

        self.visible = (page.maximum > 0)

    def setRect(self, pos, size):
        oldRect = Rect(pos, size)
        
        if self.isRight:
            xRef = oldRect.right
        else:
            xRef = oldRect.left

        self.rect = Rect((0, 0), self.image.get_size())
        self.rect.center = (xRef, oldRect.centery)

    def draw(self, screen):
        if self.visible:
            screen.blit(self.image, self.rect.topleft)

    def mouseIsOver(self, mousePos):
        if not self.visible:
            return False

        return self.rect.collidepoint(mousePos)
Example #17
0
    def __init__(self, inRect, options, inFont, colorOn, colorOff, colorBG):

        self.rectSingle = inRect
        self.options = options
        if len(options) > 0:
            self.selection = boundint.BoundInt(1, len(options), 1, True)
        else:
            self.selection = None
        self.font = inFont

        lineSize = self.font.get_height() + self.font.get_linesize()
        if self.rectSingle.height < lineSize:
            self.rectSingle.height = lineSize

        h = self.rectSingle.height * len(self.options)
        if h <= 0:
            h = 1
        self.rect = Rect(self.rectSingle.topleft, (self.rectSingle.width, h))

        self.colorOn = colorOn
        self.colorOff = colorOff
        self.colorBG = colorBG

        self.noSelection = True

        self.slate = pygame.Surface((self.rect.width, self.rect.height))
        self.slate.fill(colorBG)

        self.update()
Example #18
0
    def __init__(self):
        super(Model, self).__init__()
        self.fadeSurface = pygame.Surface(SCREEN_SIZE)
        self.fadeSurfaceColor = []
        for i in range(3):
            self.fadeSurfaceColor.append(
                boundint.BoundInt(0, INTRO_MAX_FADE, 0))

        self.transSurface = pygame.Surface(SCREEN_SIZE)
        self.transSurface.fill(
            (INTRO_MAX_FADE, INTRO_MAX_FADE, INTRO_MAX_FADE))
        self.transAlpha = boundint.BoundInt(0, 255, 255)
        self.centerTextPos = (0, SCREEN_SIZE[1] / 2)
        self.stage = 0
        self.ticker = 0

        self.textMessages = [("Games from Beyond the Farth", 2, ALMOST_BLACK,
                              WHITE, 1, True)]
        self.textRects = []
        for i in self.textMessages:
            f = FONTS[i[1]]
            size = (SCREEN_SIZE[0], f.get_linesize() + f.get_height())
            tempRect = Rect((0, 0), size)
            self.textRects.append(
                textrect.render_textrect(i[0], f, tempRect, i[2], i[3], i[4],
                                         i[5]))
Example #19
0
class PageArrow(object):
    def __init__(self, isRight, page):
        self.image = INTERFACE_GRAPHICS[4].copy()
        self.isRight = isRight

        if not isRight:
            self.image = pygame.transform.flip(self.image, True, False)

        self.visible = (page.maximum > 0)

    def setRect(self, pos, size):
        oldRect = Rect(pos, size)

        if self.isRight:
            xRef = oldRect.right
        else:
            xRef = oldRect.left

        self.rect = Rect((0, 0), self.image.get_size())
        self.rect.center = (xRef, oldRect.centery)

    def draw(self, screen):
        if self.visible:
            screen.blit(self.image, self.rect.topleft)

    def mouseIsOver(self, mousePos):
        if not self.visible:
            return False

        return self.rect.collidepoint(mousePos)
Example #20
0
    def __init__(self, inRect, inImage):

        self.mainRect = inRect
        self.mainPane = pygame.Surface(
            (self.mainRect.width, self.mainRect.height))
        pattern = inImage

        imageSize = inImage.get_size()

        tempFloat = float(float(inRect.width) / float(imageSize[0]))
        repeatX = int(math.ceil(tempFloat))
        tempFloat = float(float(inRect.height) / float(imageSize[1]))
        repeatY = int(math.ceil(tempFloat))

        sizeX = repeatX * imageSize[0]
        sizeY = repeatY * imageSize[0]
        self.subRect = Rect((0, 0), (sizeX, sizeY))
        self.subPane = pygame.Surface(
            (self.subRect.width, self.subRect.height))

        for x in range(repeatX):
            for y in range(repeatY):
                self.subPane.blit(pattern,
                                  ((x * imageSize[0]), (y * imageSize[1])))

        self.mainPane.blit(self.subPane, self.subRect.topleft)
Example #21
0
    def makeMenu(self):
        if self.stage == 0:
            if self.isSelectionScreen:
                menuOptions = ["New", "Delete", "Change Power", "Select"]
            else:
                menuOptions = ["New", "Delete", "Change Power", "Done"]

        elif self.stage == 1:
            menuOptions = []
            self.getSpeciesList()
            for s in self.currSpeciesList:
                menuOptions.append(s.speciesName)

        elif self.stage == 2:
            menuOptions = []
            for i in self.characterToDisplay.superMoves:
                menuOptions.append(i.name)

        elif self.stage == 101:
            menuOptions = ["Nevermind...", "Delete"]

        tempRect = Rect((50, 50), (200, 0))
        self.menu = minimenu.MiniMenu(tempRect, menuOptions, CHAR_EDITOR_FONT,
                                      CHAR_EDITOR_COLOR_ON,
                                      CHAR_EDITOR_COLOR_OFF,
                                      CHAR_EDITOR_COLOR_BG)
        self.menu.rect.center = (SCREEN_SIZE[0] / 2, SCREEN_SIZE[1] / 2)
Example #22
0
    def setCharacter(self, c):
        self.character = c

        self.panel = pygame.Surface(CHARACTER_SELECT_PANEL_SIZE)
        self.panel.blit(self.backPanel, (0, 0))

        if not self.character is None:
            font = CHARACTER_SELECTION_FONT
            msg = self.character.name
            textHeight = font.get_linesize() + 2
            tempRect = Rect((0, 0), (CHARACTER_SELECT_PANEL_SIZE[0], textHeight))

            text = textrect.render_textrect(msg, font, tempRect, CHARACTER_SELECTION_FONT_COLOR, ALMOST_BLACK, 1, True)
            tempRect = Rect((0, 0), text.get_size())
            tempRect.left = (CHARACTER_SELECT_PANEL_SIZE[0] / 2) - (tempRect.width / 2)
            tempRect.top = (CHARACTER_SELECT_PANEL_SIZE[1] / 2) - (tempRect.height / 2)
            self.panel.blit(text, tempRect.topleft)
Example #23
0
def printText(screen, mousePos):
    pos = getZoomPos(mousePos)
    pixelPos = posRelatedToAnchor(pos)
    text = textrect.render_textrect(
        str(pixelPos), FONTS[0], Rect(
            (0, 0), (SCREEN_SIZE[0], SCREEN_SIZE[1])), (250, 250, 250),
        (5, 5, 5), 0, True)
    screen.blit(text, (mousePos[0] + 15, mousePos[1] - 10))
Example #24
0
 def __init__(self, team, waypoint=False):
     if waypoint:
         self.image = INTERFACE_GRAPHICS[11]
     else:
         self.image = INTERFACE_GRAPHICS[2]
         
     colorSwap(self.image, (250, 250, 250, 255), TOKEN_BORDER_OFF[team], 200)
         
     self.rect = Rect((0, 0), self.image.get_size())
Example #25
0
    def setCameraPlayer(self, c):
        if (c >= 0) and (c <= 1):
            self.cameraPlayer = c
        self.createBars()

        self.youIconImage = INTERFACE_GRAPHICS[18]
        colorSwap(self.youIconImage, (215, 215, 215, 255),
                  TOKEN_BORDER_HIGHLIGHTED[self.cameraPlayer], 200)
        self.youIconRect = Rect((0, 0), self.youIconImage.get_size())
Example #26
0
    def getBoxAbsRect(self, box, inOffset):
        if self.facingRight:
            boxPos = box.rect.topleft
        else:
            boxPos = flipRect(box.rect)

        topleft = add_points(add_points(self.preciseLoc, boxPos), inOffset)

        return Rect(topleft, box.rect.size)
Example #27
0
 def __init__(self):
     super(Model, self).__init__()
     tempRect = Rect( (50, 50), (200, 0) )
     menuOptions = ["Combat Debug", "Map Debug", "Character Select Debug",
                    "Play Game Normally", "Exit"]
     self.debugMenu = minimenu.MiniMenu(tempRect, menuOptions,
                                        MINIMENU_FONT, (250, 250, 250),
                                        (125, 125, 125), (15, 15, 15))
     self.debugMenu.center(ENTIRE_SCREEN, True, True)
Example #28
0
    def __init__(self, time):
        self.time = time
        self.tick = boundint.BoundInt(0, FRAME_RATE, 0, True)

        size = (SCREEN_SIZE[0], COUNTDOWN_FONT.get_linesize() + 4)
        pos = (0, (SCREEN_SIZE[1] / 2) - (size[1] / 2) - 15)
        self.rect = Rect(pos, size)
        self.startFlag = False

        self.updateImage()
Example #29
0
    def buildHurtboxes(self, data):
        self.hurtboxes = []

        for d in data:
            topleft = (d[0], d[1])
            width = d[2] - d[0]
            height = d[3] - d[1]
            size = (width, height)
            rect = Rect(topleft, size)
            self.hurtboxes.append(hurtbox.Hurtbox(rect))
Example #30
0
    def createDescription(self, name=None, desc=None):
        if name is None:
            self.descSurface = None
        else:
            text = str(name + "\n\n" + desc)

            self.descSurface = textrect.render_textrect(
                text, CHAR_EDITOR_FONT,
                Rect(self.charMenu.rect.topleft, self.idealSize),
                CHAR_EDITOR_COLOR_OFF, CHAR_EDITOR_BLACK_PANEL_COLOR)
Example #31
0
    def __init__(self, title, banList=[], ip=False, maxLength=None):
        super(Model, self).__init__()

        if maxLength is None:
            self.maxLength = TEXT_ENTRY_LENGTH_MAX
        else:
            self.maxLength = maxLength

        self.ipCheck = ip
        self.font = TEXT_ENTRY_FONT
        self.response = []
        self.banList = banList

        size = (TEXT_ENTRY_LINE_WIDTH + (TEXT_ENTRY_BORDER_SIZE * 2),
                self.font.get_linesize() + self.font.get_height() +
                (TEXT_ENTRY_BORDER_SIZE * 2))
        pos = [0, 0]
        for i in range(2):
            pos[i] = (SCREEN_SIZE[i] / 2) - (size[i] / 2)
        self.rect = Rect(pos, size)

        self.base = pygame.Surface(size)
        self.base.fill(BLACK)
        pygame.draw.rect(self.base, WHITE, (0, 0, size[0], size[1]), 1)
        pygame.draw.rect(
            self.base, WHITE,
            (0 + TEXT_ENTRY_BORDER_SIZE, 0 + TEXT_ENTRY_BORDER_SIZE, size[0] -
             (TEXT_ENTRY_BORDER_SIZE * 2), size[1] -
             (TEXT_ENTRY_BORDER_SIZE * 2)), 1)

        self.updateImage()

        size = (self.rect.width,
                self.font.get_linesize() + self.font.get_height())
        self.titleRect = Rect((0, 0), size)
        self.titleRect.bottom = self.rect.top
        self.titleRect.left = self.rect.left
        temp = textrect.render_textrect(title, self.font, self.titleRect,
                                        WHITE, BLACK, 1)
        self.titlePanel = pygame.Surface(size)
        self.titlePanel.blit(temp,
                             (0,
                              (size[1] / 2) - (self.font.get_linesize() / 2)))
Example #32
0
    def setRect(self, pos, size):
        oldRect = Rect(pos, size)
        
        if self.isRight:
            xRef = oldRect.right
        else:
            xRef = oldRect.left

        self.rect = Rect((0, 0), self.image.get_size())
        self.rect.center = (xRef, oldRect.centery)
Example #33
0
    def __init__(self, image, pos, anchor, scale):

        self.image = image
        self.scale = scale

        self.rect = Rect(pos, image.get_size())
        self.rect.left -= anchor[0]
        self.rect.top -= anchor[1]
        self.anchor = anchor

        print self.rect.topleft
Example #34
0
 def createSuperIcons(self):
     self.superIcons = []
     
     x = self.iconRect.left
     y = self.iconRect.top + self.iconRect.height + UNIT_HUD_BORDER_WIDTH
     
     for c in self.characters:
         icon = battle_v.SuperIcon(Rect((x, y), BATTLE_SUPER_ICON_SIZE),
                                   c.battleChar.getSuperIcon(), c.battleChar.superEnergy)
         
         self.superIcons.append(icon)
Example #35
0
    def setButton(self, val):
        if not (val == self.enabled):
            self.enabled = val

            self.panel = pygame.Surface(self.rect.size)
            self.panel.blit(self.backPanel, (0, 0))

            if self.enabled:
                color = CHARACTER_SELECTION_BUTTON_COLOR_ON
            else:
                color = CHARACTER_SELECTION_BUTTON_COLOR_OFF

            font = CHARACTER_SELECTION_FONT
            textHeight = font.get_linesize() + 2
            tempRect = Rect((0, 0), (self.rect.width, textHeight))

            text = textrect.render_textrect(self.msg, font, tempRect, color, ALMOST_BLACK, 1, True)
            tempRect = Rect((0, 0), text.get_size())
            tempRect.top = (CHARACTER_SELECT_PANEL_SIZE[1] / 2) - (tempRect.height / 2)
            self.panel.blit(text, tempRect.topleft)
Example #36
0
def printList(screen):
    global boxList

    for i, b in enumerate(boxList):
        pos = (0, i * 15)
        line = (str(posRelatedToAnchor(b[1].topleft)) + " - " +
                str(posRelatedToAnchor(b[1].bottomright)))
        text = textrect.render_textrect(
            line, FONTS[0], Rect((0, 0), (SCREEN_SIZE[0], SCREEN_SIZE[1])),
            (250, 250, 250), (5, 5, 5), 0, True)
        screen.blit(text, pos)
Example #37
0
    def buildIdealSize(self):
        tempList = []
        for i in range(CHAR_EDITOR_NUM_PER_PAGE):
            tempList.append("!")

        tempRect = Rect((50, 50), (200, 0))
        temp = minimenu.MiniMenu(tempRect, tempList, CHAR_EDITOR_FONT,
                                 CHAR_EDITOR_COLOR_ON, CHAR_EDITOR_COLOR_OFF,
                                 CHAR_EDITOR_BLACK_PANEL_COLOR)

        return temp.rect.size
Example #38
0
 def setImage(self, inImage, o):
     size = inImage.get_size()
     
     if self.facingRight:
         offset = o
         self.image = inImage
     else:
         offset = (-o[0] + size[0], o[1])
         self.image = pygame.transform.flip(inImage, True, False)
     
     self.offset = offset
     self.rect = Rect(self.getRectPos(), size)
Example #39
0
 def selectMap(self, map, wasRandom):
     
     self.mapPanel.setData(MapData(map, wasRandom))
     
     numOfCharacterSlots = 0
     if not map is None:
         numOfCharacterSlots = len(map.startingPoints[0])
         
     self.characterPanels = []
     
     for i in range(2):
         xMid = (SCREEN_SIZE[0] / 4) * (1 + (i * 2))
         
         yMid = SCREEN_SIZE[1] / 2
         if (numOfCharacterSlots % 2 == 0):
             numToDisplaceFromCenter = (numOfCharacterSlots / 2) - 1
             yMid -= (CHARACTER_SELECTION_PANEL_SPACING / 2) + (CHARACTER_SELECTION_PANEL_SIZE[1] / 2)
         else:
             numToDisplaceFromCenter = int(numOfCharacterSlots / 2)
             
         yMid -= (CHARACTER_SELECTION_PANEL_SPACING + CHARACTER_SELECTION_PANEL_SIZE[1]) * numToDisplaceFromCenter
             
         
         for j in range(numOfCharacterSlots):
             rect = Rect((0,0), CHARACTER_SELECTION_PANEL_SIZE)
             rect.centerx = xMid
             rect.centery = yMid + ((CHARACTER_SELECTION_PANEL_SPACING + CHARACTER_SELECTION_PANEL_SIZE[1]) * j)
             self.characterPanels.append(Panel(i, (self.playerNum == i), rect))
             
         rect = rect = Rect((0,0), READY_PANEL_SIZE)
         rect.centerx = xMid
         rect.bottom = SCREEN_SIZE[1] - CHARACTER_SELECTION_PANEL_SPACING
         readyPanel = Panel(i, (self.playerNum == i), rect)
         readyPanel.faceUp = True
         readyPanel.setData(ReadyData(False))
         self.readyPanels[i] = readyPanel
         
     self.subScreen = 0
Example #40
0
 def __init__(self, isHost):
     super(Model, self).__init__()
     
     self.bgs = [scrollingbackground.ScrollingBackground(Rect((0, 0),
                                                              SCREEN_SIZE), CHARACTER_SELECT_BG_SKY, [0, 0]),
                 
                 scrollingbackground.ScrollingBackground(Rect((0, SCREEN_SIZE[1] - CHARACTER_SELECT_BG_MOUNTAINS_FAR.get_size()[1] - 70),
                                                              SCREEN_SIZE), CHARACTER_SELECT_BG_MOUNTAINS_FAR, [-0.3, 0]),
                 
                 scrollingbackground.ScrollingBackground(Rect((0, SCREEN_SIZE[1] - CHARACTER_SELECT_BG_MOUNTAINS_NEAR.get_size()[1]),
                                                              SCREEN_SIZE), CHARACTER_SELECT_BG_MOUNTAINS_NEAR, [-0.8, 0])
                 ]
     
     self.starting = False
     self.map = None
     
     self.netMessage = None
     
     self.subScreen = 0
     
     if isHost:
         self.playerNum = 0
     else:
         self.playerNum = 1
         
     #Create Map-selection Panel
     rect = Rect((0,0), CHARACTER_SELECTION_PANEL_SIZE)
     rect.centerx = SCREEN_SIZE[0] / 2
     rect.top = CHARACTER_SELECTION_PANEL_SPACING
     self.mapPanel = Panel(0, isHost, rect)
     
     self.characterPanels = []
     
     tempRect = Rect( (50, 50), (200, 0) )
     menuOptions = []
     for map in gamemap.getMapList():
         menuOptions.append(map.name + " (" + str(len(map.startingPoints[0])) + ")")
     menuOptions.append("<RANDOM>")
         
     self.mapMenu = minimenu.MiniMenu(tempRect, menuOptions,
                                      MAIN_MENU_FONT, MAIN_MENU_COLOR_ON,
                                      MAIN_MENU_COLOR_OFF,
                                      MAIN_MENU_COLOR_BG)
     self.mapMenu.center(ENTIRE_SCREEN, True, True)
     
     
     
     #Create Species Selection Menu
     speciesClasses = [(mapchar.Hare, hare.Hare),
                       (mapchar.Cat, cat.Cat)]
     speciesList = []
     for speciesClassGroup in speciesClasses:
         mapClass = speciesClassGroup[0]
         battleClass = speciesClassGroup[1]
         speciesList.append(mapClass(self.playerNum, battleClass()))
         
     self.speciesDialog = DetailDialog(SPECIES_SELECTION_DIALOG_SLOT_SIZE, SPECIES_SELECTION_DIALOG_MARGIN,
                                       SPECIES_SELECTION_DIALOG_SPACING, speciesList, [4, 2] )
                 
     self.currCharacterPanel = None
     
     self.readyPanels = [None, None]
     
     self.goPanel = None
Example #41
0
 def update(self):
     if (self.redraw):
         
         #Draw Panel Surface
         if (self.data is None or (isinstance(self.data, ReadyData) and self.data.value == False)):
             paletteBase = CHARACTER_SELECT_PANEL_BASE_COLORS_OFF
             paletteDecor = CHARACTER_SELECT_PANEL_DECOR_COLORS_OFF
         else:
             paletteBase = CHARACTER_SELECT_PANEL_BASE_COLORS_ON
             paletteDecor = CHARACTER_SELECT_PANEL_DECOR_COLORS_ON
             
         colorBase = paletteBase[self.team]
         colorDecor = paletteDecor[self.team]
         
         self.image = pygame.Surface(self.rect.size)
         self.image.fill(colorBase)
         
         showFront = self.faceUp or self.isOwner
         
         if (showFront):
             decorMargin = CHARACTER_SELECT_PANEL_FACE_DECOR_MARGIN
             decorWidth = CHARACTER_SELECT_PANEL_FACE_DECOR_WIDTH
         else:
             decorMargin = CHARACTER_SELECT_PANEL_BACK_DECOR_MARGIN
             decorWidth = CHARACTER_SELECT_PANEL_BACK_DECOR_WIDTH
             
         decorOuter = pygame.Surface((self.rect.width - (decorMargin * 2), self.rect.height - (decorMargin * 2)))
         decorOuter.fill(colorDecor)
             
         decorInner = pygame.Surface((decorOuter.get_size()[0] - (decorWidth * 2),
                                      decorOuter.get_size()[1] - (decorWidth * 2)))
         decorInner.fill(colorBase)
         
         if (not showFront):
             margins = CHARACTER_SELECT_PANEL_BACK_CIRCLE_MARGINS
             ovalRect = Rect((margins[0], margins[1]),
                             (decorInner.get_size()[0] - (margins[0] * 2),
                              decorInner.get_size()[1] - (margins[1] * 2)))
             pygame.draw.ellipse(decorInner, colorDecor, ovalRect)
         
         decorOuter.blit(decorInner, (decorWidth, decorWidth))
         self.image.blit(decorOuter, (decorMargin, decorMargin))
         
         
         #Fill Data
         fillRect = Rect(((decorWidth + decorMargin), (decorWidth + decorMargin)), decorInner.get_size())
         if isinstance(self.data, mapchar.MapChar):
             
             font = CHARACTER_SELECTION_CAPTION_FONT
             textHeight = font.get_linesize() + 2
             tRect = Rect((0,0), (fillRect.width - 10, textHeight))
             tRect.centerx = fillRect.centerx
             tRect.centery = fillRect.centery
             text = textrect.render_textrect(self.data.name, font, tRect,
                                             CHARACTER_SELECTION_FONT_COLOR,
                                             ALMOST_BLACK, 0, True)
             self.image.blit(text, tRect.topleft)
             
             speciesImage = self.data.getSmallImage()
             speciesRect = Rect((0, 0), speciesImage.get_size())
             speciesRect.right = tRect.right
             speciesRect.centery = self.rect.height / 2
             
             self.image.blit(speciesImage, speciesRect.topleft)
             
             
         elif isinstance(self.data, MapData):
             
             font = CHARACTER_SELECTION_CAPTION_FONT
             textHeight = font.get_linesize() + 2
             tRect = Rect((0,0), (fillRect.width - 10, textHeight))
             tRect.centerx = fillRect.centerx
             tRect.centery = fillRect.centery
             text = textrect.render_textrect(self.data.map.name, font, tRect,
                                             CHARACTER_SELECTION_FONT_COLOR,
                                             ALMOST_BLACK, 0, True)
             self.image.blit(text, tRect.topleft)
             
             if self.data.wasRandom:
                 image = RANDOM_ICON
                 rect = Rect((0,0), image.get_size())
                 rect.right = fillRect.right
                 rect.centery = fillRect.centery
                 self.image.blit(image, rect.topleft)
                 
         elif isinstance(self.data, ReadyData):
             
             font = CHARACTER_SELECTION_CAPTION_FONT
             font = CHARACTER_SELECTION_CAPTION_FONT
             textHeight = font.get_linesize() + 2
             tRect = Rect((0,0), (fillRect.width - 10, textHeight))
             tRect.centerx = fillRect.centerx
             tRect.centery = fillRect.centery
             if self.data.value:
                 color = READY_PANEL_FONT_COLOR_TRUE
                 text = "READY"
             else:
                 color = READY_PANEL_FONT_COLOR_FALSE
                 text = "PREPARING..."
             text = textrect.render_textrect(text, font, tRect,
                                             color, ALMOST_BLACK, 1, True)
             self.image.blit(text, tRect.topleft)
             
         if isinstance(self.data, GoData):
             
             font = CHARACTER_SELECTION_CAPTION_FONT
             font = CHARACTER_SELECTION_CAPTION_FONT
             textHeight = font.get_linesize() + 2
             tRect = Rect((0,0), (fillRect.width - 10, textHeight))
             tRect.centerx = fillRect.centerx
             tRect.centery = fillRect.centery
             color = READY_PANEL_FONT_COLOR_TRUE
             text = "GO!"
             text = textrect.render_textrect(text, font, tRect,
                                             color, ALMOST_BLACK, 1, True)
             self.image.blit(text, tRect.topleft)
         
         
         self.redraw = False
Example #42
0
    def __init__(self, theMap, isHost):
        super(Model, self).__init__()

        self.theMap = theMap

        self.openEditor = False
        self.sendNetMessage = False
        self.starting = False

        self.bg = pygame.Surface(SCREEN_SIZE)
        self.bg.fill(CHARACTER_SELECT_BG_COLOR)

        self.group = CharacterPanelGroup(self.theMap.numOfCharactersPerTeam())
        self.currSelected = None

        x = (CHARACTER_SELECT_PANEL_SELECTION_BORDER_WIDTH * 2) + CHARACTER_SELECT_PANEL_SIZE[0]
        y = (CHARACTER_SELECT_PANEL_SELECTION_BORDER_WIDTH * 2) + CHARACTER_SELECT_PANEL_SIZE[1]

        self.selectionBorder = pygame.Surface((x, y))
        self.selectionBorder.fill(CHARACTER_SELECT_PANEL_SELECTION_BORDER_COLOR)

        tempRect = Rect((0, 0), CHARACTER_SELECT_PLAYER_SIZE)
        tempRect.bottom = SCREEN_SIZE[1] - CHARACTER_SELECT_GROUP_FROM_TOP
        tempRect.centerx = SCREEN_SIZE[0] / 2
        self.clientPanel = PlayerPanel(tempRect, "Client", self.group.num)

        tempRect = Rect((0, 0), CHARACTER_SELECT_PLAYER_SIZE)
        tempRect.bottom = self.clientPanel.rect.top - CHARACTER_SELECT_GROUP_SPACING
        tempRect.centerx = SCREEN_SIZE[0] / 2
        self.hostPanel = PlayerPanel(tempRect, "Host", self.group.num)

        if isHost:
            self.myPanel = self.hostPanel
            self.theirPanel = self.clientPanel
        else:
            self.myPanel = self.clientPanel
            self.theirPanel = self.hostPanel

        tempRect = Rect((0, 0), CHARACTER_SELECT_BUTTON_SIZE)
        tempRect.left = self.myPanel.rect.right + CHARACTER_SELECT_GROUP_SPACING
        tempRect.top = self.myPanel.rect.top
        self.readyButton = Button(tempRect, "Ready")

        if isHost:
            tempRect = Rect((0, 0), CHARACTER_SELECT_BUTTON_SIZE)
            tempRect.left = self.theirPanel.rect.right + CHARACTER_SELECT_GROUP_SPACING
            tempRect.top = self.theirPanel.rect.top
            self.startButton = Button(tempRect, "Start")
        else:
            self.startButton = None

        x = (CHARACTER_SELECT_PANEL_SELECTION_BORDER_WIDTH * 2) + CHARACTER_SELECT_BUTTON_SIZE[0]
        y = (CHARACTER_SELECT_PANEL_SELECTION_BORDER_WIDTH * 2) + CHARACTER_SELECT_BUTTON_SIZE[1]
        self.selectionBorderButton = pygame.Surface((x, y))
        self.selectionBorderButton.fill(CHARACTER_SELECT_PANEL_SELECTION_BORDER_COLOR)

        self.loadingImage = INTERFACE_GRAPHICS[9]
        self.loadingRect = Rect((0, 0), self.loadingImage.get_size())
        self.loadingRect.center = (SCREEN_SIZE[0] / 2, SCREEN_SIZE[1] / 2)
Example #43
0
    def __init__(self, inChars, terrainLeft, terrainRight):
        super(Model, self).__init__()
        self.rect = Rect((0, 0), BATTLE_ARENA_SIZE)

        self.testBool = False
        self.testBool2 = False
        
        self.players = inChars
        for p in self.players:
            p.beginBattle()
            pos = (self.rect.centerx,
                   self.rect.height - BATTLE_AREA_FLOOR_HEIGHT)
            self.players[0].setLoc(add_points(pos,
                            ((-BATTLE_PLAYER_START_DISTANCE / 2), 0)))
            self.players[0].facingRight = True
            self.players[1].setLoc(add_points(pos,
                            ((BATTLE_PLAYER_START_DISTANCE / 2), 0)))
            self.players[1].facingRight = False
            
        self.keys = [[False, False, False, False, False, False, False, False, False],
                     [False, False, False, False, False, False, False, False, False]]
        self.keysNow = [[0, 0, 0, 0, 0, 0, 0, 0, 0],
                        [0, 0, 0, 0, 0, 0, 0, 0, 0]]

        self.frameByFrame = [0, 0]
        
        self.returnCode = [0, 0]
        self.projectiles = []
        self.retreatProhibitTime = boundint.BoundInt(0, RETREAT_PROHIBIT_TIME,
                                                     RETREAT_PROHIBIT_TIME)
        self.retreatPhase = 0
        
        self.cameraPlayer = 0
        self.netPlayer = 0
        self.catBar = None
        self.createBars()
        self.resetHitMemory()

        self.endingVal = -1
        self.endingValTick = 0

        self.fx = []

        self.platforms = getPlatforms(terrainLeft, terrainRight)

        self.countdown = countdown.Countdown(BATTLE_COUNTDOWN_LENGTH)
        self.createEndingText()
        
        self.damageTagRects = []
        self.damagePercentRects = []
        for i in range(2):
            rect = Rect((0, 0), (80, 100))
            if (i == 0):
                rect.left = 0
            else:
                rect.right = SCREEN_SIZE[0]
            rect.top = SCREEN_SIZE[1] - 55
            self.damageTagRects.append(rect)
            
            rect2 = Rect((0, 0), (80, 100))
            if (i == 0):
                rect2.left = 0
            else:
                rect2.right = SCREEN_SIZE[0]
            rect2.top = rect.top + 18
            self.damagePercentRects.append(rect2)
            
        self.damageTag = textrect.render_textrect("Strength", STRUCTURE_COUNT_FONT, self.damageTagRects[0],
                                                  ALMOST_BLACK, BLACK, 1, True)