예제 #1
0
class Meteor (Sprite):
    coord_x = 0
    coord_y = 0
    size = (1,1)
    falltime = 60
    COLOR = 255,0,0
    def __init__(self,loc, bounds, falltime):
        Sprite.__init__(self)
        self.image = Surface(self.size)
        self.rect = self.image.get_rect()
        self.rect.bottomleft = loc
        self.image.fill(self.color)
        self.bounds = bounds
        self.falltime = falltime
    def update():
        self.falltime -= 1
        if falltime <= 0:
            self.coord_x, self.coord_y = self.rect.center
            self.impact()

            self.kill()
    
    def impact():
        #self.explode = Surface(self.size)
        print "impact!"
예제 #2
0
def window_init(width, height, color, caption):
    display = (width, height)                   # Группируем ширину и высоту в одну переменную
    screen = pygame.display.set_mode(display)   # Создаем окошко
    pygame.display.set_caption(caption)         # Пишем в шапку
    bg = Surface((width,height))                # Создание видимой поверхности, будем использовать как фон
    bg.fill(Color(color))                       # Заливаем поверхность сплошным цветом
    return bg, screen
예제 #3
0
    def highlight(self):
        if not self.highlighted:
            (x, y) = self.pos()
            (w, h) = self.rect.size
            (lw, lh) = (round(w * 1.5), round(h * 1.5))

            img = Surface((lw, lh), pygame.SRCALPHA)
            img.fill(COLOR_WHITE)
            a = surfa.pixels_alpha(img)
            d = max(lw, lh) / 2
            (cx, cy) = (lw // 2, lh // 2)

            for i in range(len(a)):
                for j in range(len(a[i])):
                    k = math.sqrt(sqr(100.0 * (i - cx) / cx) + sqr(100.0 * (j - cy) / cy))
                    if k > 100: a[i][j] = 0
                    else: a[i][j] = 255 - round(k / 100.0 * 255.0)

            a = None

            img.blit(self.image, ((lw - w) // 2, (lh - h) // 2))
            self.image = img

            self.set_pos(x - (lw - w) // 2, y - (lh - h) // 2)
            self.highlighted = True
예제 #4
0
   def __init__(self, txt="Hello, World!"):
      self.text = txt
      self.__height = 15
      self.__width = self.__height * (12.0 / 20.0)
      self.__cols = 50
      self.__rows = 7
      self.__accentSize= 10
      self.__lineBuff = 2
      self.__lineHeight = self.__height + self.__lineBuff
      self.__buffer = (self.__accentSize + 4,self.__accentSize + 4)
      
      self.__size = ((self.__buffer[0] * 2) + self.__cols * self.__width  + 1,
                     (self.__buffer[1] * 2) + self.__rows * self.__lineHeight)
      
      self.__canvas = Surface(self.__size)
      self.__box = Surface(self.__size)      
      self.__myFont = font.SysFont("courier", self.__height)
      self.__color = (255,255,0)
      self.__bgColor = (0,0,100)
      self.__edgeColor = (255,255,200)
      self.__transparent = (255,0,255)
      self.__cursor = 0
      self.__nextCue = "(Press Space)"
      

      self.__canvas.set_colorkey(self.__transparent)
      self.__box.set_colorkey(self.__transparent)
      
      self.__preDrawBox()
예제 #5
0
    def makebackground(self, surface):
        surface.fill((0,0,0))
        
        template = Surface(2*(min(self.zoom.width, self.zoom.height),))
        template.fill((0,0,0,255))
        width,height = template.get_size()

        ylim = surface.get_height()/height
        xlim = surface.get_width()/width

        data = self._data
        noise = [[pnoise2(self._selected[1][0]+x,
                          self._selected[0][0]+y,
                          4, 0.85) * 50
                  for x in range(xlim)]
                 for y in range(ylim)]

        hmin = hmax = 0
        for y in range(ylim):
            for x in range(xlim):
                yd = len(data)*float(y)/ylim
                xd = len(data[0])*float(x)/xlim

                h = self._height(data, yd, xd)
                n = noise[y][x]
                if h < 0:
                    h += -n if n > 0 else n
                else:
                    h += n if n > 0 else -n
                if h < hmin:
                    hmin = h
                if h > hmax:
                    hmax = h

        self.rects = []
        for y in range(ylim):
            for x in range(xlim):
                block = template.copy()
                yd = len(data)*float(y)/ylim
                xd = len(data[0])*float(x)/xlim

                h = self._height(data, yd, xd)
                n = noise[y][x]
                if h < 0:
                    h += -n if n > 0 else n
                else:
                    h += n if n > 0 else -n
                if h < 0:
                    color = 0, 0, int(255 * (1 - h/hmin))
                else:
                    color = 0, int(255 * h/hmax), 0
                block.fill(color)
                if self.selection:
                    if self.selection[0][0] <= yd <= self.selection[0][1]:
                        if self.selection[1][0] <= xd <= self.selection[1][1]:
                            block.fill((255,0,0,32),
                                       special_flags = BLEND_ADD)
                rect = Rect(x*width, y*height, width, height)
                surface.blit(block, rect.topleft)
                self.rects.append((rect, (yd, xd)))
예제 #6
0
class Ship(Sprite):
    width = 20
    height = 20

    def __init__(self, x, y, vx, vy, bounds, color):
        Sprite.__init__(self)

        self.vx = vx
        self.vy = vy
        self.bounds = bounds
        self.color = color

        self.rect = Rect(x, y, self.width, self.height)
        self.image = Surface(self.rect.size)
        self.draw_image()
        
    def draw_image(self):
        self.image.fill(self.color)

    def update(self, dt):
        dt /= 1000.0
        dx = int(self.vx * dt)
        dy = int(self.vy * dt)
        self.rect.x += dx
        self.rect.y += dy
예제 #7
0
 def draw_grid(self, tileset):
     """Returns an image of a tile-based grid"""
     img = Surface((self.xsize * SIZE, self.ysize * SIZE))
     for pos, char in self:
         rect = get_tile_rect(pos)
         img.blit(tileset.image, rect, tileset.positions[char])
     return img
예제 #8
0
    def block(self, color, shadow = False):
        colors = {'blue':   (27, 34, 224),
                  'yellow': (225, 242, 41),
                  'pink':   (242, 41, 195),
                  'green':  (22, 181, 64),
                  'red':    (204, 22, 22),
                  'orange': (245, 144, 12),
                  'cyan':   (10, 255, 226)}

        if shadow:
            end = [40]  # end is the alpha value
        else:
            end = []    # Adding this to the end will not change the array, thus no alpha value

        border = Surface((self.blocksize, self.blocksize), pygame.SRCALPHA, 32)
        border.fill(map(lambda c: c*0.5, colors[color]) + end)

        borderwidth = 2

        box = Surface((self.blocksize-borderwidth*2, self.blocksize-borderwidth*2),
                        pygame.SRCALPHA, 32)
        boxarr = pygame.PixelArray(box)
        for x in range(len(boxarr)):
            for y in range(len(boxarr)):
                boxarr[x][y] = tuple(map(lambda c: min(255, int(c*random.uniform(0.8, 1.2))),
                                    colors[color]) + end)

        del boxarr # deleting boxarr or else the box surface will be 'locked' or something like that and won't blit
        border.blit(box, Rect(borderwidth, borderwidth, 0, 0))

        return border
예제 #9
0
class Coche(Rect):
    coche0 = image.load(os.path.join(imagesrep,'button0.png'))
    coche1 = image.load(os.path.join(imagesrep,'button1.png'))
    font = font.Font(os.path.join(thisrep,'MonospaceTypewriter.ttf'),8)

    def __init__(self,label='',fgcolor=(255,255,255),font=None):
        if not font: font = Coche.font
        Rect.__init__(self,Coche.coche0.get_rect())
        self.scr = display.get_surface()
        self.status = False
        label = Coche.font.render(label,1,fgcolor)
        Rlabel = label.get_rect()
        Rlabel.midleft = self.midright
        self.label = Surface(self.union(Rlabel).size,SRCALPHA)
        self.label.blit(label,Rlabel)
        
    
    def update(self,ev):
        if ev.type == MOUSEBUTTONUP and self.collidepoint(ev.pos):
            self.status ^= 1
            return True
    
    def screen(self):
        self.scr.blit(Coche.coche1 if self.status else Coche.coche0,self)
        self.scr.blit(self.label,self)
예제 #10
0
def join_files(target, sources, images_per_line):
    lines = len(sources) / images_per_line
    if len(sources) % images_per_line != 0:
        lines += 1
    first = pygame.image.load(sources[0])
    w, h = first.get_width(), first.get_height()

    result = Surface((w * images_per_line, h * lines)).convert_alpha()
    result.fill((255, 255, 255, 0))

    for i, source in enumerate(sources):
        im = pygame.image.load(source)
        im.convert_alpha()
        if im.get_width() != w or im.get_height() != h:
            print 'Image %s is not of the same size as the first'
            exit()

        x = w * (i % images_per_line)
        y = h * (i / images_per_line)
        result.blit(im, (x, y))
    # bg = Surface((640, 480), depth=32)
    # bg.convert_alpha()
    # bg.fill((255, 0, 0))
    # bg.blit(result, (0, 0))
    # d.blit(bg, (0, 0))
    # pygame.display.flip()
    # raw_input()
    pygame.image.save(result, target)
예제 #11
0
def draw_rectangle(width, height, colour, position, window):
    rectangle = Surface((width, height))
    pixels = surfarray.pixels3d(rectangle)
    pixels[:][:] = colour
    del pixels
    rectangle.unlock()
    window.blit(rectangle, position)
예제 #12
0
def create_tag_image(
        tags, 
        output, 
        size=(500,500), 
        background=(255, 255, 255), 
        layout=LAYOUT_MIX, 
        fontname=DEFAULT_FONT,
        rectangular=False):
    """
    Create a png tag cloud image
    """
    
    if not len(tags):
        return
    
    sizeRect, tag_store = _draw_cloud(tags,
                                      layout,
                                      size=size, 
                                      fontname=fontname,
                                      rectangular=rectangular)
    
    image_surface = Surface((sizeRect.w, sizeRect.h), SRCALPHA, 32)
    image_surface.fill(background)
    for tag in tag_store:
        image_surface.blit(tag.image, tag.rect)
    pygame.image.save(image_surface, output)
예제 #13
0
class RoboImages(Sprite):
    color = 0,0,0
    size = 60,60
    def __init__(self, parent):
        Sprite.__init__(self)
        self.parent = parent
        self.name = parent.name
        if parent.name == "baby":
            self.size = 40,40
        self.color = parent.color
        self.image = Surface(self.size)
        self.rect = self.image.get_rect()
        self.rect.centerx = self.parent.rect.centerx
        self.rect.centery = self.parent.rect.centery
        self.dir = dir
        
    

        try:
            self.image = load_image(self.name+'bot')
            print "found family sprite"
        except:
            self.image.fill(self.color)
            print "failed to load family image"
        
        
        self.image = pygame.transform.scale(self.image, self.size)
        self.image.set_colorkey((255,255,255))
        
   
    def update(self):
        self.rect.center = self.parent.rect.center
        if not self.parent.alive():
            self.kill()
예제 #14
0
파일: desc.py 프로젝트: tps12/Dorftris
    def _makebackground(self, size):
        self._renderer = TextRenderer(self._font, size[0])

        bg = Surface(size, flags=SRCALPHA)
        bg.fill((0,0,0))

        dy = 0
        bg, dy = self._addline(bg,
                           self._creature.physical(),
                           (255,255,255),
                           dy)
        appetites = self._creature.appetitereport()
        if appetites:
            bg, dy = self._addline(bg,
                               appetites,
                               (255,255,255),
                               dy)
        inventory = self._creature.inventoryreport()
        if inventory:
            bg, dy = self._addline(bg,
                               inventory,
                               (255,255,255),
                               dy)

        self._background = Surface(size, flags = bg.get_flags())
        
        self._scroll.draw(self._background, bg)
예제 #15
0
class Bomb(Sprite):
    width = 10
    height = 10
    color = 0,200,255
    fuse = 3000

    def __init__(self, pos):
        self.image = Surface((self.width, self.height))
        self.image.fill(self.color)

        self.rect = Rect(0,0,self.width, self.height)
        self.rect.center = pos

        self.time = fuse

    def update(self, dt):
        self.time -= dt
        step = self.time / 500

        if step % 2 == 0:
            color = 255,255,0
        else:
            color = 255,0,0

        self.image.fill(color, self.rect.inflate(-self.width/2, self.height/2))
예제 #16
0
class Impact(Meteor):
    size = (100,100)
    COLOR = 0,140,0
    duration = 5
    def __init__(self,loc, bounds, duration, kind):
        
        #print "explosion!"
        
        # Ice should have moving impacts
        Sprite.__init__(self)
        self.image = Surface(self.size)
        self.rect = self.image.get_rect()
        self.rect.center = loc
        self.image.fill(self.COLOR)
        self.bounds = bounds
        self.duration = duration
        self.kind = kind
        if kind == "rock":
            self.duration = 10
    def update(self):
        self.duration -= 1
        if self.duration <= 0:
            self.coord_x, self.coord_y = self.rect.center
            self.kill()
            
    #def collision(self, robot):
        
        
    def kill (self):
        Sprite.kill(self)
예제 #17
0
    def _blit_to_block(self, text_array, text_color=(255, 255, 255),
                       block_color=(0, 0, 0)):
        """
        Takes an array of strings with optional text and background colors,
        creates a Surface to house them, blits the text and returns the
        Surface.
        """

        rendered_text = []
        font_width = []
        font_height = []

        for text in text_array:
            ren = self.__font.render(text, True, text_color)
            rendered_text.append(ren)
            fw, fh = ren.get_size()
            font_width.append(fw)
            font_height.append(fh)

        block = Surface((max(font_width) + 20, sum(font_height) + 20))
        block.fill(block_color)

        h = 10
        for text in rendered_text:
            block.blit(text, (10, h))
            h += font_height[0]

        return block
예제 #18
0
	def __init__(self, posX, posY, picture, size, resourcePath):
		self.picture = picture
		self.size = size
		self.resourcePath = resourcePath
		self.maxHealth = 100 * self.size
		self.health = self.maxHealth
		self.preimage = image.load(self.resourcePath + "img/" + self.picture + "_buffalo.png")
		self.image = scale(self.preimage, (int(self.preimage.get_width() * self.size),
										   int(self.preimage.get_height() * self.size)))
		self.healthFont = font.Font(None, 20)
		self.healthBarContainer = Surface((int(75 * self.size), int(12 * self.size))).convert()
		self.healthBarShader = Surface((self.healthBarContainer.get_width() + 6,
										self.healthBarContainer.get_height() + 6)).convert()
		self.healthNumber = self.healthFont.render(str(self.health), 1, (0, 0, 0))
		self.healthBarShader.fill((175, 175, 175))
		self.healthBar = Surface(self.healthBarContainer.get_size()).convert()
		self.healthColour = ()
		if (self.health >= 50):
			self.healthColour = (float((self.maxHealth - self.health) * 2 / self.maxHealth * 255), 255, 0)
		else:
			self.healthColour = (255, float(self.health * 2 / self.maxHealth * 255), 0)
		try:
			self.healthBar.fill(self.healthColour)
		except TypeError:
			self.healthBar.fill((0, 0, 0))
		self.healthBarContainer.blit(self.healthBar, (0, 0))
		self.value = 20 * self.size
		self.rect = Rect((0, 0), self.image.get_size())
		self.rect.x = posX
		self.rect.y = posY
		self.status = "alive"
		self.targetY = posY
예제 #19
0
class Player(Sprite):
    def __init__(self, x, y):
        Sprite.__init__(self)
        self.image = Surface((22, 32))
        self.image.fill((150, 150, 150))
        self.xvel = 0
        self.yvel = 0
        self.x = x
        self.y = y
        self.onGroung = False

    def update(self, left, right):
        if left:
            self.xvel = -MOVE_SPEED
        if right:
            self.xvel = MOVE_SPEED
        if not(left or right):
            self.xvel = 0

        if not self.onGroung:
            self.yvel += GRAVITY

        self.x += self.xvel
        self.y += self.yvel

    def draw(self, surf):
        surf.blit(self.image, (self.x, self.y))
예제 #20
0
class Enemy(Sprite):
    size = width,height = 50,50
    color = 255,0,0
    vx, vy = 6,6

    def __init__(self,loc,bounds):
        Sprite.__init__(self)
        self.image = Surface(self.size)
        self.rect = self.image.get_rect()
        self.bounds = bounds


        self.image.fill(self.color)
        self.rect.bottomleft = loc

        self.vx = randrange(4,8)
        direction = 2 * randrange(2)- 1
        self.vx *= direction

    def update(self):
        self.rect.x += self.vx
        self.rect.y += self.vy

        if self.rect.left < self.bounds.left or self.rect.right > self.bounds.right:
            self.rect.x -= 2 * self.vx
            self.vx = -self.vx

        if self.rect.top > self.bounds.bottom:
            self.kill()
예제 #21
0
 def __init__(self):
     scrsize = self.w, self.h = display.get_surface().get_size()
     Surface.__init__(self, scrsize)
     self.foo = 0
     self.l0 = []
     self.l1 = []
     self.l2 = []
예제 #22
0
class Player(Sprite):
    color = 255,25,69
    size = 20,20

    def __init__(self, loc, bounds):
        Sprite.__init__(self) #makes player a sprite object

        self.image = Surface(self.size)
        self.rect = self.image.get_rect() 

        self.rect.center = loc
        self.bounds = bounds

        self.image.fill(self.color)
        self.bullets = Group()

    def update(self):
        self.rect.center = pygame.mouse.get_pos() #player moves/stays with mouse
        self.rect.clamp_ip(self.bounds) #cant leave screen bounds

    def shoot(self):
        if not self.alive():
            return #stop doing anything in this function
        bullet = Bullet(self.bounds)
        bullet.rect.midbottom = self.rect.midtop 
        self.bullets.add(bullet)
예제 #23
0
class Player(Sprite):
    color = 255, 255, 0
    size = 20, 20
    
    def __init__(self, loc, bounds):
        Sprite.__init__(self)

        self.image = Surface(self.size)
        self.rect = self.image.get_rect()

        self.rect.center = loc
        self.bounds = bounds

        self.image.fill(self.color)
        self.bullets = Group()

    def update(self):
        self.rect.center = pygame.mouse.get_pos()
        self.rect.clamp_ip(self.bounds)

    def shoot(self):
        if not self.alive():
            return

        bullet = Bullet(self.bounds)
        bullet.rect.midbottom = self.rect.midtop
        self.bullets.add(bullet)
예제 #24
0
    def get_surface(self):
        W, H = functions.get_screen_size()
        if isinstance(self.img_path, str):  # load image
            surface = load_image(self.img_path)
        else:  # take image
            surface = self.img_path
        if 0 < self.alpha < 255:
            surface.set_alpha(self.alpha, RLEACCEL)
        if self.mode == "scale to screen":
            surface = scale(surface, (W, H))
            self.size = (W, H)
        elif self.mode == "cut to screen":
            new_surface = Surface((W, H))
            new_surface.blit(surface, (0, 0))
            self.size = (W, H)
        elif self._resized:
            surface = scale(surface, self._resized)
        elif self.mode:
            functions.debug_msg("Unrecognized mode : ", self.mode)
##        elif self._resized:
##            surface = scale(surface, self._resized)
        if self.colorkey:
            surface.set_colorkey(self.colorkey, RLEACCEL)
        surface.set_clip(self.clip)
        if self.alpha < 255:
            return surface.convert_alpha()
        else:
            return surface.convert()
예제 #25
0
    def __init__(self, move_time, nodes):
        sprite.Sprite.__init__(self)
        self.nodes = nodes
        self.orig_nodes = nodes
        self.move_time = move_time
        self.spawn_time = time.time()
        self.image = Surface((40, 40)).convert()
        self.image_inside = Surface((38, 38)).convert()
        self.image_inside.fill((0, 255, 0))
        self.image.blit(self.image_inside, (1, 1))
        self.pos = (80, 40)
        self.real_pos = (80, 40)
        self.rect = Rect(self.pos, self.image.get_size())
        self.speed = 2
        self.speed_mod = 1
        self.diag_speed = 2
        self.target_pos = (880, 560)
        self.value = 1
        self.cost = 0
        self.health = 100
        self.damage_mod = 1
        self.counter = 0
        self.cur_node = self.nodes[0]
        self.the_dir = (0, 0)
        self.can_move = False

        self.name = "Monster"
        self.description = "A basic monster with slow movement speed and moderate health."
예제 #26
0
class Bullet(GameObj):
    def __init__(self):
        super(Bullet, self).__init__()
        self.r = config.bulletR
        self.m = config.bulletM
        self.shape = ShapeCircle(self.r)
        self.t = 0
        self.length = 0
        self.I = 0
        self.damage = 0
        # image
        self.image = Surface(Size).convert_alpha()
        self.image.fill((0, 0, 0, 0))
        self.rect = Rect((0, 0), Size)
        draw.circle(self.image, (0, 0, 0, 0xff), self.rect.center, self.r)

    def size(self):
        return (self.r*2, self.r*2)

    def apply(self):
        self.length += self.v.length * self.dt
        self.dt = 0

    def update(self):
        self.rect.center = self.pos

    def boom(self):
        self.I = 5000000
        self.active = 0
예제 #27
0
파일: text.py 프로젝트: tps12/Dorftris
    def render(self, text, color):
        words = text.split()
        lines = []
        h = 0
        i = 0
        j = 1
        while i < len(words):
            found = False
            if j == len(words):
                found = True
            elif self._font.size(' '.join(words[i:j]))[0] >= self._width:
                j = max(1, j-1)
                found = True

            if found:
                line = self._font.render(' '.join(words[i:j]), True, color)
                lines.append(line)
                h += line.get_height()
                i = j
            else:
                j += 1
        image = Surface((self._width, h), flags=SRCALPHA)
        h = 0
        for line in lines:
            image.blit(line, (0, h))
            h += line.get_height()
        return image
예제 #28
0
	def draw_equipment_item(self, pane):
		equip_item_pane = Surface((EQUIPMENT_ITEM_WIDTH, EQUIPMENT_ITEM_HEIGHT))
		self.draw_border(equip_item_pane)
		items = []
		equipment = self.player.inventory.items_of_type(Equipment)
		current_equipment = self.selected_party_member.equipment_set.equipment
		
		for e in equipment:
			if not e.equippable_in_slot(self.selected_equip_slot): continue
			if self.selected_party_member.party_class not in e.compatible_classes: continue
			if e.equipped and not e in current_equipment.values(): continue
			if self.selected_equip_slot == "left_hand" and e.equipped and e.equip_slot != self.selected_equip_slot and not e.left_equipped: continue
			if self.selected_equip_slot == "right_hand" and e.equipped and e.left_equipped: continue
			items.append(e)
		self.current_equip_items = items
		page_index = self.equipment_item_index/EQUIPMENT_PAGE_SIZE
		start = page_index*EQUIPMENT_PAGE_SIZE 
		end =  min(len(items), start + EQUIPMENT_PAGE_SIZE)
		for i in range(start, end):
			item = items[i]
			text = item.name
			if item.equipped: text += item.equip_tag()
			text_image = self.ui_font.render(text, True, WHITE)
			equip_item_pane.blit(text_image, (28, 8 + 40*(i%EQUIPMENT_PAGE_SIZE)))
		index = self.equipment_item_index%EQUIPMENT_PAGE_SIZE
		self.draw_pane_pointer(equip_item_pane, index)
		# TODO: multiple pages of equipment. Navigate w/ left and right arrow keys
		self.draw_equipment_page_numbers(equip_item_pane)
		pane.blit(equip_item_pane, (EQUIPMENT_ITEM_X, EQUIPMENT_ITEM_Y))
예제 #29
0
파일: sprite.py 프로젝트: derrida/shmuppy
class Sprite(DirtySprite):
    """The base sprite class that all sprites inherit."""

    def __init__(self, scene, size, color):
        DirtySprite.__init__(self)
        self.scene = scene
        self.image = Surface(size).convert_alpha()
        self.image.fill(color)
        self.rect = self.image.get_rect()
        self.x, self.y = 0, 0
        self.facing = [0,2]

    def move(self):
        """Move the sprite and set it to dirty for the current frame."""

        self.dirty = 1
        self.rect.move_ip([self.x, self.y])

    def update(self):
        """Update the sprite each frame."""

        if (self.x or self.y):
            self.facing = [self.x, self.y]
            self.move()
            self.collide()
예제 #30
0
class MortarTower(Tower):
    def __init__(self, pos):
        Tower.__init__(self, pos)
        self.name = "Mortar Tower"
        self.image = Surface((40, 40)).convert()
        self.image.fill((0, 0, 255))
        self.projectile = Surface((15, 15)).convert()
        self.projectile.fill((255, 150, 0))
        self.projectile_speed = 3

        self.radius = 300
        self.fire_rate = 3
        self.damage = 15
        self.description = "A long-range tower that fires mortars which " \
                           "explode on impact, dealing damage to all nearby enemies."
        self.cost = 75

        self.frame = TowerFrame(self)

    def update_info(self):
        self.frame = TowerFrame(self)

    def upgrade(self):
        if self.level < 5:
            self.damage += 5
            self.radius += 10
            self.projectile_speed += 0.25
            self.level += 1
            self.update_info()
            return True
        return False
예제 #31
0
# -*- coding:utf-8 -*-
__author__ = 'veles'

from pygame import display, Surface, draw, KEYDOWN, K_ESCAPE,\
    event, time, FULLSCREEN, NOFRAME, font, mouse
import sys
from math import sin, cos, pi

window = display.set_mode((0, 0), FULLSCREEN | NOFRAME)
SIZE = window.get_size()
screen = Surface(SIZE)


def drawing(pos=[0, 0], angle=0, line_size=0):
    draw.aaline(screen, (0, 255, 0), pos,
                (sin(angle + 120 * (pi / 180)) * line_size + pos[0],
                 cos(angle + 120 * (pi / 180)) * line_size + pos[1]), 1)
    draw.aaline(screen, (0, 255, 0), pos,
                (sin(angle + 240 * (pi / 180)) * line_size + pos[0],
                 cos(angle + 240 * (pi / 180)) * line_size + pos[1]), 1)
    draw.aaline(screen, (0, 255, 0), pos,
                (sin(angle + 0 * (pi / 180)) * line_size + pos[0],
                 cos(angle + 0 * (pi / 180)) * line_size + pos[1]), 1)


font.init()
ff = font.Font(None, int(SIZE[0] / 100 * 12.5))

figure_line_size = SIZE[0] / 100 * 3.125

angle = 0  # angle of rotation
예제 #32
0
파일: lobbyscreen.py 프로젝트: IanPlu/Terra
    def render(self, ui_screen):
        super().render(ui_screen)

        player_manager = self.get_manager(Manager.PLAYER)

        game_screen = Surface((RESOLUTION_WIDTH, RESOLUTION_HEIGHT), SRCALPHA,
                              32)
        game_screen.fill(clear_color[Team.RED])

        game_screen.blit(spr_title_text,
                         (self.root_x - spr_title_text.get_width() // 2, 24))

        # Render a minimap preview of the current map
        minimap = draw_map_preview(menu_width - 24, 144, self.bitmap,
                                   self.pieces, self.team_data)
        game_screen.blit(minimap,
                         (self.root_x - minimap.get_width() - 24, self.root_y))

        # Render the current lobby status-- open and filled teams for network games, human and AI teams for local
        if self.is_network_game():
            filled_teams = self.get_manager(Manager.NETWORK).filled_teams
            ai_teams = []
        else:
            filled_teams = dict([(team, get_string(label_strings,
                                                   "HUMAN_TEAM"))
                                 for team in player_manager.human_teams])
            ai_teams = player_manager.ai_teams

        row_y = 0
        for team in self.teams:
            position_x, position_y = self.root_x, self.root_y + row_y * 24 + 1

            is_filled = team in filled_teams.keys()
            x_offset = 0 if is_filled else 16

            game_screen.fill(light_color,
                             (position_x - 24 - 1 + x_offset, position_y - 1,
                              menu_width + 3 - x_offset, 24))
            game_screen.fill(
                light_team_color[team] if is_filled else shadow_color[team],
                (position_x - 24 + x_offset, position_y, menu_width - x_offset,
                 21))

            if team in filled_teams:
                game_screen.blit(
                    draw_text(filled_teams[team], light_color, dark_color),
                    (position_x + 8, position_y + 4))
            elif team in ai_teams:
                personality_type = player_manager.get_ai_player(
                    team).personality.personality_type
                game_screen.blit(
                    get_text(personality_strings, personality_type),
                    (position_x + 8, position_y + 4))
            else:
                game_screen.blit(get_text(label_strings, "OPEN_TEAM"),
                                 (position_x + 8, position_y + 4))

            row_y += 1

        if self.lobby_menu:
            self.lobby_menu.render(game_screen, ui_screen)

        return game_screen
예제 #33
0
    def set_bar_image(self,
                      unfilled_image: pygame.Surface,
                      filled_image: pygame.Surface,
                      stretch_type: int = STRETCH):
        """
        Sets the bar filled and unfilled images to a custom one with a custom fill/stretch type

        :param unfilled_image: pygame.Surface object
        :param filled_image: pygame.Surface object
        :param stretch_type: int of stretch types (0-3 or run PySliders.show_stretch_types() to see the names)
        """
        if stretch_type == STRETCH:
            self.sliderUnfilledBar = pygame.transform.scale(
                unfilled_image, [self.barWidth, self.barThickness])
            self.sliderFilledBar = pygame.transform.scale(
                filled_image, [self.barWidth, self.barThickness])

        elif stretch_type == DUPLICATE:
            y = 0
            unfilled_image_dimensions = unfilled_image.get_size()

            self.sliderUnfilledBar = pygame.Surface(
                (self.barWidth, self.barThickness), pygame.SRCALPHA, 32)
            while y is not None:
                x = 0
                while x is not None:
                    self.sliderUnfilledBar.blit(unfilled_image, [x, y])
                    x += unfilled_image_dimensions[0]
                    if x > self.sliderUnfilledBar.get_width():
                        x = None

                y += unfilled_image_dimensions[1]
                if y > self.sliderUnfilledBar.get_height():
                    y = None

            y = 0
            filled_image_dimensions = filled_image.get_size()

            self.sliderFilledBar = pygame.Surface(
                (self.barWidth, self.barThickness), pygame.SRCALPHA, 32)
            while y is not None:
                x = 0
                while x is not None:
                    self.sliderFilledBar.blit(filled_image, [x, y])
                    x += filled_image_dimensions[0]
                    if x > self.sliderFilledBar.get_width():
                        x = None

                y += filled_image_dimensions[1]
                if y > self.sliderFilledBar.get_height():
                    y = None

        elif stretch_type == FIT:
            resized_bar = aspect_resize(unfilled_image,
                                        [self.barWidth, self.barThickness])
            self.sliderUnfilledBar = pygame.Surface(
                (self.barWidth, self.barThickness), pygame.SRCALPHA, 32)
            self.sliderUnfilledBar.blit(resized_bar, [
                int((self.barXWidth / 2) - (resized_bar.get_width() / 2)),
                int((self.barThickness / 2) - (resized_bar.get_height() / 2))
            ])
            resized_bar = aspect_resize(filled_image,
                                        [self.barWidth, self.barThickness])
            self.sliderFilledBar = pygame.Surface(
                (self.barWidth, self.barThickness), pygame.SRCALPHA, 32)
            self.sliderFilledBar.blit(resized_bar, [
                int((self.barXWidth / 2) - (resized_bar.get_width() / 2)),
                int((self.barThickness / 2) - (resized_bar.get_height() / 2))
            ])

        elif stretch_type == CENTER:
            self.sliderUnfilledBar = pygame.Surface(
                (self.barWidth, self.barThickness), pygame.SRCALPHA, 32)
            self.sliderUnfilledBar.blit(unfilled_image, [
                int((self.barWidth / 2) - (unfilled_image.get_width() / 2)),
                int((self.barThickness / 2) -
                    (unfilled_image.get_height() / 2))
            ])

            self.sliderFilledBar = pygame.Surface(
                (self.barWidth, self.barThickness), pygame.SRCALPHA, 32)
            self.sliderFilledBar.blit(filled_image, [
                int((self.barWidth / 2) - (filled_image.get_width() / 2)),
                int((self.barThickness / 2) - (filled_image.get_height() / 2))
            ])

        else:
            raise ValueError(
                "set_bar_image() expected a stretch_type of value 0-3 but got: {}, "
                .format(stretch_type) +
                "run help({}) to see the names of the presets".format(__name__)
            )
    ('o', 1, 0),  # crate
    (' ', 0, 1),  # floor
    ('x', 1, 1),  # exit
    ('.', 2, 0),  # dot
    ('*', 3, 0),  # player
]
SIZE = 32


def get_tile_rect(x, y):
    """Converts tile indices to a pygame.Rect"""
    return Rect(x * SIZE, y * SIZE, SIZE, SIZE)


def load_tiles():
    """Load tiles and returns a tuple of (image, tile_dict) """
    tile_image = image.load('../../images/tiles.xpm')
    tiles = {}
    for symbol, x, y in TILE_POSITIONS:
        tiles[symbol] = get_tile_rect(x, y)
    return tile_image, tiles


if __name__ == '__main__':
    tile_img, tiles = load_tiles()
    m = Surface((96, 32))
    m.blit(tile_img, get_tile_rect(0, 0), tiles['#'])
    m.blit(tile_img, get_tile_rect(1, 0), tiles[' '])
    m.blit(tile_img, get_tile_rect(2, 0), tiles['*'])
    image.save(m, 'tile_combo.png')
예제 #35
0
    class menuItemSprite(Sprite):
        """The menu item class is used to generate the items with hotkeys, coloring and a return value."""
        def __init__(self, name, colors, data):

            Sprite.__init__(self)
            self.font = menuDefaultFont  #pygame.font.Font('freesansbold.ttf', 18)

            self.hotKey = []
            index = name.find('&')

            if index >= 0:
                self.imageRenderText = (name[:index], name[index + 1],
                                        name[index + 2:])
                self.name = str(name[:index] + name[index + 1] +
                                name[index + 2:])
                self.hotKey.append(eval('K_' + str(name[index + 1].lower())))
            else:
                self.name = name
                self.imageRenderText = (name, '', '')

            self.returnValue = data[0]
            if len(data) > 1:
                for rd in data[1:]:
                    self.hotKey.append(eval(str(rd)))

            self.hilight = False
            self.disabled = False
            self.cleanSurface = Surface(
                self.font.size(self.imageRenderText[0] +
                               self.imageRenderText[1] +
                               self.imageRenderText[2])).convert_alpha()
            self.cleanSurface.fill((0, ) * 4)
            self.image = self.cleanSurface.copy()
            self.rect = self.image.get_rect()

            self.hiColor = colors[0]
            self.hkColor = colors[1]
            self.gray = colors[2]
            self.darkGray = colors[3]

        def update(self):

            self.image = self.cleanSurface.copy()
            sizeSoFar = 0

            if self.disabled:
                self.image.blit(
                    self.font.render(
                        self.imageRenderText[0] + self.imageRenderText[1] +
                        self.imageRenderText[2], 1, self.darkGray), (0, 0))

            elif self.hilight:
                if self.imageRenderText[0] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[0], 1,
                                         self.hiColor), (0, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[0])[0]
                if self.imageRenderText[1] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[1], 1,
                                         self.hkColor), (sizeSoFar, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[1])[0]
                if self.imageRenderText[2] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[2], 1,
                                         self.hiColor), (sizeSoFar, 0))
                pygame.draw.aaline(self.image, (32, 96, 192),
                                   (2, self.rect.h - 2),
                                   (self.rect.w - 2, self.rect.h - 2))

            else:
                if self.imageRenderText[0] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[0], 1,
                                         self.gray), (0, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[0])[0]
                if self.imageRenderText[1] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[1], 1,
                                         self.hkColor), (sizeSoFar, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[1])[0]
                if self.imageRenderText[2] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[2], 1,
                                         self.gray), (sizeSoFar, 0))
