Exemple #1
0
class Grid:

    surface = None

    def __init__(self, width, height, spacing=20):
        self.width = width
        self.height = height
        self.spacing = spacing
        self.initializeSurface()

    def initializeSurface(self):
        self.surface = Surface((self.width, self.height), flags=HWSURFACE | SRCALPHA)
        self.surface.fill(Color(0, 0, 0, 0))

        for i in range(0, self.width, self.spacing):
            pygame.draw.line(self.surface, Color(0, 0, 0, 255), (i, 0), (i, self.height))

        for i in range(0, self.height, self.spacing):
            pygame.draw.line(self.surface, Color(0, 0, 0, 255), (0, i), (self.width, i))

        pygame.draw.line(self.surface,
                Color(0, 0, 0, 255),
                (self.width - 1, 0),
                (self.width - 1, self.height))
        pygame.draw.line(self.surface, Color(0, 0, 0, 255),
                (0, self.height - 1), (self.width, self.height - 1))

    def render(self, screen):
        screen.blit(self.surface, (0, 0))
        pass
Exemple #2
0
def pygame_loop(surface_: surface.Surface,
                clock: time.Clock,
                update: bool = True) -> None:
    global num_of_iterations

    clock.tick(FPS)
    if update:
        num_of_iterations += 1
        display.set_caption(
            f"Diffusion Limited Aggregation - {BETA} - {num_of_iterations}")
    for event in events.get():
        if event.type == pygame.QUIT:
            at_end()

    keys = pygame.key.get_pressed()
    if keys[pygame.K_ESCAPE]:
        at_end()

    if update:
        p.update()

    surface_.fill(BLACK)

    render(surface_)

    display.flip()
Exemple #3
0
class Panel(Clickable):
    def __init__(self, x, y, w, h, color=0x000000):
        self.items = []
        self.clickables = []
        self.surface = Surface((w, h))
        self.visible = True
        self.x = x
        self.y = y
        self.color = color

    def draw(self, screen):
        if self.visible:
            self.surface.fill(self.color)
            for item in self.items:
                item.draw(self.surface)
            screen.blit(self.surface, (self.x, self.y))

    def add(self, item):
        self.items.append(item)
        if isinstance(item, Clickable):
            self.clickables.append(item)

    def is_pressed(self, wx, wy, button):
        if not self.visible:
            return False
        x = wx - self.x
        y = wy - self.y
        res = False
        for item in self.clickables:
            res = res or item.is_pressed(x, y, button)
        return res
Exemple #4
0
    def tile(image_name, surface):
        # PYGAME CHOKE POINT

        if image_name not in Graphics.PRE_RENDERS:
            bg_image = load_resource(image_name)
            sx, sy = Settings.SCREEN_SIZE  # pre render the tiled background
            sx *= 2  # to the size of a full screen
            sy *= 2
            pr_surface = Surface((sx, sy), SRCALPHA, 32)

            w, h = pr_surface.get_size()
            img_w, img_h = bg_image.get_size()

            for x in range(0, w + img_w, img_w):
                for y in range(0, h + img_h, img_h):
                    pr_surface.blit(bg_image, (x, y))

            Graphics.PRE_RENDERS[image_name] = pr_surface

        full_bg = Graphics.PRE_RENDERS[
            image_name]  # return a subsection of the full
        #                                               # pre rendered background
        r = surface.get_rect().clip(full_bg.get_rect())
        blit_region = full_bg.subsurface(r)
        surface.blit(blit_region, (0, 0))

        return surface
Exemple #5
0
    def __init__(
        self,
        parent: Player,
        speed: int,
        x: int,
        y: int,
        width: int,
        height: int,
        color: tuple[int, int, int],
        facing: bool,
        damage: int,
        lifespan: int,
    ) -> None:
        # region DocString
        """
        Creates a `Attack` object

        ### Arguments
            `parent {Player}`:
                `summary`: the player who attacked
            `speed {int}`:
                `summary`: the speed at which the attacks move
            `x {int}`:
                `summary`: the x coordinate relative to the player
            `y {int}`:
                `summary`: the y coordinate relative to the player
            `width {int}`:
                `summary`: the width of the attack hitbox
            `height {int}`:
                `summary`: the height of the attack hitbox
            `color {(int, int, int)}`:
                `summary`: the color of the attack sprite
            `facing {bool}`:
                `summary`: true if the player is facing to the right, false otherwise
            `damage {int}`:
                `summary`: the damage dealt by the attack
            `lifespan {int}`:
                `summary`: for how much the attack can exist without hitting another player
        """
        # endregion

        super(Attack, self).__init__()

        # region Sprite variables

        self.image = Surface((width, height))
        self.image.fill(color)
        self.rect = self.image.get_rect()
        self.rect.move_ip(
            parent.rect.right if facing else (parent.rect.x - width),
            parent.rect.y)
        self.rect.move_ip(x, y)

        # endregion

        self.parent = parent
        self.speed = speed
        self.damage = damage
        self.lifespan = lifespan
        self.current_life_frame = 0
Exemple #6
0
def makeMap(tiles, tileSz):
    R, C = tiles.shape
    surf = Surface((int(R * tileSz), int(C * tileSz)))
    for r in range(R):
        for c in range(C):
            surf.blit(tiles[r, c], (int(r * tileSz), int(c * tileSz)))
    return surf
Exemple #7
0
 def build(self, disp):
     self.surface = Surface((WIDTH, HEIGHT), HWSURFACE)
     draw.rect(self.surface, WHITE,
               Rect(0, 0, WIDTH - WALLWIDTH, HEIGHT - WALLWIDTH), WALLWIDTH)
     for wall in self.cells_draw:
         draw.line(self.surface, WHITE, wall[0], wall[1], WALLWIDTH)
     # if cell.matrix_index == (0, 0):
     #     self.surface.fill(
     #         RED,
     #         Rect(
     #             cell.pos[0]+int(CELLSIZE*0.1),
     #             cell.pos[1]+int(CELLSIZE*0.1),
     #             int(CELLSIZE*0.8),
     #             int(CELLSIZE*0.8)
     #         )
     #     )
     # elif cell.matrix_index == (WIDTH/CELLSIZE-1, HEIGHT/CELLSIZE-1):
     #     self.surface.fill(
     #         BLUE,
     #         Rect(
     #             cell.pos[0]+int(CELLSIZE*0.1),
     #             cell.pos[1]+int(CELLSIZE*0.1),
     #             int(CELLSIZE*0.8),
     #             int(CELLSIZE*0.8)
     #         )
     #     )
     self.surface.convert(disp)
 def __init__(self, size, game):
     Surface.__init__(self, size)
     self.width, self.height = size
     self.game = game
     self._load_images()
     self.font = pygame.font.SysFont("Comic Sans MS", int(0.09 * self.width))
     self.hsfont = pygame.font.SysFont("Comic Sans MS", int(0.09 * self.width))
	def _prepare_buttons(self):
		""" Prepares the buttons.

		This method pre-renders the plus and minus buttons.
		"""
		# draw plus button
		self._plus_button = Surface((self._font_height, self._font_height), pygame.SRCALPHA, 32)
		self._plus_button.convert_alpha()
		pygame.draw.rect(self._plus_button, SettingsScreen.COLOR, Rect(0, self._font_height/3, self._font_height, self._font_height/3))
		pygame.draw.rect(self._plus_button, SettingsScreen.COLOR, Rect(self._font_height/3, 0, self._font_height/3, self._font_height))

		# draw minus button
		self._minus_button = Surface((self._font_height, self._font_height), pygame.SRCALPHA, 32)
		self._minus_button.convert_alpha()
		pygame.draw.rect(self._minus_button, SettingsScreen.COLOR, Rect(0, self._font_height/3, self._font_height, self._font_height/3))

		# draw unchecked bool button
		self._unchecked_bool = Surface((self._font_height, self._font_height), pygame.SRCALPHA, 32)
		self._unchecked_bool.convert_alpha()
		pygame.draw.rect(self._unchecked_bool, SettingsScreen.COLOR, Rect(0, 0, self._font_height, self._font_height), 3)

		# draw checked bool button
		self._checked_bool = Surface((self._font_height, self._font_height), pygame.SRCALPHA, 32)
		self._checked_bool.convert_alpha()
		pygame.draw.rect(self._checked_bool, SettingsScreen.COLOR, Rect(0, 0, self._font_height, self._font_height), 3)
		pygame.draw.line(self._checked_bool, SettingsScreen.COLOR, (0, 0), (self._font_height, self._font_height), 3)
		pygame.draw.line(self._checked_bool, SettingsScreen.COLOR, (0, self._font_height), (self._font_height, 0), 3)
