Пример #1
0
def interaction(screen, player):

    Mpos = pygame.mouse.get_pos()
    Mx = Mpos[0] // Tile.width
    My = Mpos[1] // Tile.height
    
    for event in pygame.event.get():
        
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if event.type == pygame.MOUSEBUTTONDOWN:
            for tile in Tile.List:
                if tile.x == (Mx * Tile.width) and tile.y == (My * Tile.width):
                    tile.type = 'solid'
                    tile.walkable = False
                    break

    keys = pygame.key.get_pressed()
    

    if keys[pygame.K_w]: # North
        future_tile_number = player.get_number() - Tile.V
        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('n')
                #player.y -= player.height                   

    if keys[pygame.K_s]: # South
        future_tile_number = player.get_number() + Tile.V
        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('s')
                #player.y += player.height 

    if keys[pygame.K_a]: # West
        future_tile_number = player.get_number() - Tile.H
        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('w')
                
                #player.x -= player.width 

    if keys[pygame.K_d]: # East
        future_tile_number = player.get_number() + Tile.H

        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('e')
Пример #2
0
def gameLoop():
    pygame.init()
    pygame.font.init()
    #pygame.mixer.init()

    #pygame.mixer.music.load("audio/halo_themes.wav")
    #pygame.mixer.music.play(-1)

    invalids = tuple(invalids_func())

    for y in range(0, screen.get_height(), 32):
        for x in range(0, screen.get_width(), 32):
            if Tile.total_tiles in invalids:
                Tile(x, y, 'solid')
            else:
                Tile(x, y, 'empty')

    #set time
    #clock = pygame.time.Clock()
    FPS = 24
    total_frames = 0

    background = pygame.image.load('images/Background.png')
    player = Player(64, 128)

    while player.health > 1:

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

        Enemy.spawn(total_frames, FPS)
        Enemy.update(screen, player)

        player.movement()

        Bullet.super_massive_jumbo_loop(screen)

        A_Star(screen, player, total_frames, FPS)
        interaction(screen, player)
        player.draw(screen)

        Func.text_to_screen(screen, "Health {0}".format(player.health), 0, 0)

        pygame.display.flip()
        clock.tick(FPS)
        total_frames += 1

        if player.health <= 0:
            sleep(2)
            screen.blit(pygame.image.load("images/End.png"), (0, 0))
            pygame.display.update()
            break

    sleep(4)
Пример #3
0
def interaction(screen, player):

    Mpos = pygame.mouse.get_pos()
    Mx = Mpos[0] // Tile.width
    My = Mpos[1] // Tile.height

    for event in pygame.event.get():

        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if event.type == pygame.MOUSEBUTTONDOWN:
            for tile in Tile.List:
                if tile.x == (Mx * Tile.width) and tile.y == (My * Tile.width):
                    tile.type = 'solid'
                    tile.walkable = False
                    break

        if event.type == pygame.KEYDOWN:

            #North
            if event.key == pygame.K_w:
                future_tile_number = player.get_number() - Tile.V

                if Tile.get_tile(future_tile_number).walkable:
                    player.y -= player.height

            #South
            if event.key == pygame.K_s:
                future_tile_number = player.get_number() + Tile.V

                if Tile.get_tile(future_tile_number).walkable:
                    player.y += player.height

            #West
            if event.key == pygame.K_a:
                future_tile_number = player.get_number() - Tile.H

                if Tile.get_tile(future_tile_number).walkable:
                    player.x -= player.width

            #East
            if event.key == pygame.K_d:
                future_tile_number = player.get_number() + Tile.H

                if Tile.get_tile(future_tile_number).walkable:
                    player.x += player.width
Пример #4
0
    def get_surrounding_tiles(base_node):

        array = (
            (base_node.number + N),
            (base_node.number + NE),
            (base_node.number + E),
            (base_node.number + SE),
            (base_node.number + S),
            (base_node.number + SW),
            (base_node.number + W),
            (base_node.number + NW)
            )

        tiles = []

        #original node number
        onn = base_node.number
        diagonals = [onn + NE, onn + NW, onn + SE, onn + SW] 

        for tile_number in array:

            surrounding_tile = Tile.get_tile(tile_number)
            
            if tile_number not in range(1, Tile.total_tiles + 1):
                continue

            if surrounding_tile.walkable and surrounding_tile not in closed_list:
                tiles = blocky(tiles, diagonals, surrounding_tile)

        return tiles
Пример #5
0
	def get_adjacent_tiles(current_node):
		
		array = (                          #array of all adjacent (surrounding) tile's numbers
			(current_node.number + N),
			(current_node.number + NE),
			(current_node.number + E),
			(current_node.number + SE),
			(current_node.number + S),
			(current_node.number + SW),
			(current_node.number + W),
			(current_node.number + NW),
			)

		tiles = []                         #contains all valid tiles that are around our current_node

		original_node_number = current_node.number
		diagonals = [original_node_number + NE, original_node_number + NW, original_node_number + SE, original_node_number + SW]

		for tile_number in array:          #go through all tiles in above array

			adjacent_tile = Tile.get_tile(tile_number)                       #get the tile
			if adjacent_tile == None:
				continue
				
			if tile_number not in range(1, Tile.total_tiles + 1):            #if surround tiles happen to be off the screen
				continue

			if adjacent_tile.walkable and adjacent_tile not in closed_list:  #if this tile meets our criteria (walkable and not already in closed list)
				#tiles.append(adjacent_tile) #Diagonal movement              #add this tile to the list of all valid tiles that are around our current_node
				tiles = block_movement(tiles, diagonals, adjacent_tile) #Blocky movement

		return tiles                                                         #return this list