예제 #36
0
class menuGroup(Group):
    """A class for a menu, mostly encapsulated, semi-dynamic with subclass menuItemSprites generated from
     a series of tuples in the form: (&Name, reutrn value, optional hotkeys, ...), ...
     e.g. menu = menuGroup(('&Resume', 'play', 'K_ESCAPE'), None, ('&New game', 'new game'), ('&Quit', 'quit'))"""
    class titleSprite(Sprite):
        """The title class of the menu, on the top, text is changable through menu.title.string."""
        def __init__(self):

            Sprite.__init__(self)
            self.rect = Rect(0, 0, 1, 1)
            self.font = menuTitleFont  #pygame.font.Font('freesansbold.ttf', 24)
            self.color = (255, ) * 3
            self.string = 'Paused'
            self.image = self.font.render(self.string, 1, self.color)
            self.rect = self.image.get_rect()
            self.rect.top = 5

        def __setattr__(self, name, value):

            Sprite.__setattr__(self, name, value)

            if name == 'string':
                oldCenterX = self.rect.centerx
                self.image = self.font.render(self.string, 1, self.color)
                self.rect = self.image.get_rect()
                self.rect.centerx = oldCenterX
                self.rect.top = 5

    class versionSprite(Sprite):
        """A subscript in lower right corner of the menu - generally used for version number."""
        def __init__(self, text='menu'):

            Sprite.__init__(self)
            self.subscript = text
            self.font = menuSubFont  #pygame.font.Font('freesansbold.ttf', 10)
            self.color = (255, ) * 3
            self.redraw()

        def redraw(self):

            self.image = self.font.render(self.subscript, 1, self.color)
            self.rect = self.image.get_rect()

    class menuItemSprite(Sprite):
        """The menu item class is used to generate the items with hotkeys, coloring and a return value."""
        def __init__(self, name, colors, data):

            Sprite.__init__(self)
            self.font = menuDefaultFont  #pygame.font.Font('freesansbold.ttf', 18)

            self.hotKey = []
            index = name.find('&')

            if index >= 0:
                self.imageRenderText = (name[:index], name[index + 1],
                                        name[index + 2:])
                self.name = str(name[:index] + name[index + 1] +
                                name[index + 2:])
                self.hotKey.append(eval('K_' + str(name[index + 1].lower())))
            else:
                self.name = name
                self.imageRenderText = (name, '', '')

            self.returnValue = data[0]
            if len(data) > 1:
                for rd in data[1:]:
                    self.hotKey.append(eval(str(rd)))

            self.hilight = False
            self.disabled = False
            self.cleanSurface = Surface(
                self.font.size(self.imageRenderText[0] +
                               self.imageRenderText[1] +
                               self.imageRenderText[2])).convert_alpha()
            self.cleanSurface.fill((0, ) * 4)
            self.image = self.cleanSurface.copy()
            self.rect = self.image.get_rect()

            self.hiColor = colors[0]
            self.hkColor = colors[1]
            self.gray = colors[2]
            self.darkGray = colors[3]

        def update(self):

            self.image = self.cleanSurface.copy()
            sizeSoFar = 0

            if self.disabled:
                self.image.blit(
                    self.font.render(
                        self.imageRenderText[0] + self.imageRenderText[1] +
                        self.imageRenderText[2], 1, self.darkGray), (0, 0))

            elif self.hilight:
                if self.imageRenderText[0] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[0], 1,
                                         self.hiColor), (0, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[0])[0]
                if self.imageRenderText[1] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[1], 1,
                                         self.hkColor), (sizeSoFar, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[1])[0]
                if self.imageRenderText[2] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[2], 1,
                                         self.hiColor), (sizeSoFar, 0))
                pygame.draw.aaline(self.image, (32, 96, 192),
                                   (2, self.rect.h - 2),
                                   (self.rect.w - 2, self.rect.h - 2))

            else:
                if self.imageRenderText[0] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[0], 1,
                                         self.gray), (0, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[0])[0]
                if self.imageRenderText[1] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[1], 1,
                                         self.hkColor), (sizeSoFar, 0))
                    sizeSoFar += self.font.size(self.imageRenderText[1])[0]
                if self.imageRenderText[2] != '':
                    self.image.blit(
                        self.font.render(self.imageRenderText[2], 1,
                                         self.gray), (sizeSoFar, 0))

    class separatorSprite(Sprite):
        """A sprite for (visually) separating menu items."""
        def __init__(self, *args):

            Sprite.__init__(self, *args)

            self.disabled = True

            self.image = pygame.Surface((60, 6)).convert_alpha()
            self.image.fill((0, ) * 4)
            self.image.fill((64, 64, 64, 224), Rect(0, 3, 60, 2))

            self.rect = self.image.get_rect()

    class selectorSprite(Sprite):
        """Little image on the left and right bounding the active menu item."""
        def __init__(self, parent, flipped, *args):

            Sprite.__init__(self, *args)
            self.parent = parent
            self.flipped = flipped

            self.image = pygame.Surface((3, 3))
            self.image.fill(self.parent.borderColor)

            if self.flipped:
                self.image.fill((160, ) * 3, Rect(0, 0, 1, 3))
            else:
                self.image.fill((160, ) * 3, Rect(2, 0, 1, 3))

            self.rect = self.image.get_rect()
            self.parent.add(self)

        def update(self):

            if self.flipped:
                self.rect.left = self.parent.active.rect.right + 8
                self.rect.bottom = self.parent.active.rect.bottom - 8
            else:
                self.rect.right = self.parent.active.rect.left - 8
                self.rect.bottom = self.parent.active.rect.bottom - 8

    def __init__(self, menuItemSet):

        self.visible = False
        self.maxX = 0
        self.maxY = 0

        Group.__init__(self)

        self.title = self.titleSprite()
        self.add(self.title)
        self.maxY += 48 + 5

        self.active = None

        self.bgColor = (8, 24, 34, 224)
        self.borderColor = (32, 96, 192)

        # hilight - hotkey - normal - disabled
        self.menuItemColors = (128, 192, 255), (24, 128,
                                                255), (192, ) * 3, (64, ) * 3

        self.enterSurface = None
        self.offsetOnSurface = (0, 0)

        self.orderList = []

        self.generate(menuItemSet)
        self.redraw()
        self.clearBg = Surface(self.bg.get_size())

        self.getFirst()

        self.selectorSprite(self, False)
        self.selectorSprite(self, True)

    def get_size(self):

        return self.bg.get_size()

    def generate(self, items):

        c = 1

        for i in items:

            if i == None:
                thisSprite = self.separatorSprite()
            else:
                thisSprite = self.menuItemSprite(i[0], self.menuItemColors,
                                                 i[1:])
                thisSprite.order = c
                c += 1
            if thisSprite.image.get_width() > self.maxX:
                self.maxX = thisSprite.image.get_width() + 64
            self.maxY += thisSprite.rect.h + 2
            self.add(thisSprite)

            self.orderList.append(thisSprite)

        self.maxY += 32

        self.bg = Surface(
            (max(self.title.rect.w + 20,
                 self.maxX + 20), self.maxY + 20)).convert_alpha()

    def redraw(self):

        self.bg.fill(self.bgColor)  # img?
        self.rect = self.bg.get_rect()
        pygame.draw.rect(self.bg, self.borderColor, self.rect, 1)

        self.title.rect.centerx = int(self.bg.get_width() / 2)
        self.title.rect.top = 10

        yDrawCounter = self.title.rect.h + 10

        for i in self.orderList:
            i.rect.centerx = int(self.bg.get_width() / 2)
            i.rect.top = yDrawCounter + 6
            yDrawCounter += 6 + i.rect.h

        #~ for i in self:
        #~ if isinstance(i, self.versionSprite):
        #~ i.rect.right = self.rect.right - 3
        #~ i.rect.bottom = self.rect.bottom - 2
        #~ break

    def execute(self, item):

        for i in self:
            if isinstance(i, self.menuItemSprite):
                if i.name == item:
                    if i.disabled:
                        return None
                    else:
                        self.visible = False
                        self.active.hilight = False
                        if self.enterSurface is not None:
                            self.enterSurface.blit(self.clearBg,
                                                   self.offsetOnSurface)
                            #~ self.backupSurface = self.enterSurface.subsurface(Rect(self.backupOffset, (self.rect.w, self.rect.h)))
                            self.enterSurface = None
                        return i.returnValue
        else:
            return None

    def enter(self, enterSurface):

        self.clearBg = Surface((self.rect.w, self.rect.h))
        self.clearBg.blit(enterSurface, (0, 0), self.rect)
        self.enterSurface = enterSurface
        #~ self.backupSurface = Surface((self.rect.w, self.rect.h))
        self.offsetOnSurface = self.rect.left, self.rect.top
        self.visible = True
        self.itemName = ''

        if self.active is None or self.active.disabled:
            self.getFirst()

        print 'menu active:', self.active

    def tick(self, eventList):

        rValue = None

        for event in eventList:

            #~ if event.type == QUIT:
            #~ rValue = 'quit'
            #~ break

            if event.type == KEYDOWN:
                rValue = self.execute(self.checkKeys(event.key))

            if event.type == MOUSEBUTTONDOWN:
                self.itemName = self.checkMouse(event.pos)

            elif event.type == MOUSEBUTTONUP and self.itemName != '':
                if self.itemName == self.checkMouse(event.pos):
                    rValue = self.execute(self.itemName)

            elif event.type == MOUSEMOTION:
                self.checkMouse(event.pos)

        self.clear()
        self.update()
        self.draw()

        return rValue

    def disable(self, item):

        for i in self:
            if isinstance(i, self.menuItemSprite):
                if i.name == item:
                    i.disabled = True
                    if item == self.active:
                        self.getFirst()
                    break

    def enable(self, item):

        for i in self:
            if isinstance(i, self.menuItemSprite):
                if i.name == item:
                    i.disabled = False
                    break

    def draw(self):

        Group.draw(self, self.bg)
        if self.enterSurface is not None:
            self.enterSurface.blit(self.bg, self.rect)

    def get_rect(self):

        return self.bg.get_rect()

    def clear(self):

        Group.clear(self, self.bg, self.clear_callback)
        if self.enterSurface is not None:
            self.enterSurface.blit(self.clearBg, self.rect)

    def getByName(self, item):

        for i in self:
            if isinstance(i, self.menuItemSprite):
                if i.name == item:
                    return i

    def getFirst(self):

        first = None

        for i in self.orderList:
            if isinstance(i, self.menuItemSprite):
                if not i.disabled:
                    first = i
                    break

        if first != None: first.hilight = True
        self.active = first

    def getLast(self):

        last = None

        for i in reversed(self.orderList):
            if isinstance(i, self.menuItemSprite):
                if not i.disabled:
                    last = i
                    break

        if last != None: last.hilight = True
        self.active = last

    def checkKeys(self, key):

        self.active.hilight = False

        if self.active == None or self.active.disabled:
            self.getFirst()
            return None

        if key == K_RETURN or key == K_KP_ENTER or key == K_SPACE:
            return self.active.name

        activeIndex = self.orderList.index(self.active)

        if key == K_UP:

            if activeIndex > 0:

                while activeIndex >= 0:
                    activeIndex -= 1
                    thisItem = self.orderList[activeIndex]
                    if not thisItem.disabled:
                        self.active = thisItem
                        break

            else:
                self.getLast()

        elif key == K_DOWN:

            try:

                while activeIndex < len(self.orderList):
                    activeIndex += 1
                    thisItem = self.orderList[activeIndex]
                    if not thisItem.disabled:
                        self.active = thisItem
                        break

            except IndexError:
                self.getFirst()

        elif key == K_HOME or key == K_PAGEUP:
            self.getFirst()

        elif key == K_END or key == K_PAGEDOWN:
            self.getLast()

        else:
            for i in self:
                if isinstance(i, self.menuItemSprite):
                    if key in i.hotKey and not i.disabled:
                        return i.name

        if self.active != None:
            self.active.hilight = True
        return None

    def checkMouse(self, pos):

        x, y = pos
        x -= self.rect.left
        y -= self.rect.top
        rName = ''

        for item in self:

            if isinstance(item, self.menuItemSprite):

                if item.rect.collidepoint(x, y) and not item.disabled:

                    if self.active != None:
                        self.active.hilight = False

                    self.active = item

                    item.hilight = True
                    rName = item.name

        return rName

    def subscript(self, text=None):

        for i in self:
            if isinstance(i, self.versionSprite):
                self.remove(i)
                break

        if text is not None:

            i = self.versionSprite(text)
            i.rect.right = self.rect.right - 3
            i.rect.bottom = self.rect.bottom - 2
            self.add(i)
            print i.rect

    def clear_callback(self, surf, rect):

        surf.fill(self.bgColor, rect)