def prepare_paragraph(text, width, size="normal", colour=(0,0,0)):
    font = FONTS[size]
    lines = []
    words = text.split()
    if words:
        lastline = None
        line = words[0]
        for i in range(1,len(words)):
            lastline = line
            line = line+" "+words[i]
            w,h = font.size(line)
            if w > width:
                lines.append(lastline)
                line = words[i]
    else:
        line = ""
    lines.append(line)

    parawidth = max(font.size(each)[0] for each in lines)
    lineheight = font.get_height()
    paraheight = lineheight*len(lines)
    paragraph = Surface((parawidth,paraheight),pygame.SRCALPHA)
    paragraph.fill((255,255,255,0))
    for y,line in enumerate(lines):
        text = prepare(line,size,colour)
        paragraph.blit(text,(0,y*lineheight))
    return paragraph
Exemple #11
0
    def _createSurfaceImage(self, surfaceHeight):
        """
        Make the ground surface image.

        IDEA: Try changing the color of the ground, or maybe even add a texture to it.
        """
        LunarSurface.image = pygame.Surface([screen_width_pixels, surfaceHeight + self._groundElevation], pygame.SRCALPHA, 32).convert_alpha()
        initialY = y = Surface.get_height(LunarSurface.image) - self._pointsY[0] + self._drop_amount - self._groundElevation
        polyCoords = [(0, y)]
        for i in range(1, len(self._pointsX)):
            y -= self._pointsY[i]
            polyCoords.append((self._pointsX[i], y))

        surfaceCoords = list(polyCoords)
        polyCoords.append([screen_width_pixels, Surface.get_height(LunarSurface.image)])
        polyCoords.append([0, Surface.get_height(LunarSurface.image)])
        polyCoords.append([0, initialY])
        pygame.draw.polygon(LunarSurface.image, (64, 64, 64), polyCoords, 0)
        for i in range(0, len(surfaceCoords) - 1):
            if self._flatCoordinates.count(i) or self._flatEasyCoordinates.count(i):
                color = 0, 255, 255
                width = 2
            else:
                color = 128, 128, 128
                width = 1
            pygame.draw.line(LunarSurface.image, color, surfaceCoords[i], surfaceCoords[i + 1], width)

        self._plotlandingScores(surfaceCoords)
def prepare_table(rows, alignment="lr", size="normal", colour=(0,0,0), padding=0):
    f = FONTS[size]
    numcolumns = len(rows[0])
    numrows = len(rows)
    def u(n):
        return n if isinstance(n, unicode) else unicode(n)
    shapes = [[f.size(u(col)) for col in row] for row in rows]
    maxheight = max(max(shape[1] for shape in shaperow) for shaperow in shapes)
    widths = [max(shaperow[i][0] for shaperow in shapes) for i in range(numcolumns)]
    table = Surface((sum(widths) + padding * (numcolumns - 1),
                     maxheight * numrows + padding * (numrows - 1)),
                    pygame.SRCALPHA)
    table.fill((255,255,255,0))
    y = 0
    for r, row in enumerate(rows):
        x = 0
        for c, col in enumerate(row):
            w, h = shapes[r][c]
            text = prepare(u(col), size=size, colour=colour)
            align = alignment[c]
            if align == "r":
                adjustx = widths[c] - w
            elif align == "c":
                adjustx = (widths[c] - w) // 2
            else:
                adjustx = 0
            table.blit(text, (x + adjustx, y))
            x += widths[c] + padding
        y += maxheight + padding
    return table
Exemple #13
0
class GameUI:
    def __init__(self, mainchar):
        self.bg = Surface((600, 1600))
        self.statusbar = Surface((200, 600))
        self.mainchar = mainchar
        self.widget = []
        self.create_bg()
    
    def create_bg(self):
        rbg = self.bg.get_rect()
        bgimg = media.load_image('bg.png').convert()
        rbgimg = bgimg.get_rect()
        columns = int(rbg.width / rbgimg.width) + 1
        rows = int(rbg.height / rbgimg.height) + 1
        
        for y in xrange(rows):
            for x in xrange(columns):
                if x == 0 and y > 0:
                    rbgimg = rbgimg.move([-(columns -1 ) * rbgimg.width, rbgimg.height])
                if x > 0:
                    rbgimg = rbgimg.move([rbgimg.width, 0])
                self.bg.blit(bgimg, rbgimg)
                        
    def update(self):
        r = pygame.rect.Rect(0, 0, 200, 100)
        
        for w in self.widget:
            w.update()
            self.statusbar.blit(w.image, r)
            r = r.move((0, 100))
Exemple #14
0
 def __init__(self, width, height, runnable_stack, x=0, y=0):
     self.controls = []
     self.x = x
     self.y = y
     self.surface = Surface((width, height))
     self.runnable_stack = runnable_stack
     self.events = []