Пример #6
0
 def spawn(total_frames, FPS):
     if total_frames % (FPS * 2) == 0:
         r = randint(0, len(Enemy.spawn_tiles) - 1)
         tile_num = Enemy.spawn_tiles[r]
         spawn_node = Tile.get_tile(tile_num)
         Enemy(spawn_node.x, spawn_node.y)
         Enemy.health = randint(0, 400)
Пример #7
0
    def get_surrounding_tiles(base_node):

        array = ((base_node.number + N), (base_node.number + NE),
                 (base_node.number + E), (base_node.number + SE),
                 (base_node.number + S), (base_node.number + SW),
                 (base_node.number + W), (base_node.number + NW))

        tiles = []

        #original node number
        onn = base_node.number
        diagonals = [onn + NE, onn + NW, onn + SE, onn + SW]

        for tile_number in array:

            surrounding_tile = Tile.get_tile(tile_number)

            if surrounding_tile.walkable and surrounding_tile not in closed_list:
                #tiles.append(surrounding_tile) #Diagonal movement
                tiles = blocky(tiles, diagonals, surrounding_tile)

        return tiles
Пример #8
0
    def get_tile(self):

        return Tile.get_tile(self.get_number())
Пример #9
0
pygame.init()
pygame.font.init() #initialize font module
pygame.mixer.init() #initialize mixer for music

pygame.mixer.music.load("../Audio/gameMusicHighAlert.ogg")   #set up the game's background music
pygame.mixer.music.set_volume(0.06)
pygame.mixer.music.play(-1)                               #keep the music playing on replay    

print(pygame.mixer.music.get_volume())

screen = pygame.display.set_mode((800, 608))
for y in range(0, screen.get_height(), 32): 
	for x in range(0, screen.get_width(), 32):
		if Tile.total_tiles in Tile.invalidTiles:         #total_tiles also keeps track of current tile number. So if the tile is in fact an invalid tile,
			Tile(x, y, "solid")                           #then make the tile a solid type (aka walkable = False)
		else:
			Tile(x, y, "empty")                           #if not then make the tile an empty type (aka walkable = True)


clock = pygame.time.Clock()
FPS = 32
total_frames = 0

gamemap = pygame.image.load("../Images/techbackground.jpg")

player = Player(64, 288)
healthUPS.spawn()
ammoPacks.spawn()
prev_enemies_killed = 0
healthUPS_respawn = False
Пример #10
0
 def spawn(total_frames, FPS):
     if total_frames % FPS // 3 == 0:
         r = randint(0, len(Enemy.spawn_tiles) - 1)
         tile_num = Enemy.spawn_tiles[r]
         spawn_node = Tile.get_tile(tile_num)
         Enemy(spawn_node.x, spawn_node.y)
Пример #11
0
from object_classes import *
from interaction import interaction
from invalidsFunc import *
from A_Star import A_Star

pygame.init()
pygame.font.init()

invalids = tuple(invalids_func())

screen = pygame.display.set_mode((960, 640))

for y in range(0, screen.get_height(), 32):
    for x in range(0, screen.get_width(), 32):
        if Tile.total_tiles in invalids:
            Tile(x, y, 'solid')
        else:
            Tile(x, y, 'empty')

#set time
clock = pygame.time.Clock()
FPS = 24
total_frames = 0

background = pygame.image.load('images/Background.png')
player = Player(64, 128)

while True:

    screen.blit(background, (0, 0))
Пример #12
0
def interaction(screen, player):

    for event in pygame.event.get():

        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_e:
                player.current += 1
                player.current %= 3

    keys = pygame.key.get_pressed()

    if keys[pygame.K_w]:  # North
        future_tile_number = player.get_number() - Tile.V
        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('n')
                #player.y -= player.height

    if keys[pygame.K_s]:  # South
        future_tile_number = player.get_number() + Tile.V
        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('s')
                #player.y += player.height

    if keys[pygame.K_a]:  # West
        future_tile_number = player.get_number() - Tile.H
        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('w')

                #player.x -= player.width

    if keys[pygame.K_d]:  # East
        future_tile_number = player.get_number() + Tile.H

        if future_tile_number in range(1, Tile.total_tiles + 1):
            future_tile = Tile.get_tile(future_tile_number)
            if future_tile.walkable:
                player.set_target(future_tile)
                player.rotate('e')
                #player.x += player.width

    if keys[pygame.K_LEFT]:
        player.rotate('w')
        Bullet(player.centerx, player.centery, -10, 0, 'w',
               player.get_bullet_type())

    elif keys[pygame.K_RIGHT]:
        player.rotate('e')
        Bullet(player.centerx, player.centery, 10, 0, 'e',
               player.get_bullet_type())

    elif keys[pygame.K_UP]:
        player.rotate('n')
        Bullet(player.centerx, player.centery, 0, -10, 'n',
               player.get_bullet_type())

    elif keys[pygame.K_DOWN]:
        player.rotate('s')
        Bullet(player.centerx, player.centery, 0, 10, 's',
               player.get_bullet_type())
Пример #13
0
pygame.init()
pygame.font.init()
pygame.mixer.init()

pygame.mixer.music.load("audio/halo_themes.wav")
pygame.mixer.music.play(-1)

invalids = tuple(invalids_func())

screen = pygame.display.set_mode((960, 640))

for y in range(0, screen.get_height(), 32):
    for x in range(0, screen.get_width(), 32):
        if Tile.total_tiles in invalids:
            Tile(x, y, 'solid')
        else:
            Tile(x, y, 'empty')

#set time
clock = pygame.time.Clock()
FPS = 24
total_frames = 0

background = pygame.image.load('images/Background.png')
player = Player(64, 128)

while player.health > 1:

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