예제 #37
0
from Bonus import Bonus

from Camera import Camera

from Menu import Menu

from Target import Target

from pygame import display, Surface, init, sprite, mixer, time, font, Rect,\
                   Color, event, QUIT, KEYDOWN, KEYUP,\
                   K_UP, K_RIGHT, K_ESCAPE, K_LEFT

init()  # Инициализация pygame
window = display.set_mode(WINDOW)  # Создание окна
display.set_caption("Dakota`s run")  # Название окна
screen = Surface(DISPLAY)  # Создание видимой поверхности

# Строка состояния
info_string = Surface((640, 30))

#  Шрифты
font.init()
inf_font = font.Font(None, 32)


# Создание героя
hero = Player(320, 1320)
left = right = up = False

# Создание уровня
with open(LEVEL_1, 'r') as level1:
예제 #38
0
class PygameView:
    def __init__(self, evManager):
        self.evManager = evManager
        self.evManager.RegisterListener(self)

        self.window = display.set_mode((720, 420))
        self.winsize = self.window.get_size()
        display.set_caption("Blokus")
        self.background = Surface(self.window.get_size())
        self.background.fill((255, 255, 255))
        self.window.blit(self.background, (0, 0))
        sbLoc = (len(o.board.matrix) * 20 + 5, 0)
        self.scorebox = {"surf": Surface((100, 200)), "loc": sbLoc}
        self.scorebox["surf"].fill((255, 255, 255))
        self.font = font.Font(None, 40)
        pbLoc = (sbLoc[0] + 100, 0)
        self.piecebox = self.window.subsurface(Rect(pbLoc, (200, 420)))
        self.piecebox.fill((255, 255, 255))
        self.drawBoard()
        self.drawPiece()
        self.drawScores()
        self.drawPlayerPieces()
        display.flip()

    def drawBoard(self):
        csize = o.board.csize
        space = image.load(join("sprites", "space.png"))
        pieceImg = image.load(join("sprites", "piece.jpg"))
        pieceArray = surfarray.array3d(pieceImg)
        for row in o.board.matrix:
            for cell in row:
                self.window.blit(space, (cell.x * csize, cell.y * csize))
                if cell.color:
                    piece = n.array(pieceArray)
                    if cell.color == "r":
                        piece[:, :, 1:] = 0
                    elif cell.color == "g":
                        piece[:, :, [0, 2]] = 0
                    elif cell.color == "b":
                        piece[:, :, :2] = 0
                    elif cell.color == "y":
                        piece[:, :, 2] = 0
                    surfarray.blit_array(pieceImg, piece)
                    self.window.blit(pieceImg,
                                     (cell.x * csize + 1, cell.y * csize + 1))

    def drawPiece(self):
        csize = o.board.csize
        pieceImg = image.load(join("sprites", "piece.jpg"))
        p = o.players.cur
        pieceArray = surfarray.array3d(pieceImg)
        if p.c == "r":
            pieceArray[:, :, 1:] = 0
        elif p.c == "g":
            pieceArray[:, :, [0, 2]] = 0
        elif p.c == "b":
            pieceArray[:, :, :2] = 0
        elif p.c == "y":
            pieceArray[:, :, 2] = 0
        surfarray.blit_array(pieceImg, pieceArray)
        pieceImg.set_alpha(175)
        bpos = n.array((p.pos[0] * csize + 1, p.pos[1] * csize + 1))
        for r in range(len(p.curPiece.m)):
            for c in range(len(p.curPiece.m[0])):
                if p.curPiece.m[r][c] == 1:
                    pos = n.array((c * csize, r * csize))
                    self.window.blit(pieceImg, bpos + pos)

    def drawScores(self):
        self.scorebox["surf"].fill((255, 255, 255))
        scores = []
        for player in o.players.players:
            scores.append(
                self.font.render(player.c + ": " + str(player.score), True,
                                 (0, 0, 0)))
        for s in range(len(scores)):
            self.scorebox["surf"].blit(scores[s], (0, s * 50))
        self.window.blit(self.scorebox["surf"], self.scorebox["loc"])

    def drawPlayerPieces(self):
        self.piecebox.fill((255, 255, 255))
        pieceImg = image.load(join("sprites", "piecesmall.jpg"))

        pieceArrays = {
            "r": surfarray.array3d(pieceImg),
            "g": surfarray.array3d(pieceImg),
            "b": surfarray.array3d(pieceImg),
            "y": surfarray.array3d(pieceImg)
        }
        pieceArrays["r"][:, :, 1:] = 0
        pieceArrays["g"][:, :, [0, 2]] = 0
        pieceArrays["b"][:, :, :2] = 0
        pieceArrays["y"][:, :, 2] = 0

        bpos = n.array((0, 0))
        for player in o.players.players:
            surfarray.blit_array(pieceImg, pieceArrays[player.c])
            for size in player.pieces.keys():
                for p in player.pieces[size]:
                    if len(p.m) < len(p.m[0]):
                        isTaller = True
                        h = len(p.m)
                        psize = (9 * len(p.m[0]), 9 * len(p.m))
                    else:
                        isTaller = False
                        h = len(p.m[0])
                        psize = (9 * len(p.m), 9 * len(p.m[0]))
                    pieceImg.set_alpha(100)
                    if player is o.players.cur:
                        pieceRect = self.piecebox.subsurface(Rect(bpos, psize))
                        o.players.pieces.append((pieceRect, size, p))
                        if p is player.curPiece:
                            pieceImg.set_alpha(255)
                    for r in range(len(p.m)):
                        for c in range(len(p.m[0])):
                            if isTaller:
                                x = c
                                y = r
                            else:
                                x = r
                                y = c
                            if p.m[r][c] == 1:
                                pos = n.array((x * 9, y * 9))
                                if player.c == o.players.cur.c:
                                    pieceRect.blit(pieceImg, pos)
                                else:
                                    self.piecebox.blit(pieceImg, bpos + pos)
                    bpos[1] += h * 9 + 1
            bpos[0] += 50
            bpos[1] = 0

    def Notify(self, event):
        if isinstance(
                event,
            (e.GetPiece, e.RotPiece, e.NextPiece, e.MovePiece, e.SwitchPiece)):
            self.drawBoard()
            self.drawPiece()
            if isinstance(event, (e.GetPiece, e.NextPiece, e.SwitchPiece)):
                self.drawPlayerPieces()
            display.update()
        if isinstance(event, e.NextTurn):
            self.drawBoard()
            self.drawPiece()
            self.drawPlayerPieces()
            self.drawScores()
            display.update()