Exemple #15
0
    def __init__(self, initialFuel):
        self._pandaFrame = []
        self._pandaFrame.append(pygame.image.load("Resources/panda0.png").convert_alpha())
        self._pandaFrame.append(pygame.image.load("Resources/panda1.png").convert_alpha())
        self._pandaFrame.append(pygame.image.load("Resources/panda2.png").convert_alpha())
        self._pandaFrame.append(pygame.image.load("Resources/pandaLand0.png").convert_alpha())
        self._pandaFrame.append(pygame.image.load("Resources/pandaLand1.png").convert_alpha())
        self._pandaFrame.append(pygame.image.load("Resources/pandaLand2.png").convert_alpha())

        self.pandaHeight = Surface.get_height(self._pandaFrame[0]) * self._imageResample
        self.pandaWidth = Surface.get_width(self._pandaFrame[0]) * self._imageResample
        self.altitude = screen_height_pixels - self.pandaHeight * 2

        self._landingStickLength = max(self.pandaHeight, self.pandaWidth)

        self.x = 50
        self.angle = 0
        self.angleDelta = 0
        self.velocityX = 0.1
        self.velocityY = 0
        self.thrusting = False
        self.image = pygame.transform.rotozoom(self._pandaFrame[0], 0, self._imageResample)
        self.rotate(45)
        self.thrustSound = pygame.mixer.Sound('Resources/thrust.ogg')
        self.thrustSound.set_volume(0.25)
        self.fuel = initialFuel

        pygame.sprite.Sprite.__init__(self)
        self.rect = Rect(self.x, 0, self.pandaWidth, self.pandaWidth)

        self.maxHeight = math.sqrt(self.pandaHeight * self.pandaHeight + self.pandaWidth * self.pandaWidth)
        self.rotationsPerSec = 0.2

        self.recalculateRect()
Exemple #16
0
    def __init__(self, evManager, numlines=3, rect=(0, 0, 100, 20), txtcolor=(255, 0, 0), bgcolor=None):
        Widget.__init__(self, evManager)

        # When receiving an event containing text,
        # add or remove that text to the widget's set of text lines to display.

        # addevents_attrs maps event classes to the text attr of events
        # that add text to display.
        self.addevents_attrs = {MdAddPlayerEvt: "pname", MNameChangedEvt: "newname", MMyNameChangedEvent: "newname"}
        for evtClass in self.addevents_attrs:
            self._em.reg_cb(evtClass, self.on_addtextevent)

        # rmevents_attrs maps event classes to the text attributes of events
        # that remove text to display.
        self.rmevents_attrs = {MPlayerLeftEvt: "pname", MNameChangedEvt: "oldname", MMyNameChangedEvent: "oldname"}
        for evtClass in self.rmevents_attrs:
            self._em.reg_cb(evtClass, self.on_rmtextevent)

        self.texts = []  # Each text is a player name.

        # gfx
        self.font = Font(None, config_get_fontsize())
        self.rect = rect
        self.txtcolor = txtcolor
        self.bgcolor = bgcolor
        img = Surface(rect.size)
        if bgcolor:
            img.fill(bgcolor)
        else:
            img.set_alpha(0, RLEACCEL)  # fully transparent
        self.image = img

        self.maxnumlines = numlines
        self.linewidgets = deque(maxlen=numlines)  # deque of TextLabelWidgets
Exemple #17
0
    def update(self, duration):
        """ update all the contained linewidgets
        TODO: check that it works with transparent bg
        """

        if self.dirty == 0:
            return

        # make the box
        size = self.rect.size
        bgcol = self.bgcolor
        if bgcol:  # only display a bg img if bgcolor specified
            img = Surface(size)
            img.fill(bgcol)
            img = img.convert()
        else:  # more or less transparent
            img = Surface(size, SRCALPHA)  # handles transparency
            transparency = 50  # 0 = transparent, 255 = opaque
            img.fill((0, 0, 0, transparency))
            img = img.convert_alpha()

        # blit each line
        numelemts = min(len(self.texts), self.maxnumlines)
        for i in range(numelemts):
            wid = self.linewidgets[i]
            wid.set_text(self.texts[-i - 1])
            wid.update(duration)
            img.blit(wid.image, wid.rect)

        self.image = img
Exemple #18
0
class Star(pygame.sprite.Sprite, Drawable):
    height = 1
    width = 1
    move_step = 2

    def __init__(self, direction: Directon = Directon.DOWN):
        super().__init__()
        self.direction = direction
        self.rect = Rect(random.randint(0, SCREEN_WITH),
                         random.randint(0, SCREEN_HEIGHT), self.width,
                         self.height)
        self.image = Surface((self.width, self.height))
        self.image.fill(WHITE)

    def handle(self, event: pygame.event.Event):
        pass

    def draw(self, surface: pygame.Surface):
        pygame.draw.rect(surface, WHITE, self.rect)

    def update(self, *args, **kwargs):
        self.rect.move_ip(0, self.move_step)

        if self.rect.y < 0 or self.rect.y > SCREEN_HEIGHT:
            self.rect.y = 0
            self.rect.x = random.randint(0, SCREEN_WITH)
Exemple #19
0
 def __init__(self, color, pos):
     Sprite.__init__(self)
     self.rect = Rect(*pos, CELLS_SIZE, CELLS_SIZE)
     self.image = Surface((self.rect.width, self.rect.height))
     self.image.fill(color)
     self.state = 'normal'
     self.color = color
Exemple #20
0
    def __init__(self, game_env): 
        Text.__init__(self, game_env, size=20)
        self.__game_env = game_env
        seperator = self.font.render(' ', 1, self.color)
        header = self.font.render('=== HELP ===', 1, self.color)
        footer = self.font.render('=== GOOD LUCK ===', 1, self.color)
        all_surfaces = []
        all_surfaces.append(seperator)
        all_surfaces.append(self.font.render('Your objective should you choose to accept is to navigate your jet without getting hit by', 1, self.color))
        all_surfaces.append(self.font.render('the incoming missiles. For self-defence you can shoot down the enemy missiles. You are', 1, self.color))
        all_surfaces.append(self.font.render('armed with 100 special missiles. Level-up awards you another 50 special missiles and a', 1, self.color))
        all_surfaces.append(self.font.render('power-up star which will instantly deactivate all the enemy missiles.', 1, self.color))
        all_surfaces.append(self.font.render('Your jet can carry maximum 999 special missiles.', 1, self.color))
        all_surfaces.append(seperator)
        all_surfaces.append(self.font.render('With keyboard input, you should use your keyboard arrow keys to navigate and spacebar', 1, self.color))
        all_surfaces.append(self.font.render('to shoot. With mouse as input, you should use your mouse to navigate your jet and', 1, self.color))
        all_surfaces.append(self.font.render('mouse click to shoot', 1, self.color))
        all_surfaces.append(self.font.render(' ', 1, self.color))
        all_surfaces.append(self.font.render('POINTS: Destroy Missle -> 10 pts. Power-up Star -> 100 pts. Level-up -> 10 pts.', 1, self.color))
        all_surfaces.append(seperator)

        self.surf = Surface((all_surfaces[1].get_width(), all_surfaces[0].get_height() * (len(all_surfaces) + 2)), self.__game_env.SRCALPHA)

        self.surf.blit(header, (self.surf.get_width()/2 - header.get_width()/2, 0))
        for index, temp_surf in enumerate(all_surfaces):
            self.surf.blit(temp_surf, (0, header.get_height() + index * temp_surf.get_height()))
        self.surf.blit(footer, (self.surf.get_width()/2 - footer.get_width()/2, self.surf.get_height() - footer.get_height()))

        self.rect = self.surf.get_rect(center=(self.__game_env.static.screen_width/2, self.__game_env.static.screen_height/2))