예제 #39
0
 def __draw_bar(surface: Surface, width: int, height: int, x: int, y: int):
     img = Surface((width, 1))
     img.fill(color)
     surface.blit(img, (x, y - height - bar_height))
예제 #40
0
 def create_label(self, font_color, box_color):
     label_box = Surface((self.label_text.get_rect().width + 40, self.label_text.get_rect().height + 10))
     label_box.fill(box_color)
     self.set_font_color(font_color)
     label_box.blit(self.label_text, (20, 5))
     return label_box
예제 #41
0
def draw_tt(expr: sympy.Symbol):
    """..."""
    font: pygame.font.Font = style.get('.tt-font', 'font')
    color = style.get('.tt-font', 'font-color')
    background = style.get('.tt-item', 'background')
    indent, _, cell_width, _ = style.get('.tt-item', 'rect')
    _, _, width, height = style.get('.infobar-page-tt', 'rect')
    _, sy = style.get('.tt-items', 'shift')

    variables, truth_table = calculate_tt(expr)

    result = Surface((width, height), pygame.SRCALPHA)

    back = Surface((width, (len(truth_table) + 1) * sy))
    back.fill(background)
    result.blit(back, (0, 0))

    for i, var in enumerate(variables + ('RES', )):
        letter = font.render(str(var), True, color << 8)
        result.blit(letter, (indent + i * cell_width, 0))

    # lts = {
    #     '0': font.render('0', True, color << 8),
    #     '1': font.render('1', True, color << 8)
    # }

    lts = {
        '0': style.get('.tt-false', 'icon'),
        '1': style.get('.tt-true', 'icon')
    }
    ix, iy, _, _ = style.get('.tt-false', 'icon-rect')

    for i, res in enumerate(truth_table):
        for j, char in enumerate(
                bin((i << 1) + bool(res))[2:].zfill(len(variables) + 1)):
            result.blit(lts[char],
                        (indent + ix + j * cell_width, iy + (i + 1) * sy))

    return result
예제 #42
0
파일: label.py 프로젝트: Sk00g/arena
 def draw(self, screen: Surface):
     return screen.blit(self.surface, self._get_final_position())
예제 #43
0
class Button(Sprite):
    def __init__(self,
                 x=0,
                 y=0,
                 width=10,
                 height=10,
                 text='',
                 text_size=0,
                 color=(10, 10, 120),
                 alt_text=''):
        Sprite.__init__(self)
        self.image = Surface((width, height))
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.PL_W = width
        self.PL_H = height
        self.text = text
        self.alt_text = alt_text
        if text_size == 0:
            self.font = font.Font(None, width)
        elif text_size > 0:
            self.font = font.Font(None, text_size)
        self.color = color

    def update(self, plitki=[]):
        if len(plitki) > 1:
            for pl in plitki:
                if self != pl:
                    if collide_rect(self, pl):
                        if self.rect.x < pl.rect.x:
                            self.rect.x -= 1
                            pl.rect.x += 1
                        elif self.rect.x > pl.rect.x:
                            self.rect.x += 1
                            pl.rect.x -= 1
                        if self.rect.y < pl.rect.y:
                            self.rect.y -= 1
                            pl.rect.y += 1
                        elif self.rect.y > pl.rect.y:
                            self.rect.y += 1
                            pl.rect.y -= 1
        surf = get_surface()
        if self.rect.x <= 0:
            self.rect.x += 1
        if self.rect.y <= 0:
            self.rect.y += 1
        if self.rect.x + self.rect.w >= surf.get_width():
            self.rect.x -= 1
        if self.rect.y + self.rect.h >= surf.get_height():
            self.rect.y -= 1

        if self.mouse_on_button():
            self.image.fill((255 - self.color[0], 255 - self.color[1],
                             255 - self.color[2]))
            rect(self.image, (125, 125, 125), (0, 0, self.PL_W, self.PL_H), 1)
            self.image.blit(self.font.render(self.text, 1, self.color), (3, 3))
        else:
            self.image.fill(self.color)
            rect(self.image, (255, 255, 255), (0, 0, self.PL_W, self.PL_H), 1)
            self.image.blit(
                self.font.render(self.text, 1,
                                 (255 - self.color[0], 255 - self.color[1],
                                  255 - self.color[2])), (3, 3))

    def onClick(self, mouse_click=False):
        mx, my = get_pos()
        if self.rect.x < mx and self.rect.x + self.PL_W > mx and self.rect.y < my and self.rect.y + self.PL_H > my and mouse_click:
            return 1
        else:
            return 0

    def mouse_on_button(self):
        mx, my = get_pos()
        if self.rect.x < mx and self.rect.x + self.PL_W > mx and self.rect.y < my and self.rect.y + self.PL_H > my:
            return 1
        else:
            return 0