Exemple #21
0
class Bullet(pygame.sprite.Sprite, Drawable, EventHandler):
    height = 5
    width = 5

    def __init__(self, x, y, direction: Directon = Directon.UP, velocity=5):
        super().__init__()
        self.velocity = velocity
        self.direction = direction
        self.rect = Rect(int(x - self.width / 2), y - self.height, self.width,
                         self.height)
        self.image = Surface((self.width, self.height))
        self.image.fill(WHITE)

    def handle(self, event: pygame.event.Event):
        pass

    def draw(self, surface: pygame.Surface):
        pygame.draw.rect(surface, WHITE, self.rect)

    def update(self, *args, **kwargs):
        # noinspection PyTypeChecker
        self.rect.move_ip(0, self.velocity * self.direction.value)

        if self.rect.y < 0 or self.rect.y > SCREEN_HEIGHT:
            self.kill()
Exemple #22
0
    def __init__(self, x, y):
        Sprite.__init__(self)
        self.image = Surface((73, 211))
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.image.set_colorkey(Color(BACKGROUND_COLOR))
        self.is_Give = False
        self.is_Has = False
        self.is_Fall = False

        def make_boltAnim(anim_list, delay):
            boltAnim = []
            for anim in anim_list:
                boltAnim.append((anim, delay))
            Anim = pyganim.PygAnimation(boltAnim)
            return Anim

        self.boltAnimStay = make_boltAnim(ANIMATION_STAY, ANIMATION_DELAY)
        self.boltAnimStay.play()

        self.boltAnimCall = make_boltAnim(ANIMATION_CALL, ANIMATION_DELAY * 3)
        self.boltAnimCall.play()

        self.boltAnimJump = make_boltAnim(ANIMATION_JUMP, ANIMATION_DELAY * 3)
        self.boltAnimJump.play()
    def _createSurfaceImage(self, surfaceHeight):
        """
        Make the ground surface image.
        
        IDEA: Try changing the color of the ground, or maybe even add a texture to it.
        """
        LunarSurface.image = pygame.Surface(
            [screen_width_pixels, surfaceHeight + self._groundElevation], pygame.SRCALPHA, 32
        ).convert_alpha()
        initialY = y = (
            Surface.get_height(LunarSurface.image) - self._pointsY[0] + self._drop_amount - self._groundElevation
        )
        polyCoords = [(0, y)]

        for i in range(1, len(self._pointsX)):
            y -= self._pointsY[i]
            polyCoords.append((self._pointsX[i], y))

        surfaceCoords = list(polyCoords)
        polyCoords.append([screen_width_pixels, Surface.get_height(LunarSurface.image)])
        polyCoords.append([0, Surface.get_height(LunarSurface.image)])
        polyCoords.append([0, initialY])
        pygame.draw.polygon(LunarSurface.image, (64, 64, 64, 128), polyCoords, 0)
        for i in range(0, len(surfaceCoords) - 1):
            if self._flatCoordinates.count(i) or self._flatEasyCoordinates.count(i):
                # NAM change color: color = 0, 255, 255
                color = 255, 0, 0
                width = 3
            else:
                color = 128, 128, 128
                width = 1
            pygame.draw.line(LunarSurface.image, color, surfaceCoords[i], surfaceCoords[i + 1], width)

        self._plotlandingScores(surfaceCoords)
    def __init__(self, initialFuel):
        self._tardisFrame = []
        self._tardisFrame.append(pygame.image.load("Resources/tardis0.png").convert_alpha())
        self._tardisFrame.append(pygame.image.load("Resources/tardis1.png").convert_alpha())
        self._tardisFrame.append(pygame.image.load("Resources/tardis2.png").convert_alpha())
        self._tardisFrame.append(pygame.image.load("Resources/tardisLand0.png").convert_alpha())
        self._tardisFrame.append(pygame.image.load("Resources/tardisLand1.png").convert_alpha())
        self._tardisFrame.append(pygame.image.load("Resources/tardisLand2.png").convert_alpha())

        self.tardisHeight = Surface.get_height(self._tardisFrame[0]) * self._imageResample
        self.tardisWidth = Surface.get_width(self._tardisFrame[0]) * self._imageResample
        self.altitude = screen_height_pixels - self.tardisHeight * 1  # NAM: Adjust start height

        self._landingStickLength = max(self.tardisHeight, self.tardisWidth)

        self.x = 50
        self.angle = 0
        self.angleDelta = 0
        self.velocityX = 0.1
        self.velocityY = 0
        self.thrusting = False
        self.image = pygame.transform.rotozoom(self._tardisFrame[0], 0, self._imageResample)
        self.rotate(45)
        self.thrustSound = pygame.mixer.Sound("Resources/tardisthrust.ogg")
        self.thrustSound.set_volume(0.5)
        self.fuel = initialFuel

        pygame.sprite.Sprite.__init__(self)
        self.rect = Rect(self.x, 0, self.tardisWidth, self.tardisWidth)

        self.maxHeight = math.sqrt(self.tardisHeight * self.tardisHeight + self.tardisWidth * self.tardisWidth)
        self.rotationsPerSec = 0.2

        self.recalculateRect()
Exemple #25
0
class menu(object):
    
    def __init__(self, rect, width):
        self.surface = Surface((width, rect.height))
        self.surface.fill((100,100,250))
        self.buttonDict = dict()
        self.addButton(10, 10, 40, 40, "House")
        self.updateAll()
        
    def addButton(self, x, y, width, height, text):
        self.buttonDict[(x, y, width, height)] = (button.button(width, height, text))
        
    def getButton(self, x, y):
        for myRect in self.buttonDict.keys():
            if Rect(myRect[0], myRect[1], myRect[2], myRect[3]).collidepoint(x, y):
                return self.buttonDict[(myRect[0], myRect[1], myRect[2], myRect[3])].text
        return None
            
    def updateAll(self):
        for myRect, button in self.buttonDict.items():
            self.surface.blit(button.surface, (myRect[0], myRect[1]))
    
    def getSurface(self):
        return self.surface
        
Exemple #26
0
    def update(self, duration):
        """ update all the contained linewidgets.
        Return right away if no text has changed.
        """

        if self.dirty == 0:  # no new text has been added
            return

        # make the box
        size = self.rect.size
        bgcolor = self.bgcolor
        if bgcolor:  # completely opaque bg
            img = Surface(size)
            img.fill(self.bgcolor)
            img = img.convert()
        else:  # more or less transparent
            img = Surface(size, SRCALPHA)  # handles transparency
            transparency = 50  # 0 = transparent, 255 = opaque
            img.fill((0, 0, 0, transparency))  # black
            img = img.convert_alpha()

        # blit each line
        for wid in self.linewidgets:
            wid.update(duration)
            img.blit(wid.image, wid.rect)

        self.image = img
        self.dirty = 0
Exemple #27
0
    def __init__(self, side, speed, engine: ControlEngine):
        super().__init__()

        self.speed = speed

        self.engine = engine
        self.engine.bind_pad(self)

        self.top_region_pct = 10
        self.middle_region_pct = 15

        self.width = 25
        self.height = 75

        self.dy = 0

        self.image = Surface((self.width, self.height))
        self.image.fill(white)

        self.rect = self.image.get_rect()

        if side == 'left':
            self.margin = 25
        else:
            self.margin = 775 - self.width

        self.rect.y = 300
        self.rect.x = self.margin
        self.borders = None