예제 #44
0
def draw_expr(expression: t_Expr, brackets_everywhere: bool = False):
    """Возвращает изображение выражения в математическом виде"""
    bar_height = style.get('.viewer-expression', 'bar')
    font: pygame.font.Font = style.get('.viewer-expression', 'font')
    color = style.get('.viewer-expression', 'font-color')

    interval = style.get('.viewer-expression', 'font-spacing')

    def __priority(operation: int):
        return int(operation == T_AND)

    def __draw_bar(surface: Surface, width: int, height: int, x: int, y: int):
        img = Surface((width, 1))
        img.fill(color)
        surface.blit(img, (x, y - height - bar_height))

    def __draw_symbol(surface: t.Optional[Surface], symbol: str, x: int,
                      y: int):
        img = font.render(symbol, True, color << 8)
        rect = img.get_rect()
        if surface:
            rect.bottomleft = x, y
            surface.blit(img, rect)
        return rect.size

    def __draw_constant(surface: t.Optional[Surface], expr: Constant, x: int,
                        y: int) -> (int, int):
        return __draw_symbol(surface, style.EXPR_CONSTANT_MAPPING[expr.value],
                             x, y)

    def __draw_variable(surface: t.Optional[Surface], expr: Variable, x: int,
                        y: int) -> (int, int):
        return __draw_symbol(surface, style.EXPR_VARIABLE_MAPPING[expr.type],
                             x, y)

    def __draw_operation(surface: t.Optional[Surface], expr: Expression,
                         x: int, y: int) -> (int, int):
        return __draw_symbol(surface,
                             style.EXPR_OPERATION_MAPPING[expr.operation], x,
                             y)

    def __draw_open_bracket(surface: t.Optional[Surface], x: int,
                            y: int) -> (int, int):
        return __draw_symbol(surface, style.EXPR_BRACKETS[0], x, y)

    def __draw_close_bracket(surface: t.Optional[Surface], x: int,
                             y: int) -> (int, int):
        return __draw_symbol(surface, style.EXPR_BRACKETS[1], x, y)

    def __draw_expr(surface: t.Optional[Surface], expr: t_Expr, x: int, y: int,
                    brackets: bool):
        if type(expr) is Constant:
            width, height = __draw_constant(surface, expr, x, y)
            return width, height

        if type(expr) is Variable:
            width, height = __draw_variable(surface, expr, x, y)
            if expr.is_inverted and surface:
                __draw_bar(surface, width, height, x, y)
            return width, height + bar_height * expr.is_inverted

        total = 0

        ob_height = 0
        if brackets:
            width, ob_height = __draw_open_bracket(surface, x, y)
            total += width

        needs_brackets = brackets_everywhere or type(
            expr.operand_1) is Expression and __priority(
                expr.operation) > __priority(expr.operand_1.operation)
        width1, height1 = __draw_expr(surface, expr.operand_1, x + total, y,
                                      needs_brackets)
        total += width1 + interval

        width, op_height = __draw_operation(surface, expr, x + total, y)
        total += width + interval

        needs_brackets = brackets_everywhere or type(
            expr.operand_1) is Expression and __priority(
                expr.operation) > __priority(expr.operand_1.operation)
        width2, height2 = __draw_expr(surface, expr.operand_2, x + total, y,
                                      needs_brackets)
        total += width2

        oc_height = 0
        if brackets:
            width, oc_height = __draw_close_bracket(surface, x + total, y)
            total += width

        height = max(ob_height, height1, op_height, height2, oc_height)

        if expr.is_inverted and surface:
            __draw_bar(surface, total, height, x, y)

        return total, height + bar_height * expr.is_inverted

    size = __draw_expr(None, expression, 0, 0, False)
    result = Surface(size, pygame.SRCALPHA)
    __draw_expr(result, expression, 0, size[1], False)
    return result
예제 #45
0
def __(pos: Tuple[int, int], surface: pg.Surface) -> Tuple[Union[int, float], Union[int, float]]:
    return pos[0], surface.get_height() - pos[1]