Exemple #28
0
 def __init__(self, location):
     sprite.Sprite.__init__(self)
     self.image = Surface((20, 20))
     self.image = image.load(location)
     self.rect = self.image.get_rect()
     self._x = None
     self._y = None
 def __init__(self,
              title,
              name,
              x,
              y,
              width,
              height,
              button_color,
              font_color,
              func,
              background_image=None):
     self.title = title
     self.name = name
     self.id = ControlButton.button_id
     ControlButton.button_id += 1
     self.x = x
     self.y = y
     self.abs_x = x
     self.abs_y = y
     self.width = width
     self.height = height
     self.func = func
     self.button_color = button_color
     self.font_color = font_color
     self.__selected_color = color.white
     self.background_image = background_image
     if background_image:
         img_surf = pygame.image.load(background_image)
         self.surface = pygame.transform.scale(img_surf, (width, height))
     else:
         self.surface = Surface((self.width, self.height))
     self.draw()
Exemple #30
0
    def draw(self, surface: Surface, dest_rect: Rect,
             critter_location: Union[Rect, None]):
        """
        Render a window into the maze into the main surface while making sure the critter at critter_location is visible

        :param surface: Main window's surface
        :param dest_rect: The rectangle of where in the window's that the viewable maze section is rendered into
        :param critter_location: Rectangle of critter to scroll maze around
        """
        rect = self.rect.copy()
        if critter_location is not None:
            if RIGHT_SCROLL_LIM > critter_location.left > LEFT_SCROLL_LIM:
                rect.left = critter_location.left - LEFT_SCROLL_LIM
            elif critter_location.left < MID_PLAY_WIDTH:
                rect.left = 0
            else:
                rect.left = RIGHT_SCROLL_LIM - MID_PLAY_WIDTH

            if BOT_SCROLL_LIM > critter_location.top > TOP_SCROLL_LIM:
                rect.top = critter_location.top - TOP_SCROLL_LIM
            elif critter_location.top < MID_PLAY_HEIGHT:
                rect.top = 0
            else:
                rect.top = BOT_SCROLL_LIM - MID_PLAY_HEIGHT

        surface.blit(self.surface, dest_rect, rect)
Exemple #31
0
class Wall(Platform):
    def __init__(self, surf, area, coords, height):
        super().__init__(surf, coords, 50, height)
        self.sprite = Surface((50, height))
        for i in range(0, height // 50):
            img = 'imgs/' + area + '-wall-right-' + str(randint(1, 3)) + '.png'
            self.sprite.blit(pg.image.load(img), (0, i * 50))
Exemple #32
0
def create_turn_marker(board, parent_rect, group):
    MARKER_OFFSET = 20
    MARKER_WIDTH = 5
    current_turn = board.current_board.current_turn
    if current_turn % 2 == 0:
        marker_size = (parent_rect.width - MARKER_OFFSET, MARKER_WIDTH)
    else:
        marker_size = (MARKER_WIDTH, parent_rect.width - MARKER_OFFSET)
    marker_size_half = (marker_size[0] / 2, marker_size[1] / 2)
    parent_half_width = parent_rect.width / 2
    parent_half_height = parent_rect.height / 2
    SEAT_OFFSETS = [
        (0, parent_half_height - marker_size_half[1]),
        (parent_half_width - marker_size_half[0], 0),
        (0, -parent_half_height + marker_size_half[1]),
        (-parent_half_width + marker_size_half[0], 0),
    ]

    turn_marker_surface = Surface(marker_size)
    turn_marker_surface.fill((255, 255, 255))
    sprite = Sprite()
    sprite.rect = turn_marker_surface.get_rect()
    sprite.image = turn_marker_surface
    sprite.rect.center = parent_rect.center
    sprite.rect.x += SEAT_OFFSETS[current_turn][0]
    sprite.rect.y += SEAT_OFFSETS[current_turn][1]
    sprite.layer = 2
    group.add(sprite)
Exemple #33
0
class Ground(Platform):
    def __init__(self, surf, area, coords, width):
        super().__init__(surf, coords, width, 50)
        self.sprite = Surface((width, 50))
        for i in range(0, width // 50):
            img = 'imgs/' + area + '-ground-' + str(randint(1, 3)) + '.png'
            self.sprite.blit(pg.image.load(img), (i * 50, 0))
Exemple #34
0
    def __init__(self, size, images):
        Surface.__init__(self, images[0].get_size(), pygame.SRCALPHA)

        self.location = (0, 34)
        self.blit(images[0], (0, 0))
        self.xChange = 100

        self.rotationX = 45
        self.rotationY = 33

        self.surfaces = [
            CubeSide(images[x], images[0].get_size(), x) for x in range(6)
        ]
        self.surfaces[0].blit(images[0], (0, 0))
        self.surfaces[1].blit(images[1], (0, 0))

        self.ORIGINAL_SURFACES = [
            pygame.Surface((100, 100), pygame.SRCALPHA) for _ in range(6)
        ]
        self.ORIGINAL_SURFACES[0].blit(images[0], (0, 0))

        self.testingSurf = Transform.skew_surface(
            pygame.transform.scale(self.surfaces[0], (self.xChange, 100)), 0,
            33)
        self.testingSurf2 = Transform.skew_surface(
            pygame.transform.scale(self.surfaces[4], (self.xChange, 100)), 0,
            -33)
Exemple #35
0
    def __init__(self, background_color, font: Font,
                 keyboard_manager: KeyboardManager,
                 state_manager: StateManager,
                 root_object_manager: RootObjectManager,
                 handler_manager: HandlerManager, shutdown):
        self.background_color = background_color
        self.font: Font = font
        self.keyboard_manager: KeyboardManager = keyboard_manager
        self.state_manager: StateManager = state_manager
        self.root_object_manager = root_object_manager
        self.handler_manager = handler_manager
        self.shutdown = shutdown

        self.line = ''
        self.surface = Surface([0, 0])

        self.surface_background_width = 0

        self.x = 0
        self.y = 100

        self.backspace_pressed_time = 0
        self.backspace_sleep_duration = 0.5
        self.backspace_repress_cycle = 0.05
        self.backspace_cycle_elapsed = 0

        self.last_loop_time = 0
Exemple #36
0
 def _getTexture(self, textureName):
     """ Return a texture surface from the texture name. """
     surface = Surface(TEXTURE_SIZE)
     self.divisor = 32
     for v in range(0, TEXTURE_SIZE[0]):
         for h in range(0, TEXTURE_SIZE[1]):
             x = float(h) / self.divisor
             y = float(v) / self.divisor
             # Render the correct Texture
             if (textureName == 'clouds'):
                 colorPoint = self._renderClouds(x, y)
             elif (textureName == 'marble'):
                 colorPoint = self._randerMarble(x, y)
             elif (textureName == 'spruce'):
                 colorPoint = self._randerSpruce(x, y)
             elif (textureName == 'radiation'):
                 colorPoint = self._renderRadiation(x, y)
             elif (textureName == 'stucco'):
                 colorPoint = self._renderStucco(x, y)
             elif (textureName == 'water'):
                 colorPoint = self._renderCrappyWater(x, y)
             elif (textureName == 'leaves'):
                 colorPoint = self._renderLeaves(x, y)
             else:
                 raise Exception("Unknown texture: %s" % textureName)
             # Paint the Canvas
             surface.set_at((h, v), colorPoint)
     return surface
 def draw_snake(self, head_img, color, screen: Surface, blocksize: int):
     for part in self.body[:-1]:
         pygame.draw.rect(screen, color, \
           [part.x * blocksize, part.y * blocksize,\
            blocksize - 1, blocksize - 1])
     screen.blit(head_img,
                 (self.head.x * blocksize, self.head.y * blocksize))
Exemple #38
0
    def prepare_map(self):
        map_surface = Surface(self.map_rect.size)
        # print(self.resource_manager.maps)
        tile_map = self.resource_manager.maps[self.level_name]

        tile_size = self.textures["tile0"].get_rect().w

        tile_list = []

        for row_idx, row in enumerate(tile_map):
            for column_idx, tile in enumerate(row):

                tile_rect = self.textures["tile" + str(tile)].get_rect().copy()
                tile_rect.topleft = (column_idx * tile_size,
                                     row_idx * tile_size)

                map_surface.blit(self.textures["tile" + str(tile)], tile_rect)

                if tile in [2]:
                    tile_list.append([tile_rect, True])

                elif tile == 1:
                    spawn_point = tile_rect.topleft
                    spawn_tile = (column_idx, row_idx)

                elif tile == 4:
                    end_tile = (column_idx, row_idx)

        paths = self.prepare_paths(tile_map, spawn_tile, end_tile)

        return map_surface, tile_list, paths, spawn_point
class WelcomeScreen(object):
    def __init__(self, mouse):
        self.mouse = mouse
        self.surface_size = (CONFIG['screen']['width']/2, CONFIG['screen']['height']/2)
        self.surface = Surface(self.surface_size)

    def draw(self, screen):
        text_box = TextBox(self.surface, align="center")
        self.surface.fill((0,175,75))
        text_box.text_color = (32, 32, 32)
        text_box.background_color = ((0, 175, 75))
        text_box.font_size = 35
        text_box.draw_new_line("Welcome to the", margin_top=-20)
        text_box.draw_new_line("City Manager Game!")

        text_box.font_size = 25
        text_box.draw_new_line("Here you can create new buildings, roads", margin_top=20)
        text_box.draw_new_line("and earn money from the things you have built.")
        text_box.draw_new_line(f"Every {CONFIG['income_period']/1000} seconds you will earn money", margin_top=5)
        text_box.draw_new_line("from your belongings.")
        text_box.draw_new_line("You can build new things using the ")
        text_box.draw_new_line("money you have as well.")
        text_box.draw_new_line("Have fun!")
        text_box.draw_new_line("Press enter to continue", margin_top=10)

        screen.blit(self.surface, (self.surface_size[0]/2,
                                   self.surface_size[1]/2))
Exemple #40
0
    def __init__(
        self, evManager, text, rect=None, onDownClickEvent=None, onUpClickEvent=None, onMouseMoveOutEvent=None
    ):
        Widget.__init__(self, evManager)
        # Widget init sets dirty to true, hence the actual text rendering
        # will be done in ButtonWidget.update(), called by the view renderer.

        self._em.reg_cb(DownClickEvent, self.on_downclick)
        self._em.reg_cb(UpClickEvent, self.on_upclick)
        self._em.reg_cb(MoveMouseEvent, self.on_mousemove)

        # the events to be triggered when the button is clicked or mouse moved
        self.onDownClickEvent = onDownClickEvent
        self.onUpClickEvent = onUpClickEvent
        self.onMouseMoveOutEvent = onMouseMoveOutEvent

        self.text = text
        self.font = Font(None, config_get_fontsize())  # default font, 40 pixels high

        if rect:
            self.rect = rect
            self.image = Surface(self.rect.size)  # container size from specified rect
            # if txtimg does not fit in rect, it'll get cut (good thing)
        else:
            txtimg = self.font.render(self.text, True, (0, 0, 0))
            self.rect = txtimg.get_rect()
            self.image = Surface(self.rect.size)  # container size from rendered text
Exemple #41
0
def get_surface(room):
    surface = Surface((800, 600))
    room["scrap"] = []

    for wall in room["walls"]:
        pygame.draw.polygon(surface, dark_green, wall)

    if "ellipses" in room:
        for ellipse in room["ellipses"]:
            transparent_beige = (beige[0], beige[1], beige[2], 0)
            pygame.draw.ellipse(surface, transparent_beige, ellipse)

    for scrap_center in room["scrap_pile_coords"]:
        if scrap_center[2] is not None and scrap_center[2] == 1:
            scrap = pygame.image.load(f"resources/mutter/mutter_{scrap_i}.png")
        else:
            scrap = pygame.image.load(f"resources/screw/screw_{scrap_i}.png")

        scrap.set_colorkey(beige)
        scrap_rect = scrap.get_rect()
        scrap_rect.center = (scrap_center[0], scrap_center[1])

        room["scrap"].append(scrap_rect)
        surface.blit(scrap, scrap_rect)

    return surface
Exemple #42
0
    def draw(self):
        """Draw battle field time.

        Returns:
            Surface: Drawn surface
        """
        surface = Surface((self._width, self._height))

        _minute, _second = divmod(math.ceil(self._jhclient.bf.time), 60)
        text = f"{_minute:02d}:{_second:02d}"

        # change text color by remaining time
        if _minute >= 1 and _second > 0:
            text = self.font.render(text, True, config.COLORS["white"])
        elif _second > 30:
            text = self.font.render(text, True, config.COLORS["blue"])
        elif _second > 10:
            text = self.font.render(text, True, config.COLORS["orange"])
        else:
            text = self.font.render(text, True, config.COLORS["red"])

        self.text_width, self.text_height = text.get_rect()[2:]

        _left = (self._width - self.text_width) // 2
        _top = (self._height - self.text_height) // 2
        surface.blit(text, (_left, _top))

        return surface
    def order_reversed_spritesheet(self, flipped_sheet):
        """Reorganize the frames in a flipped sprite sheet so that
        they are in the same order as the original sheet.

        Args:
            flipped_sheet: A PyGame Surface containing a flipped sprite
                sheet.

        Returns:
            A PyGame Surface containing the sprite sheet with each frame
            flipped and in the correct order.
        """
        ordered_sheet = Surface((self.spritesheet.get_width(),
                                 self.spritesheet.get_height()),
                                SRCALPHA)
        ordered_sheet.convert_alpha()

        for frame_index in xrange(0, self.get_num_of_frames()):
            frame_x = self.get_width() * frame_index
            old_frame_index = self.get_num_of_frames() - 1 - frame_index
            old_region = self.get_frame_region(old_frame_index)

            ordered_sheet.blit(flipped_sheet, (frame_x, 0), old_region)

        return ordered_sheet
Exemple #44
0
 def draw_status(self, surface: Surface):
     text = Fonts.shields.render(
         str(self.current_hull) + '/' + str(self.max_hull), True,
         (255, 255, 255))
     text2 = Fonts.shields.render(str(self.command), True, (0, 255, 0))
     surface.blit(text, (0, 30))
     surface.blit(text2, (0, 10))
Exemple #45
0
    def refresh_loc(self, field_size):
        """
        updates coordinates on teh table surface
        :param field_size: float; size of a virtual field
         that is determined by the size of the window that inhabits the GUI
        """
        # gets surface with fitting size

        if self.title == "Remaining Ships":
            self.location = [field_size * 25, field_size * 5
                             ]  # updates location on the game window
            column_width = 3
        else:
            self.location = [field_size * 10, field_size * 5.5]
            column_width = 3.75
        self.surf = Surface((self.fake_size[0] * 4 * field_size,
                             self.fake_size[1] * 3 * field_size))
        self.writing.font = SysFont(None, int(field_size * 3 /
                                              2))  # resizes title's font
        # calculates title's center
        self.writing.top_left_corner = [
            field_size * self.columns.__len__() * column_width / 2,
            field_size * 3 / 4
        ]
        for column in self.columns:  # goes through every column
            column.refresh_loc(field_size)  # updates its locations
Exemple #46
0
    def __init__(self, image, movement_speed):
        Surface.__init__(self, image.get_size())

        self.image = image
        self.blit(self.image, (0, 0))

        self.movement_speed = movement_speed
Exemple #47
0
    def render(self, text, antialias, color, background=None):
        """Font.render(text, antialias, color, background=None): return Surface
           draw text on a new Surface"""
        color = Color(color)
        fg = ffi.new("SDL_Color [1]")
        bg = ffi.new("SDL_Color [1]")
        fg[0].r = color.r
        fg[0].g = color.g
        fg[0].b = color.b
        if background:
            try:
                background = Color(background)
                bg[0].r = background.r
                bg[0].g = background.g
                bg[0].b = background.b
            except (TypeError, ValueError):
                # Same error behaviour as pygame
                bg[0].r = 0
                bg[0].g = 0
                bg[0].b = 0
        else:
            bg[0].r = 0
            bg[0].g = 0
            bg[0].b = 0

        if text is None or text == "":
            # Just return a surface of width 1 x font height
            height = sdl.TTF_FontHeight(self._sdl_font)
            surf = Surface((1, height))
            if background and isinstance(background, Color):
                surf.fill(background)
            else:
                # clear the colorkey
                surf.set_colorkey(flags=sdl.SDL_SRCCOLORKEY)
            return surf

        if not isinstance(text, basestring):
            raise TypeError("text must be a string or unicode")
        if "\x00" in text:
            raise ValueError("A null character was found in the text")
        if isinstance(text, unicode):
            text = text.encode("utf-8", "replace")
            if utf_8_needs_UCS_4(text):
                raise UnicodeError("A Unicode character above '\\uFFFF' was found;" " not supported")
        if antialias:
            if background is None:
                sdl_surf = sdl.TTF_RenderUTF8_Blended(self._sdl_font, text, fg[0])
            else:
                sdl_surf = sdl.TTF_RenderUTF8_Shaded(self._sdl_font, text, fg[0], bg[0])
        else:
            sdl_surf = sdl.TTF_RenderUTF8_Solid(self._sdl_font, text, fg[0])
        if not sdl_surf:
            raise SDLError(ffi.string(sdl.TTF_GetError()))
        surf = Surface._from_sdl_surface(sdl_surf)
        if not antialias and background is not None:
            surf.set_colorkey()
            surf.set_palette([(bg[0].r, bg[0].g, bg[0].b)])
        return surf
class LoadingScene(AbstractScene):
    """
    @type image: SurfaceType
    @type rect: pygame.rect.RectType
    """

    image = None
    rect = None

    def __init__(self, manager):
        """
        @type manager: slg.application.manager.Manager
        """
        super().__init__(manager)
        self.group = GameSceneGroup(self)
        image = pygame.image.load(os.path.join(GUI_DIR, 'loading_screen.jpg'))
        self.image = Surface(self._manager.get_display().get_size())
        self.rect = pygame.rect.Rect(self.image.get_rect())
        image_size = image.get_size()
        surface_size = self.image.get_size()
        x = int((image_size[0] - surface_size[0]) / 2)
        y = int((image_size[1] - surface_size[1]) / 2)
        if x < 0 and y < 0:
            image = pygame.transform.scale(image, surface_size)
            x, y = 0, 0
        elif x <= 0 <= y:
            image = pygame.transform.scale(image, (surface_size[0], image_size[1]))
            x = 0
        elif y <= 0 <= x:
            image = pygame.transform.scale(image, (image_size[0], surface_size[1]))
            y = 0
        styles = {'font': 'alger', 'font_size': 40, 'align': [TextWidget.CENTER, TextWidget.CENTER]}
        text = TextWidget(**styles)
        text.set_text("""Loading...
Please wait""")
        self.image.blit(image, (-x, -y))
        text.draw(self.image)

    def handle_events(self, events):
        self.group.handle_events(events)
        for e in events:
            if e.type == KEYDOWN:
                self.handle_keypress(e.key, pygame.key.get_mods())

    def handle_keypress(self, key, modificated):
        if key == K_SPACE and self._manager.state < GAME_STATE_LOADING:
            ChangeState(int(not bool(self._manager.state))).post()

        if key == K_m and modificated and pygame.KMOD_CTRL:
            Selector(self._manager.get_display(), self.group)
            ChangeState(GAME_STATE_PAUSED).post()

    def draw(self):
        display_surface = self._manager.get_display()
        display_surface.blit(self.image, (0, 0))
        self.group.update(display_surface)
        self.group.draw(display_surface)
Exemple #49
0
    def __init__(self, image):
        Surface.__init__(self, (300, 300))

        self.rotation = 0
        self.originalImage = image

        self.cubeSide = CubeSide(image, (100, 100), 0)

        self.imageLocation = (100, 100)
Exemple #50
0
 def __init__(self, size, score_manager):
     Surface.__init__(self, size)
     self.background = None
     self.width, self.height = size
     self.font = pygame.font.SysFont("Comic Sans MS", int(0.09 * self.width))
     self.font2 = pygame.font.SysFont("Comic Sans MS", int(0.07 * self.width))
     self.score_manager = score_manager
     self._load_images()
     self._init_board()
class FilteredSpList(Clickable):
    def __init__(self, data, x, y, filters):
        self.data = data
        self.filter = filters
        self.surface = Surface((200, 170))
        self.x = x
        self.y = y
        self.up_button = Button(86, 0, 28, 21, callback=self.decrease_offset, sprite=SpriteManager().sprites['up_button'])
        self.down_button = Button(86, 142, 28, 21, callback=self.increase_offset, sprite=SpriteManager().sprites['down_button'])
        self.offset = 0
        self.items = [self.up_button, self.down_button]
        self.clickables = [self.up_button, self.down_button]
        self.reset()

    def update_specialists(self):
        self.shown_sp_panels = self.sp_panels[self.offset:self.offset + 2]
        for i in range(len(self.shown_sp_panels)):
            self.shown_sp_panels[i].y = i * 60 + 21

    def increase_offset(self):
        if self.offset < len(self.data.specialists) - 2:
            self.offset += 1
            self.update_specialists()

    def decrease_offset(self):
        if self.offset > 0:
            self.offset -= 1
            self.update_specialists()

    def draw(self, screen):
        self.surface.fill(0x000000)
        for item in self.items:
            item.draw(self.surface)
        for item in self.shown_sp_panels:
            item.draw(self.surface)
        screen.blit(self.surface, (self.x, self.y))

    def is_pressed(self, wx, wy, button):
        x = wx - self.x
        y = wy - self.y
        res = False
        for item in self.clickables:
            res = res or item.is_pressed(x, y, button)
        for item in self.shown_sp_panels:
            if item.is_pressed(x, y, button):
                if item.selected:
                    self.chosen.add(item.specialist)
                else:
                    self.chosen.remove(item.specialist)
                res = True
        return res

    def reset(self):
        free_specialists = [sp for sp in self.data.specialists if not sp.occupied and sp.s_type in self.filter]
        self.sp_panels = [SpecialistPanel(0, 0, specialist, True) for specialist in free_specialists]
        self.update_specialists()
        self.chosen = set()
Exemple #52
0
 def text(self, value): 
     #set the new text
     self._label.text = value
     #reconstruction of the frame surface, maybe resized
     frame = Surface((self._padding_left * 2 + self._label.width, self._padding_top * 2 + self._label.height))
     frame.fill(Color("grey"))
     self._sprite.image = frame
     #self._sprite = SpriteFactory().fromSurface("widget.button", frame, self._sprite.rect.topleft, layer=self._sprite.layer)
     self._sprite.dirty = 1
Exemple #53
0
class World(object):
    def __init__(self, width, height):
        self.width = 300
        self.height = 300
        self.grid_size = 20

        self.pixel_size = Rect(0, 0, width, height)
        self.full_grid = Rect(0, 0, self.width, self.height)
        self.view_grid = Rect(10, 10, 0, 0)
        self.prev_view_grid = None
        self.zoom(0)

        self.ground = [[0 for col in range(self.width)] for row in range(self.height)]

        for y in range(self.height):
            for x in range(self.width):
                self.ground[y][x] = Assets.colors_db.any('dirt')
        self.surface = Surface((width, height), HWSURFACE, 32)

    def draw(self, screen):
        rect = self.view_grid
        if self.prev_view_grid != rect:
            self.prev_view_grid = Rect(rect)
            x1 = rect.left
            y1 = rect.top
            x2 = min(self.width, rect.left + rect.width)
            y2 = min(self.height, rect.top + rect.height)

            r = Rect(0, 0, self.grid_size, self.grid_size)
            for row in self.ground[y1:y2 - 1]:
                for col in row[x1:x2 - 1]:
                    self.surface.fill(col, r)
                    r.left += self.grid_size
                r.left = 0
                r.top += self.grid_size

        screen.blit(self.surface, self.pixel_size)

    def view_move(self, move):
        self.view_grid.left += move.x
        self.view_grid.top += move.y
        self.view_grid.clamp_ip(self.full_grid)

    def zoom_in(self):
        self.zoom(+1)

    def zoom_out(self):
        self.zoom(-1)

    def zoom(self, dz):
        if 50 >= self.grid_size + dz >= 5:
            self.grid_size = self.grid_size + dz
            self.view_grid.width = int(math.ceil(self.pixel_size.width / float(self.grid_size))) + 1
            self.view_grid.height = int(math.ceil(self.pixel_size.height / float(self.grid_size))) + 1
            self.view_grid.clamp_ip(self.full_grid)
            self.prev_view_grid = None
Exemple #54
0
    def redraw(self, rotation_x, rotation_y):
        resize_width = 0
        resize_height = 0
        if (rotation_x + self.originalRotationX > 360):
            resize_width = (rotation_x + self.originalRotationX * 1.0) % 90.0
            resize_width = int(resize_width * 100)

        Surface.__init__(self, self.get_size(), pygame.SRCALPHA)
        Transform.skew_surface(self.originalImage, 0, -rotation_y), (0, 0)
        self.blit(pygame.transform.scale(Transform.skew_surface(self.originalImage, 0, -rotation_y), (resize_width, self.get_size()[1])), (-rotation_x,0))
Exemple #55
0
 def create_layer(self):
     bgimg = media.load_image('bg.png').convert()
     rbgimg = bgimg.get_rect()
     rows = int(600 / rbgimg.height) + 2
     
     layer = Surface((rbgimg.width, 600))
     for y in xrange(rows):
         layer.blit(bgimg, rbgimg)
         rbgimg = rbgimg.move([0, rbgimg.height])
     return layer
Exemple #56
0
 def __init__(self, size, game):
     Surface.__init__(self, size)
     self.width, self.height = size
     self.game = game
     self._load_images()
     self.font = pygame.font.SysFont("Comic Sans MS", int(0.09 * self.width))
     self.font2 = pygame.font.SysFont("Comic Sans MS", int(0.035 * self.width))
     self.select_column_text = self.font.render("Select column", 1, (255, 255, 0))
     self.select_school_text = self.font.render("Select school", 1, (255, 255, 0))
     self.move_text = self.font2.render("MOVE", 1, (255, 0, 0))
Exemple #57
0
 def create_bottom(self):
     bgimg = media.load_image('tile_wall.png').convert()
     bgimg = pygame.transform.flip(bgimg, False, True)
     rbgimg = bgimg.get_rect()
     cols = int(1000 / rbgimg.width)
     
     top = Surface((1000, rbgimg.height))
     for x in xrange(cols):
         top.blit(bgimg, rbgimg)
         rbgimg = rbgimg.move([rbgimg.width, 0])
     return top
Exemple #58
0
 def create_top(self):
     bgimg = media.load_image('tile_wall.png').convert()
     rbgimg = bgimg.get_rect()
     self.top_size = rbgimg.width
     cols = int(1000 / rbgimg.width)
     
     top = Surface((1000, rbgimg.height))
     for x in xrange(cols):
         top.blit(bgimg, rbgimg)
         rbgimg = rbgimg.move([rbgimg.width, 0])
     return top
Exemple #59
0
    def __init__(self, surface_image, front_size, side):
        Surface.__init__(self, front_size, pygame.SRCALPHA)
        self.originalImage = surface_image
        self.blit(surface_image, (0, 0))
        self.side = side
        self.isVisible = True

        self.originalRotationX = 0
        self.originalRotationY = 0

        self.get_rotation()
Exemple #60
0
 def __init__(self, size, game, acceleration=ACCELERATION):
     Surface.__init__(self, size)
     self.width, self.height = size
     self.game = game
     self.player = Player(self, (size[0]/2, size[1]*0.8))
     self.obstacle_manager = ObstacleManager(self,
                                             OBSTACLE_BASE_SPEED,
                                             MAX_OBSTACLES,
                                             CollisionStrategyFactory(self.game),
                                             self.player)
     self.children = [self.player, self.obstacle_manager]
     self.acceleration = acceleration