예제 #46
0
def draw_scheme(expression: t_Expr):
    """Возвращает изображение выражения в виде схемы"""
    _, _, block_width, block_height = style.get('.board-gates', 'item-rect')
    pad_x, pad_y = style.get('.board-gates', 'shift')
    color = style.get('.board-gates-and', 'outline')
    shift = 10

    def __draw_line(surface: Surface, pos1: (int, int), pos2: (int, int)):
        x1, y1 = pos1
        x2, y2 = pos2
        pygame.draw.line(surface, color, (x1, y1), (x1 - shift, y1), 2)
        pygame.draw.line(surface, color, (x2, y2), (x2 + shift, y2), 2)
        pygame.draw.line(surface, color, (x1 - shift, y1), (x2 + shift, y2), 2)

    def __draw_block(surface: Surface, element: str,
                     rect: (int, int, int, int)):
        style.blit_button(surface, element, rect)

    def __draw_block_constant(surface: Surface, expr: Constant, x: int,
                              y: int):
        element = f'.board-gates-{style.CONSTANT_MAPPING[expr.value]}'
        __draw_block(surface, element, (x, y, block_width, block_height))

    def __draw_block_variable(surface: Surface, expr: Variable, x: int,
                              y: int):
        element = f'.board-gates-{style.VARIABLE_MAPPING[(expr.type, expr.is_inverted)]}'
        __draw_block(surface, element, (x, y, block_width, block_height))

    def __draw_block_operation(surface: Surface, expr: Expression, x: int,
                               y: int):
        element = f'.board-gates-{style.OPERATION_MAPPING[(expr.operation, expr.is_inverted)]}'
        __draw_block(surface, element, (x, y, block_width, block_height))

    def __draw_scheme(surface: t.Optional[Surface], expr: t_Expr, x: int,
                      y: int):
        if type(expr) is Constant:
            if surface:
                __draw_block_constant(surface, expr, x, y)
            return block_width, block_height

        if type(expr) is Variable:
            if surface:
                __draw_block_variable(surface, expr, x, y)
            return block_width, block_height

        if surface:
            __draw_line(surface, (x, y + block_height // 3),
                        (x - pad_x, y + block_height // 2))
        width1, height1 = __draw_scheme(surface, expr.operand_1,
                                        x - block_width - pad_x, y)

        if surface:
            __draw_line(surface, (x, y + block_height * 2 // 3),
                        (x - pad_x, y + height1 + pad_y + block_height // 2))
        width2, height2 = __draw_scheme(surface, expr.operand_2,
                                        x - block_width - pad_x,
                                        y + height1 + pad_y)

        if surface:
            __draw_block_operation(surface, expr, x, y)

        return block_width + pad_x + max(width1,
                                         width2), height1 + pad_y + height2

    size = __draw_scheme(None, expression, 0, 0)
    result = Surface(size)
    result.fill(style.get('.projectbar-page-board', 'background'))
    result.set_colorkey(style.get('.projectbar-page-board', 'background'))
    __draw_scheme(result, expression, size[0] - block_width, 0)
    return result
예제 #47
0
 def draw(self, canvas: pygame.Surface):
     if self.has_rect:
         pygame.draw.rect(canvas, self.rect_color, self.lbl_box)
     canvas.blit(self.lbl_obj, self.lbl_box)
예제 #48
0
 def random_circle(screen: pg.Surface, radius: Union[int, float]=1) -> 'Circle':
     x, y = randrange(0, screen.get_width()), randrange(0, screen.get_height())
     return Circle((x, y), radius, screen)
def create_body(size, color):
    surface = Surface(size, pygame.SRCALPHA)
    surface.fill((color[0], color[1], color[2], 155))
    pygame.draw.rect(surface, color, Rect((0, 0), (size[0] - 1, size[1] - 1)),
                     4)
    return surface
예제 #50
0
 def draw(self, screen: pygame.Surface):
     x, y = pygame.mouse.get_pos()
     piece_rect = self.piece.get_sprite_rect()
     coords = x - piece_rect.width / 2, y - piece_rect.height / 2
     screen.blit(Piece.SPRITE, coords, self.piece.get_sprite_rect())
예제 #51
0
 def draw_to_surface(self, surface : pygame.Surface, x_offset, y_offset):
     if self.active:
         surface.blit(self.image, (self.x+x_offset, self.y+y_offset))
예제 #52
0
class Status_bar:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.surface = Surface((360, 60))
        self.surface.fill((65, 56, 231))
        self.surface.set_colorkey((65, 56, 231))
        self.surface.set_alpha(200)
        self.image = load("images/status_bar/status_bar.png")
        self.hp_image = load('images/status_bar/hp.png')
        self.friend_image = load('images/tanks/player_up_1.png')
        self.friend_image.set_colorkey((255, 255, 255))
        self.enemy_image = load('images/tanks/enemy_up_1.png')
        self.enemy_image.set_colorkey((255, 255, 255))
        self.font = font.Font('fonts/ComicTalecopy.ttf', 32)

    def show(self, hp, friends, enemies, lvl, scr, scr_w):
        self.surface.blit(self.image, (0, 0))
        self.surface.blit(self.hp_image, (10, 10))
        self.surface.blit(self.font.render('X' + str(hp), 1, (255, 255, 255)),
                          (55, 15))

        self.surface.blit(self.friend_image, (110, 10))
        self.surface.blit(
            self.font.render('X' + str(friends - 1), 1, (255, 255, 255)),
            (155, 15))

        self.surface.blit(self.enemy_image, (210, 10))
        self.surface.blit(
            self.font.render('X' + str(enemies), 1, (255, 255, 255)),
            (255, 15))

        scr.blit(self.surface, (0, 0))
        scr.blit(self.font.render('Stage ' + str(lvl), 1, (255, 255, 255)),
                 (1366 - self.font.size('stage' + str(lvl))[0] - 20, 10))
예제 #53
0
    def info_surf(self):

        textcolor = (255, 255, 255)
        font = pygame.font.Font(None, 30)
        width = (WIDTH-(MATRIS_OFFSET+BLOCKSIZE*MATRIX_WIDTH+BORDERWIDTH*2)) - MATRIS_OFFSET*2

        def renderpair(text, val):
            text = font.render(text, True, textcolor)
            val = font.render(str(val), True, textcolor)

            surf = Surface((width, text.get_rect().height + BORDERWIDTH*2), pygame.SRCALPHA, 32)

            surf.blit(text, text.get_rect(top=BORDERWIDTH+10, left=BORDERWIDTH+10))
            surf.blit(val, val.get_rect(top=BORDERWIDTH+10, right=width-(BORDERWIDTH+10)))
            return surf

        scoresurf = renderpair("Score", self.matris.score)
        levelsurf = renderpair("Level", self.matris.level)
        linessurf = renderpair("Lines", self.matris.lines)
        combosurf = renderpair("Combo", "x{}".format(self.matris.combo))

        height = 20 + (levelsurf.get_rect().height + 
                       scoresurf.get_rect().height +
                       linessurf.get_rect().height + 
                       combosurf.get_rect().height )

        area = Surface((width, height))
        area.fill(BORDERCOLOR)
        area.fill(BGCOLOR, Rect(BORDERWIDTH, BORDERWIDTH, width-BORDERWIDTH*2, height-BORDERWIDTH*2))

        area.blit(levelsurf, (0,0))
        area.blit(scoresurf, (0, levelsurf.get_rect().height))
        area.blit(linessurf, (0, levelsurf.get_rect().height + scoresurf.get_rect().height))
        area.blit(combosurf, (0, levelsurf.get_rect().height + scoresurf.get_rect().height + linessurf.get_rect().height))

        return area
예제 #54
0
def rotozoom(surface: pygame.Surface, angle, scale):
    width, height = surface.get_rect().size
    new_surface = pygame.transform.scale(
        surface, (floor(width * scale), floor(height * scale)))
    new_surface = pygame.transform.rotate(new_surface, angle)
    return new_surface
예제 #55
0
class Matris(object):
    def __init__(self, size=(MATRIX_WIDTH, MATRIX_HEIGHT), blocksize=BLOCKSIZE):
        self.size = {'width': size[0], 'height': size[1]}
        self.blocksize = blocksize
        self.surface = Surface((self.size['width']  * self.blocksize,
                                (self.size['height']-2) * self.blocksize))


        self.matrix = dict()
        for y in range(self.size['height']):
            for x in range(self.size['width']):
                self.matrix[(y,x)] = None


        self.next_tetromino = random.choice(list_of_tetrominoes)
        self.set_tetrominoes()
        self.tetromino_rotation = 0
        self.downwards_timer = 0
        self.base_downwards_speed = 0.4 # Move down every 400 ms

        self.movement_keys = {'left': 0, 'right': 0}
        self.movement_keys_speed = 0.05
        self.movement_keys_timer = (-self.movement_keys_speed)*2

        self.level = 1
        self.score = 0
        self.lines = 0

        self.combo = 1 # Combo will increase when you clear lines with several tetrominos in a row
        
        self.paused = False
        self.gameover = False

        self.highscore = load_score()
        self.played_highscorebeaten_sound = False

        self.levelup_sound  = get_sound("levelup.wav")
        self.gameover_sound = get_sound("gameover.wav")
        self.linescleared_sound = get_sound("linecleared.wav")
        self.highscorebeaten_sound = get_sound("highscorebeaten.wav")


    def set_tetrominoes(self):
        self.current_tetromino = self.next_tetromino
        self.next_tetromino = random.choice(list_of_tetrominoes)
        self.surface_of_next_tetromino = self.construct_surface_of_next_tetromino()
        self.tetromino_position = (0,4) if len(self.current_tetromino.shape) == 2 else (0, 3)
        self.tetromino_rotation = 0
        self.tetromino_block = self.block(self.current_tetromino.color)
        self.shadow_block = self.block(self.current_tetromino.color, shadow=True)

    
    def hard_drop(self):
        amount = 0
        while self.request_movement('down'):
            amount += 1

        self.lock_tetromino()
        self.score += 10*amount

    def update(self, timepassed):
        pressed = lambda key: event.type == pygame.KEYDOWN and event.key == key
        unpressed = lambda key: event.type == pygame.KEYUP and event.key == key

        events = pygame.event.get()
        
        for event in events:
            if pressed(pygame.K_p):
                self.surface.fill((0,0,0))
                self.paused = not self.paused
            elif event.type == pygame.QUIT:
                self.prepare_and_execute_gameover(playsound=False)
                exit()
            elif pressed(pygame.K_ESCAPE):
                self.prepare_and_execute_gameover(playsound=False)

        if self.paused:
            return

        for event in events:
            if pressed(pygame.K_SPACE):
                self.hard_drop()
            elif pressed(pygame.K_UP) or pressed(pygame.K_w):
                self.request_rotation()

            elif pressed(pygame.K_LEFT) or pressed(pygame.K_a):
                self.request_movement('left')
                self.movement_keys['left'] = 1
            elif pressed(pygame.K_RIGHT) or pressed(pygame.K_d):
                self.request_movement('right')
                self.movement_keys['right'] = 1

            elif unpressed(pygame.K_LEFT) or unpressed(pygame.K_a):
                self.movement_keys['left'] = 0
                self.movement_keys_timer = (-self.movement_keys_speed)*2
            elif unpressed(pygame.K_RIGHT) or unpressed(pygame.K_d):
                self.movement_keys['right'] = 0
                self.movement_keys_timer = (-self.movement_keys_speed)*2




        self.downwards_speed = self.base_downwards_speed ** (1 + self.level/10.)

        self.downwards_timer += timepassed
        downwards_speed = self.downwards_speed*0.10 if any([pygame.key.get_pressed()[pygame.K_DOWN],
                                                            pygame.key.get_pressed()[pygame.K_s]])   else self.downwards_speed
        if self.downwards_timer > downwards_speed:
            if not self.request_movement('down'):
                self.lock_tetromino()
            self.downwards_timer %= downwards_speed


        if any(self.movement_keys.values()):
            self.movement_keys_timer += timepassed
        if self.movement_keys_timer > self.movement_keys_speed:
            result = self.request_movement('right' if self.movement_keys['right'] else 'left')
            self.movement_keys_timer %= self.movement_keys_speed

        with_shadow = self.place_shadow()

        try:
            with_tetromino = self.blend(self.rotated(), allow_failure=False, matrix=with_shadow)
        except BrokenMatrixException:
            self.prepare_and_execute_gameover()
            return

        for y in range(self.size['height']):
            for x in range(self.size['width']):

                #                                       I hide the 2 first rows by drawing them outside of the surface
                block_location = Rect(x*self.blocksize, (y*self.blocksize - 2*self.blocksize), self.blocksize, self.blocksize)
                if with_tetromino[(y,x)] is None:
                    self.surface.fill(BGCOLOR, block_location)
                else:
                    if with_tetromino[(y,x)][0] == 'shadow':
                        self.surface.fill(BGCOLOR, block_location)
                    
                    self.surface.blit(with_tetromino[(y,x)][1], block_location)
                    
    def prepare_and_execute_gameover(self, playsound=True):
        if playsound:
            self.gameover_sound.play()
        write_score(self.score)
        self.gameover = True

    def place_shadow(self):
        posY, posX = self.tetromino_position
        while self.blend(position=(posY, posX)):
            posY += 1

        position = (posY-1, posX)

        return self.blend(position=position, block=self.shadow_block, shadow=True) or self.matrix
        # If the blend isn't successful just return the old matrix. The blend will fail later in self.update, it's game over.

    def fits_in_matrix(self, shape, position):
        posY, posX = position
        for x in range(posX, posX+len(shape)):
            for y in range(posY, posY+len(shape)):
                if self.matrix.get((y, x), False) is False and shape[y-posY][x-posX]: # outside matrix
                    return False

        return position
                    

    def request_rotation(self):
        rotation = (self.tetromino_rotation + 1) % 4
        shape = self.rotated(rotation)

        y, x = self.tetromino_position

        position = (self.fits_in_matrix(shape, (y, x)) or
                    self.fits_in_matrix(shape, (y, x+1)) or
                    self.fits_in_matrix(shape, (y, x-1)) or
                    self.fits_in_matrix(shape, (y, x+2)) or
                    self.fits_in_matrix(shape, (y, x-2)))
        # ^ Thats how wall-kick is implemented

        if position and self.blend(shape, position):
            self.tetromino_rotation = rotation
            self.tetromino_position = position
            return self.tetromino_rotation
        else:
            return False
            
    def request_movement(self, direction):
        posY, posX = self.tetromino_position
        if direction == 'left' and self.blend(position=(posY, posX-1)):
            self.tetromino_position = (posY, posX-1)
            return self.tetromino_position
        elif direction == 'right' and self.blend(position=(posY, posX+1)):
            self.tetromino_position = (posY, posX+1)
            return self.tetromino_position
        elif direction == 'up' and self.blend(position=(posY-1, posX)):
            self.tetromino_position = (posY-1, posX)
            return self.tetromino_position
        elif direction == 'down' and self.blend(position=(posY+1, posX)):
            self.tetromino_position = (posY+1, posX)
            return self.tetromino_position
        else:
            return False

    def rotated(self, rotation=None):
        if rotation is None:
            rotation = self.tetromino_rotation
        return rotate(self.current_tetromino.shape, rotation)

    def block(self, color, shadow=False):
        colors = {'blue':   (27, 34, 224),
                  'yellow': (225, 242, 41),
                  'pink':   (242, 41, 195),
                  'green':  (22, 181, 64),
                  'red':    (204, 22, 22),
                  'orange': (245, 144, 12),
                  'cyan':   (10, 255, 226)}


        if shadow:
            end = [40] # end is the alpha value
        else:
            end = [] # Adding this to the end will not change the array, thus no alpha value

        border = Surface((self.blocksize, self.blocksize), pygame.SRCALPHA, 32)
        border.fill(map(lambda c: c*0.5, colors[color]) + end)

        borderwidth = 2

        box = Surface((self.blocksize-borderwidth*2, self.blocksize-borderwidth*2), pygame.SRCALPHA, 32)
        boxarr = pygame.PixelArray(box)
        for x in range(len(boxarr)):
            for y in range(len(boxarr)):
                boxarr[x][y] = tuple(map(lambda c: min(255, int(c*random.uniform(0.8, 1.2))), colors[color]) + end) 

        del boxarr # deleting boxarr or else the box surface will be 'locked' or something like that and won't blit.
        border.blit(box, Rect(borderwidth, borderwidth, 0, 0))


        return border

    def lock_tetromino(self):

        self.matrix = self.blend()

        lines_cleared = self.remove_lines()
        self.lines += lines_cleared

        if lines_cleared:
            if lines_cleared >= 4:
                self.linescleared_sound.play()
            self.score += 100 * (lines_cleared**2) * self.combo

            if not self.played_highscorebeaten_sound and self.score > self.highscore:
                if self.highscore != 0:
                    self.highscorebeaten_sound.play()
                self.played_highscorebeaten_sound = True

        if self.lines >= self.level*10:
            self.levelup_sound.play()
            self.level += 1

        self.combo = self.combo + 1 if lines_cleared else 1

        self.set_tetrominoes()

    def remove_lines(self):
        lines = []
        for y in range(self.size['height']):
            line = (y, [])
            for x in range(self.size['width']):
                if self.matrix[(y,x)]:
                    line[1].append(x)
            if len(line[1]) == self.size['width']:
                lines.append(y)

        for line in sorted(lines):
            for x in range(self.size['width']):
                self.matrix[(line,x)] = None
            for y in range(0, line+1)[::-1]:
                for x in range(self.size['width']):
                    self.matrix[(y,x)] = self.matrix.get((y-1,x), None)

        return len(lines)

    def blend(self, shape=None, position=None, matrix=None, block=None, allow_failure=True, shadow=False):
        if shape is None:
            shape = self.rotated()
        if position is None:
            position = self.tetromino_position

        copy = dict(self.matrix if matrix is None else matrix)
        posY, posX = position
        for x in range(posX, posX+len(shape)):
            for y in range(posY, posY+len(shape)):
                if (copy.get((y, x), False) is False and shape[y-posY][x-posX] # shape is outside the matrix
                    or # coordinate is occupied by something else which isn't a shadow
                    copy.get((y,x)) and shape[y-posY][x-posX] and copy[(y,x)][0] != 'shadow'): 
                    if allow_failure:
                        return False
                    else:
                        raise BrokenMatrixException("Tried to blend a broken matrix. This should mean game over, if you see this it is certainly a bug. (or you are developing)")
                elif shape[y-posY][x-posX] and not shadow:
                    copy[(y,x)] = ('block', self.tetromino_block if block is None else block)
                elif shape[y-posY][x-posX] and shadow:
                    copy[(y,x)] = ('shadow', block)

        return copy

    def construct_surface_of_next_tetromino(self):
        shape = self.next_tetromino.shape
        surf = Surface((len(shape)*self.blocksize, len(shape)*self.blocksize), pygame.SRCALPHA, 32)

        for y in range(len(shape)):
            for x in range(len(shape)):
                if shape[y][x]:
                    surf.blit(self.block(self.next_tetromino.color), (x*self.blocksize, y*self.blocksize))
        return surf
예제 #56
0
    def render(self, surface: pg.Surface):
        surface.fill(BLACK)
        for object in self.objects.values():
            pg.draw.lines(surface, WHITE, True, object)

        self.mask = pg.mask.from_threshold(surface, WHITE, (1, 1, 1, 255))
예제 #57
0
    def render(self, target_surf: pygame.Surface, offset: Optional[List[int]] = None):
        """
        The core rendering function that renders the lighting within the lightbox. The offset is used to specify
        the terrain offset (aka camera offset or scroll) of the game relative to the viewed area.

        The `target_surface` is the `pygame.Surface` that will have the lighting rendered onto it. If it is a black
        surface, you get the internal lighting mask. This can be useful for static lighting. However, normally the
        main display surface should be used.
        """
        # avoid mutable default
        if offset is None:
            offset = [0, 0]
        assert isinstance(offset, list)

        # get the max light radius to determine which lights need to be rendered
        # if a light center is farther away from the viewing range than its radius, it's off the screen
        # if the light's modifications don't reach onto the screen, then its shadows won't have an effect,
        # so it's not necessary to process
        max_radius = self._get_max_light_radius()

        # define an updated render_box rect with respect to the terrain offset and the light range to determine which
        # walls needs to be processed
        render_box_r = pygame.Rect(
            -max_radius + offset[0],
            -max_radius + offset[1],
            self.vision_box_r.width + max_radius * 2,
            self.vision_box_r.height + max_radius * 2,
        )

        # get all visible walls by using the chunk indexes
        valid_wall_dict = {}
        for y in range(self.vision_box_r.height // self.chunk_size + self.chunk_overshoot * 2 + 1):
            for x in range(self.vision_box_r.width // self.chunk_size + self.chunk_overshoot * 2 + 1):
                chunk_str = (
                    str(int(x - self.chunk_overshoot // 2 + offset[0] // self.chunk_size))
                    + ";"
                    + str(int(y - self.chunk_overshoot // 2 + offset[1] // self.chunk_size))
                )
                if chunk_str in self.chunk_walls:
                    valid_wall_dict.update(self.chunk_walls[chunk_str])
        valid_walls = list(valid_wall_dict.values())
        for group in self.dynamic_walls:
            valid_walls += self.dynamic_walls[group]

        # adjust for offset to get the "shown position"
        valid_walls = [
            wall.clone_move([-offset[0], -offset[1]]) for wall in valid_walls if wall.rect.colliderect(render_box_r)
        ]

        # redefine the render_box rect with the terrain offset removed since the walls have been moved
        render_box_r = pygame.Rect(
            -max_radius,
            -max_radius,
            self.vision_box_r.width + max_radius * 2,
            self.vision_box_r.height + max_radius * 2,
        )

        # generate a Surface to render the lighting mask onto
        rendered_mask = pygame.Surface(self.vision_box_r.size)

        # iterate through all of the lights
        for light in self.lights.values():
            # apply the terrain offset
            light_pos = [light.position[0] - offset[0], light.position[1] - offset[1]]
            # check for visibility (don't forget that the current rect is adjusted for the radii of the lights)
            if render_box_r.collidepoint(light_pos):
                # apply lighting image
                light_instance_surf = light.light_img.copy()
                light_offset = [light_pos[0] - light.radius, light_pos[1] - light.radius]

                # draw over the light image with the shadows of each wall (the draw_shadow function only draws if
                # applicable, so a polygon isn't drawn every time)
                for wall in valid_walls:
                    wall.draw_shadow(light_instance_surf, light_pos, render_box_r, (0, 0, 0), light_offset)

                # blit lighting mask onto main surface with RGBA_ADD so that the lighting can accumulate
                rendered_mask.blit(light_instance_surf, light_offset, special_flags=BLEND_RGBA_ADD)

                # update the light
                light.update()

        # blit the final lighting mask onto the target surface
        target_surf.blit(rendered_mask, (0, 0), special_flags=self.blit_flags)

        # return the list of visible walls in case they need to be used for anything
        return valid_walls
예제 #58
0
    def main(self, screen):
        clock = pygame.time.Clock()
        background = Surface(screen.get_size())

        background.blit(construct_nightmare(background.get_size()), (0,0))

        self.matris = Matris()
        matris_border = Surface((MATRIX_WIDTH*BLOCKSIZE+BORDERWIDTH*2, VISIBLE_MATRIX_HEIGHT*BLOCKSIZE+BORDERWIDTH*2))
        matris_border.fill(BORDERCOLOR)

        while 1:
            dt = clock.tick(45)

            self.matris.update((dt / 1000.) if not self.matris.paused else 0)
            if self.matris.gameover:
                return

            tricky_centerx = WIDTH-(WIDTH-(MATRIS_OFFSET+BLOCKSIZE*MATRIX_WIDTH+BORDERWIDTH*2))/2

            background.blit(matris_border, (MATRIS_OFFSET,MATRIS_OFFSET))
            background.blit(self.matris.surface, (MATRIS_OFFSET+BORDERWIDTH, MATRIS_OFFSET+BORDERWIDTH))

            nextts = self.next_tetromino_surf(self.matris.surface_of_next_tetromino)
            background.blit(nextts, nextts.get_rect(top=MATRIS_OFFSET, centerx=tricky_centerx))

            infos = self.info_surf()
            background.blit(infos, infos.get_rect(bottom=HEIGHT-MATRIS_OFFSET, centerx=tricky_centerx))


            screen.blit(background, (0, 0))

            pygame.display.flip()
예제 #59
0
class Image:
    def __init__(self, size=(0, 0), blend_flag=None, context=None):
        self.blend_flag = blend_flag
        self.surface = None
        self.paintSurface = None
        self.linkedImages = {}  # linked images
        self.blitOrder = []
        self.superImage = None  #The parent image
        self.painters = {}
        if not context:
            self.contextData = Context()
        else:
            self.contextData = context
        self.contextData.init_context_vars({
            "pos": (0, 0),
            "absolutePos": (0, 0),
            "size": size,
            "scroll": (0, 0)
        })
        self.contextData.addContextListner("pos", self.onPosChange)
        self.contextData.addContextListner("size", self.onSizeChange)
        self.queReblit = True

    def getSuperImage(self):
        return self.superImage

    def getRootImage(self):
        if self.superImage:
            return self.superImage.getRootImage()
        return self

    def getDepth(self):
        if (self.superImage):
            return self.superImage.getDepth() + 1
        return 0

    def dumpRenderTree(self):
        depth = self.getDepth()
        for e in self.blitOrder:
            print(depth * "=", e)
            self.linkedImages[e].dumpRenderTree()

    def getContext(self):
        return self.contextData

    def getImageSize(self):
        return self.size

    def linkImage(self, imageID, image):
        if (image not in self.linkedImages):
            self.linkedImages[imageID] = image
            print(self.getDepth() * "~", self)
            if (imageID not in self.blitOrder):
                self.blitOrder += [imageID]
            image.superImage = self
        else:
            print("Image already linked, cannot link again")

    def unlinkImage(self, imageID):
        if (imageID in self.linkedImages):
            del self.linkedImages[imageID]
            self.blitOrder.remove(imageID)
            image.superImage = None
        else:
            print("Image not linked, cannot unlink")

    def getLinkedImage(self, imageID):
        if (imageID in self.linkedImages):
            return self.linkedImages[imageID]

    def addPainter(self, id, painter: Painter):
        self.painters[id] = painter
        painter.boundImage = self
        return painter

    def getPainter(self, id):
        if (id in self.painters):
            return self.painters[id]

    def onSizeChange(self, old, new):
        pass

    def removePainter(self, id):
        del self.painters[id]

    def create_image(self):
        try:
            self.surface = Surface(self.contextData.size).convert_alpha()
            self.surface.fill((0, 0, 0, 0))
            self.paintSurface = self.surface.copy()
        except ValueError as e:
            print(self.contextData.size)
            raise e

    def getSurface(self):
        if (self.contextData.hasChanged):
            self.contextData.clearChange()
        return self.surface

    def blitLayers(self):
        if not (pygame.display.get_init()):
            return

        if not (self.queReblit): return
        #depth = self.getDepth()
        #print("-"*depth,"blitting: ",self)
        if not (self.surface): self.create_image()
        self.surface.fill((0, 0, 0, 0))
        self.surface.blit(self.paintSurface, (0, 0))
        for e in self.blitOrder:
            img = self.linkedImages[e]
            if (img.getSurface()):
                self.surface.blit(img.getSurface(),
                                  img.getContext().absolutePos)
        self.queReblit = False

    def applyPainters(self):
        #depth = self.getDepth()
        #print("-"*depth,"painting: ",self)
        self.paintSurface.fill((0, 0, 0, 0))
        for i, e in self.painters.items():
            #print("-"*(depth+1),"painter: ",i)
            e.apply(self.paintSurface)

    def onPosChange(self, old, new):
        self.reblit()
        pass

    def reblit(self):
        self.queReblit = True
        if (self.superImage): self.superImage.reblit()

    def repaint(self):
        #print("repaint", self)
        if not (self.surface): return
        self.applyPainters()
        self.reblit()
        pass

    def render(self):
        if not (pygame.display.get_init()):
            return
        #depth = self.getDepth()
        #print("-"*depth,"rendering: ",self.contextData)
        self.create_image()
        self.applyPainters()
        for e, i in self.linkedImages.items():
            i.render()
        self.blitLayers()

    def maintain(self):
        for e, i in self.linkedImages.items():
            if (i.queReblit):
                i.maintain()
        self.blitLayers()
예제 #60
0
 def reset_screen(self, screen: pygame.Surface):
     """Shows a screen containing only a grid of blocks"""
     screen.fill(Colors.BLACK)
     self.display_borders(screen)