def update(self): Sprite.update(self) # Keyboard Input if (App.Keys[pygame.K_LEFT] or App.Keys[pygame.K_a] or App.Keys[pygame.K_RIGHT] or App.Keys[pygame.K_d]): if (App.Keys[pygame.K_LEFT] or App.Keys[pygame.K_a]): self.velocity -= self.accel if (App.Keys[pygame.K_RIGHT] or App.Keys[pygame.K_d]): self.velocity += self.accel if (abs(self.velocity) > self.maxVelocity): self.velocity = self.maxVelocity * math.copysign(1, self.velocity) else: self.velocity *= 0.80 if (abs(self.velocity) < 0.1): self.velocity = 0.0 self.shootTimer += App.Elapsed if (App.Keys[pygame.K_UP] or App.Keys[pygame.K_w] or App.Keys[pygame.K_SPACE]): self.shoot() # Move the player self.angle += self.velocity * App.Elapsed # Set Position self.position = Vector.FromAngle(self.angle, self.distance) self.position.x += (App.Width / 2) - (self.image.get_width() / 2) self.position.y += (App.Height / 2) - (self.image.get_height() / 2)
def __init__( self, x, y, width, height, fname ):
Sprite.__init__( self, x, y, width, height )
bitmap = pygame.image.load( fname ).convert_alpha()
self.images[ self.UP ] = (
bitmap.subsurface( ( width * 0, height * 0, width, height ) ),
bitmap.subsurface( ( width * 0, height * 1, width, height ) ),
bitmap.subsurface( ( width * 0, height * 2, width, height ) ),
bitmap.subsurface( ( width * 0, height * 3, width, height ) )
)
self.images[ self.DOWN ] = (
bitmap.subsurface( ( width * 1, height * 0, width, height ) ),
bitmap.subsurface( ( width * 1, height * 1, width, height ) ),
bitmap.subsurface( ( width * 1, height * 2, width, height ) ),
bitmap.subsurface( ( width * 1, height * 3, width, height ) )
)
self.images[ self.LEFT ] = (
bitmap.subsurface( ( width * 2, height * 0, width, height ) ),
bitmap.subsurface( ( width * 2, height * 1, width, height ) ),
bitmap.subsurface( ( width * 2, height * 2, width, height ) ),
bitmap.subsurface( ( width * 2, height * 3, width, height ) )
)
self.images[ self.RIGHT ] = (
bitmap.subsurface( ( width * 3, height * 0, width, height ) ),
bitmap.subsurface( ( width * 3, height * 1, width, height ) ),
bitmap.subsurface( ( width * 3, height * 2, width, height ) ),
bitmap.subsurface( ( width * 3, height * 3, width, height ) )
)
self.setHeading( self.LEFT )
self.setSteps( 2, 2 )
self.setUpdateInterval( 16 )
self.setRefreshInterval( 16 )
class GameObject:
def __init__(self, x, y, width, height, images, fps, looping):
self.x = x
self.y = y
self.width = width
self.height = height
self.sprite = Sprite(images, fps, looping)
def update(self, gameTime):
self.sprite.update(gameTime)
def draw(self, surface):
surface.blit(self.getImage(), self.getRect())
def getRect(self):
return Rect(self.x, self.y, self.width, self.height)
def getImage(self):
return self.sprite.getImage()
def setSprite(self, sprite):
self.sprite = sprite
def getHitMask(self):
return pygame.surfarray.array_alpha(self.sprite.getImage())
def _loadLevel(self, file):
rect = pygame.Rect(0,0,32,32)
level = open(file,'r')
x, y = 0, 0
for i,line in enumerate(level):
for tile in list(line):
if tile == '\n':
break
elif self._tiles.has_key(tile):
#create sprite
sprite = Sprite()
sprite.rect = rect.move(x,y)
sprite.image = self._tiles[tile].image
sprite.image.set_colorkey([255,0,255])
sprite.flags = self._tiles[tile].flags
self._group.add(sprite)
#add to managers based on flags
for flag in self._tiles[tile].flags:
if flag in self._managers.keys():
self._managers[flag].add(sprite)
x+=32
y += 32
x = 0
def __init__(self, image):
Sprite.__init__(self, image, 0, 0, randint(1,5))
self.Index = randint(0,1)
self.XPosition = randint(0, 768)
self.YPosition = randint(0, 15) * 32
self.LastFired = randint(0,50)
self.Score = self.Speed
if(randint(0,1) == 1):
self.Left = False
else:
self.Left = True
self.Right = not self.Left
if(Sprite.MonsterFrames == []):
Sprite.MonsterFrames.append(pygame.Surface((32,32)).convert_alpha())
Sprite.MonsterFrames.append(pygame.Surface((32,32)).convert_alpha())
Sprite.MonsterFrames.append(pygame.Surface((32,32)).convert_alpha())
Sprite.MonsterFrames.append(pygame.Surface((32,32)).convert_alpha())
Sprite.MonsterFrames[0].fill((0,0,0,0))
Sprite.MonsterFrames[1].fill((0,0,0,0))
Sprite.MonsterFrames[2].fill((0,0,0,0))
Sprite.MonsterFrames[3].fill((0,0,0,0))
Sprite.MonsterFrames[0].blit(image,(0,0),(32,0,32,32))
Sprite.MonsterFrames[1].blit(image,(0,0),(32,32,32,32))
Sprite.MonsterFrames[2].blit(image,(0,0),(64,0,32,32))
Sprite.MonsterFrames[3].blit(image,(0,0),(64,32,32,32))
def __init__(self, filename):
self._movie = pygame.movie.Movie(filename)
surf = pygame.surface.Surface(self._movie.get_size())
self._movie.set_display(surf)
self._lastFrame = None
self._movie.set_volume(0.0)
Sprite.__init__(self, surf)
def update(self):
"""
Updates the plant sprite
Just decreases health until death
"""
Sprite.button_ops(self)
self.health_monitor()
self.blit()
def __init__(self, angle, playerDist, speed=100): Sprite.__init__(self, 0, 0, "assets/game/bullet") self.distance = playerDist + self.image.get_width() self.angle = angle self.speed = speed self.position = Vector.FromAngle(self.angle, self.distance) self.position.x += (App.Width / 2) - (self.image.get_width() / 2) self.position.y += (App.Height / 2) - (self.image.get_height() / 2)
def __init__(self, x, y, w, h, model):
Sprite.__init__(self, x, y, w, h,
model) #Calls super constructor in sprite class
#Initializes Member Variables
self.jumpFrame = 0 #Checks to see how many frames Mario has jumped
self.prevX = 0
self.prevY = 0
self.coinPop = 0 #Makes sure only one coin pops out
marioImages = None
def update(self): Sprite.update(self) self.distance += self.speed * App.Elapsed self.speed += 3 if self.distance > 600: self.kill() self.position = Vector.FromAngle(self.angle, self.distance) self.position.x += (App.Width / 2) - (self.image.get_width() / 2) self.position.y += (App.Height / 2) - (self.image.get_height() / 2)
def update(self):
"""
Updates the bee sprite
Either dies, calls Sprite.hunt for plants or calls Sprite.update
"""
Sprite.button_ops(self)
if self.health_monitor():
return
if not Sprite.hunt(self, Global.plant_group):
Sprite.update(self)
def __init__(self,sprites,locationX,locationY): Sprite.__init__(self,sprites,locationX,locationY) #self.vx = 0 #self.vy = 0 #self.pvx = 0 #previous velocity, stored to help out its snake followers #self.pvy = 0 self.movingto = None self.backlog = None #If recieves a move command while still moving, goes here self.follower = None #a Movable is a Snake. This links to its follower self.smoothtransitioncounter = 0#from 0-1 representing sprite inbetween thingies
def update(self):
"""
Updates the deer sprite
Either dies, hunts deer, or calls Sprite.update
"""
Sprite.button_ops(self)
if self.health_monitor():
return
if not Sprite.hunt(self, Global.deer_group):
Sprite.update(self)
def __init__(self, image_rect):
"""
Calls Spite.init as super
Sets speed and radius
Adds to global bee_group
"""
Sprite.__init__(self, pygame.image.load("Resources/sprites/bees.png"), image_rect, "bees")
self.speed = 15
self.radius = 250
Global.bee_group.add_internal(self)
def __init__( self , boat, line):
Sprite.__init__( self , 32 , 32 , 0 , 0 )
hookImage = pygame.image.load( "res/hook.png" );
hookImage = pygame.transform.scale( hookImage , ( 50 , 50 ) );
self.setImage( hookImage );
self.boat = boat
self.line = line
self.setHeight( 35 )
self.setWidth( 30 )
pass
def update(self, bullets):
"""Updates the player"""
if(self.Firing and self.LastFired > 40):
self.LastFired = 0
self.Frame = 2
self.FrameTicks = 0
s = Fireball(self.spriteSheet, self.XPosition, self.YPosition, 0)
bullets.add(s)
Player.SEffect.play()
Sprite.update(self)
self.image = Sprite.PlayerFrames[self.Frame]
def __init__(self):
Sprite.__init__(self, 0, 0, "assets/game/player")
self.angle = 0
self.distance = 100
self.velocity = 0
self.accel = 17.0
self.maxVelocity = 450.0
self.bullets = pygame.sprite.Group()
self.shootTimer = 0
self.shootRate = 0.35
self.shootSound = pygame.mixer.Sound("assets/game/shoot.wav")
def __init__(self, image_rect):
"""
Calls Spite.init as super
Sets speed, radius and runningAway (a boolean)
Adds to global deer_group
"""
Sprite.__init__(self, pygame.image.load("Resources/sprites/wolf.png"), image_rect, "wolf")
self.speed = 15
self.radius = 100
self.stealth = 60
Global.wolf_group.add_internal(self)
def __init__(self, name, init_x, init_y, image, stats, other):
self.utils = Utils()
self.name = name
self.x = init_x
self.y = init_y
self.sprite = Sprite((self.x * self.utils.MAP_TILE_WIDTH,
self.y * self.utils.MAP_TILE_HEIGHT), image,
self.name)
self.stats = stats
self.exp_given = other['exp']
self.difficulty = other['difficulty']
def __init__(self, rect, is_pollinated=False):
"""
Calls Spite.init as super
Sets speed, radius and is_pollinated (a boolean)
Adds to global plant_group
Loads pollinated image if is_pollinated
"""
Sprite.__init__(self, pygame.image.load("Resources/sprites/plant.png"), rect, "plant")
self.screen = Utils.screen
self.is_pollinated = is_pollinated
Global.plant_group.add_internal(self)
if self.is_pollinated:
self.image = pygame.image.load("Resources/sprites/plantpollinated.png")
def __init__(self, name, init_x, init_y, image, stats, equipment,
inventory, skills):
self.utils = Utils()
self.name = name
self.x = init_x
self.y = init_y
self.sprite = Sprite((self.x * self.utils.MAP_TILE_WIDTH,
self.y * self.utils.MAP_TILE_HEIGHT), image,
self.name)
self.stats = stats
self.equipment = equipment
self.inventory = inventory
self.skills = skills
def update(self, bullets):
Sprite.update(self)
if(self.Left and self.XPosition <= 0):
self.Left = False
self.Right = True
if(self.Right and self.XPosition >= 768):
self.Right = False
self.Left = True
if(self.LastFired >= 50 and randint(0,25) == 5):
b = Fireball(self.spriteSheet, self.XPosition, self.YPosition, 1)
bullets.add(b)
self.LastFired = 0
self.image = Sprite.MonsterFrames[2 * self.Index + self.Frame]
def randomFood(self):
row = int(self.HEIGHT/self.IMAGE_SIZE)
col = int(self.WIDTH/self.IMAGE_SIZE)
allPos = [i for i in range(row*col)]
invalidPos = []
for sprite in self.snake.spriteList:
invalidPos.append(int(sprite.y/self.IMAGE_SIZE) * row + int(sprite.x/self.IMAGE_SIZE))
valid = []
for x in allPos:
if x not in invalidPos:
valid.append(x)
x = int(valid[random.randint(0, len(valid)-1)]%col) * self.IMAGE_SIZE
y = int(valid[random.randint(0, len(valid)-1)]/col) * self.IMAGE_SIZE
self.food = Sprite("goomba.gif", self.__canvas, x,y)
def __init__(self, x, y, state, tower_type):
# For cycle detection
self.is_powered = False
self.x = x
self.y = y
self.tower_type = tower_type
# pos is placeholder
self.sprite = Sprite(x=x, y=y, frames=[[pygame.image.load('sprites/lighthouse/LH1.png')]])
self.sprite.rect.x = x*PIXEL_RESOLUTION
self.sprite.rect.y = y*PIXEL_RESOLUTION
self.light_sprite = Sprite(x=x, y=y, frames=[[pygame.image.load('sprites/lighthouse/weakstraight1.png')]], can_rotate=True)
self.light_sprite.rect.x = x*PIXEL_RESOLUTION
self.light_sprite.rect.y = y*PIXEL_RESOLUTION
def __init__(self, location, velocity, direction):
""" Bullet class for the Asteroids game
Parameters
----------
location : list of ints
x, y pixel position of the center of the bullet
velocity : int
velocity of the bullet (always 30)
direction : int
0-19 direction of travel of the bullet
"""
Sprite.__init__(self, location, velocity, direction)
self.lifetime = 20
def __init__(self, image):
Sprite.__init__(self, image, 300, 568, 3)
if(Sprite.PlayerFrames == []):
Sprite.PlayerFrames.append(pygame.Surface((32,32)).convert_alpha())
Sprite.PlayerFrames.append(pygame.Surface((32,32)).convert_alpha())
Sprite.PlayerFrames.append(pygame.Surface((32,32)).convert_alpha())
Sprite.PlayerFrames[0].fill((0,0,0,0))
Sprite.PlayerFrames[1].fill((0,0,0,0))
Sprite.PlayerFrames[2].fill((0,0,0,0))
Sprite.PlayerFrames[0].blit(image,(0,0),(0,0,32,32))
Sprite.PlayerFrames[1].blit(image,(0,0),(0,32,32,32))
Sprite.PlayerFrames[2].blit(image,(0,0),(0,64,32,32))
if(Player.SEffect == None):
Player.SEffect = pygame.mixer.Sound("Fireball1.wav")
def __init__(self, screen, sprite_sheet):
self.screen = screen
self.screen_area = screen.get_rect()
self.sprite_sheet = sprite_sheet
self.space_invaders_title = Text(screen, "SPACE INVADERS", (0, 255, 0),
(0, 0, 0), self.screen_area.w,
self.screen_area.h, 100)
self.set_text_position_menu(self.space_invaders_title, 4, 6)
self.press_enter_text = Text(screen, "Press Enter To Start Game",
(0, 255, 0), (0, 0, 0),
self.screen_area.w, self.screen_area.h,
30)
self.set_text_position_menu(self.press_enter_text, 2, 4)
self.press_highscores_text = Text(screen,
"Press H To View High Scores",
(0, 255, 0), (0, 0, 0),
self.screen_area.w,
self.screen_area.h, 30)
self.set_text_position_menu(self.press_highscores_text, 2, 4, 0, 50)
self.alien_points_1_text = Text(screen, "10 Points", (255, 255, 255),
(0, 0, 0), self.screen_area.w,
self.screen_area.h, 48)
self.set_text_position_menu(self.alien_points_1_text, 2, 2, 0, -50)
self.alien_points_2_text = Text(screen, "20 Points", (255, 255, 255),
(0, 0, 0), self.screen_area.w,
self.screen_area.h, 48)
self.set_text_position_menu(self.alien_points_2_text, 2, 2)
self.alien_points_3_text = Text(screen, "30 Points", (255, 255, 255),
(0, 0, 0), self.screen_area.w,
self.screen_area.h, 48)
self.set_text_position_menu(self.alien_points_3_text, 2, 2, 0, 50)
self.alien_points_4_text = Text(screen, "????????", (255, 255, 255),
(0, 0, 0), self.screen_area.w,
self.screen_area.h, 48)
self.set_text_position_menu(self.alien_points_4_text, 2, 2, 0, 100)
self.alien_1_sprite = Sprite(screen, sprite_sheet, 5,
self.screen_area.w, self.screen_area.h)
self.set_sprite_position_menu(self.alien_1_sprite, 2, 2, -100, -50)
self.alien_2_sprite = Sprite(screen, sprite_sheet, 11,
self.screen_area.w, self.screen_area.h)
self.set_sprite_position_menu(self.alien_2_sprite, 2, 2, -100)
self.alien_3_sprite = Sprite(screen, sprite_sheet, 17,
self.screen_area.w, self.screen_area.h)
self.set_sprite_position_menu(self.alien_3_sprite, 2, 2, -100, 50)
self.alien_4_sprite = Sprite(screen, sprite_sheet, 0,
self.screen_area.w, self.screen_area.h)
self.set_sprite_position_menu(self.alien_4_sprite, 2, 2, -100, 100)
def createLevel():
GameState.clean()
GameState.level += 1
stairUp = Item("stairs_up.png", (SCALE, SCALE), GameState.triggerLoad)
GameState.dynamics.add(stairUp)
playerPos = None
maze = genMaze(MAPSIZE+GameState.level)
floors = sum(sum(maze.data))
spawns = [lambda pos: HealItem(pos, 1) for _ in range(int(0.02*floors))]
spawns += [lambda pos: Enemy("enemy_placeholder.png", pos) for _ in range(int(0.05*floors))]
for x in range(maze.M+2):
for y in range(maze.N+2):
if not maze[x-1,y-1]:
GameState.statics.add(Sprite(wallimg, (x*SCALE, y*SCALE)))
elif playerPos is None:
playerPos = x*SCALE, y*SCALE
elif random.random() < .01 and x < maze.M/2 and y < maze.N:
playerPos = x*SCALE, y*SCALE
else:
if random.random() < max(len(spawns)/floors, .05) and spawns:
i = random.randrange(len(spawns))
GameState.dynamics.add(spawns[i]((x*SCALE,y*SCALE)))
del spawns[i]
floors -= 1
stairUp.rect.x, stairUp.rect.y = x*SCALE, y*SCALE
GameState.initBackground()
GameState.player.rect.topleft = playerPos
def init(self):
# hearts component
temp_sprite = Sprite("heart", 50, 50, 0, 0, ui_sprite=True)
new_heart_comp = HeartsComp(0, 0, 0, 0, temp_sprite)
self.add_component(new_heart_comp)
Camera.set_follows(self)
def __init__(self, canvas, length, x, y):
self.__canvas = canvas
self.spriteList = []
self.addOne = False
for i in range(length):
newSprite = Sprite("mario.gif", self.__canvas, x, y + i * 50)
self.spriteList.append(newSprite)
def move(self):
STEP_SIZE = 30
theta = self.rotation() # degrees
theta = theta * pi / 180 # radians
dx = STEP_SIZE * cos(theta)
dy = STEP_SIZE * sin(theta)
if self.distance_traveled > self.max_range:
if not self.scene():
return
self.scene().removeItem(self)
del self
else:
# move bullet
self.setPos(self.x() + dx, self.y() + dy)
self.distance_traveled += STEP_SIZE
# if bullet collides with enemy, destroy both
self.colliding_items = self.collidingItems()
for i in self.colliding_items:
if hasattr(i, 'team') and i.team != self.owner.team:
# substract health
if i.is_damageable():
i.decrease_health(self.damage)
# animate
self.scene().addItem(Sprite(self.pos()))
self.scene().removeItem(self)
del self
return
def __init__(self, stats, fishingHook, fishingLine, eelSpeed):
Sprite.__init__(self, 32, 32, 0, 0)
eelImage = pygame.image.load("res/eel.png").convert_alpha()
#eelImage = pygame.image.load( "res/eel1.png" ).convert()
#eelImage = pygame.transform.scale( eelImage , (100 , 50) )
#eelImage.set_colorkey( (255,255,255) )
self.setImage(eelImage)
self.stats = stats
self.fishingHook = fishingHook
self.fishingLine = fishingLine
#slightly offset eel picture's extra whitespace width
self.setWidth(48)
#self.setHeight( 15 )
self.speed = eelSpeed
class Bullet:
bulletSprite = Sprite(
'https://github.com/NJHewadewa/DebtRunners/blob/master/Sprites/Bullet.png?raw=true'
)
def __init__(self,
pos=Vector(),
vel=Vector(),
homing=False,
enemyPos=Vector(),
bulletSpeed=7):
self.pos = pos
self.vel = vel
self.homing = homing
self.enemyPos = enemyPos
self.bulletSpeed = bulletSpeed
self.counter = 0
def update(self):
if self.homing == False:
self.pos.add(self.vel)
elif self.homing == True:
if self.counter < 30:
#Goes in the direction of the mouse for 30 frames(half a second) then locks onto enemy and fires at the enemy
self.counter += 1
self.pos.add(self.vel)
else:
self.vel = self.enemyPos.copy().subtract(
self.pos.copy()).normalize().multiply(self.bulletSpeed)
self.pos.add(self.vel)
def parse_key(self, node):
# in self.key there should be only ref nodes
# the point is at start to create all nodes that have NO parent
starter = self.get_from_key_with_parent(node.get_bone_id())
if len(starter) == 0:
print 'WARNING: found a bone with no children attached:', node.get_name(
), 'id:', node.get_bone_id()
# Utils.print_error('There are no nodes with this node as parent', [node, self.key, self.timeline])
for st in starter:
obj = None
if st.get_type() == BoneRef.type:
obj = Node()
elif st.get_type() == ObjectRef.type:
obj = Sprite(self.fileKeeper)
if obj is None:
Utils.print_error('Unable to generate node nor sprite from',
[obj, self.key, self.timeline])
objTime = obj.build(st, self.timeline)
if math.fabs(self.key.time - objTime) > 1e-4:
obj.set_active(False)
node.add_child(obj)
newPath = obj.get_bone_id()
if newPath is not None:
self.parse_key(obj)
def SetUpCloudSprite(x,y, towerEntity):
towerEntity.tower_type.is_passable = False;
img = pygame.image.load('sprites/fake_cloud.png')
towerEntity.sprite = Sprite(x=x, y=y, frames=[[img]])
towerEntity.sprite.rect.x = x*PIXEL_RESOLUTION;
towerEntity.sprite.rect.y = y*PIXEL_RESOLUTION;
towerEntity.light_sprite = None;
def __init__(self, source, scale, pos, angle):
super().__init__(pos=pos)
self.scale = scale
self.images = Atlas('images/hat.atlas') ## Atlas initialization
self.keys = list(
self.images.textures.keys()) ## atlas keys into a list
print('keys in Hat', self.keys)
self.kys = ('hat_burnt0', 'hat_burnt1', 'hat_burnt2', 'hat_burnt3',
'hat_burnt4', 'hat_burnt-final')
print('hat keys list', self.kys)
self.image = Sprite(texture=self.images['hat'],
scale=self.scale,
pos=pos)
#self.image = Sprite(source=source, scale=self.scale, pos=pos)
self.size = self.image.size
self.add_widget(self.image)
self.inhand = False
self.onhead = False
self.onhead_timer = 0
self.moving = False
#burning status
self.burning = False
self.burnt = False
self.burn_counter = 0
self.sprite = 0
self.animation_value = int(200 / (len(self.kys) - 1))
print('animation value', self.animation_value)
self.vy = 0
self.combust = SoundLoader.load('audio/combust-both.wav')
def __init__(self, location, velocity, direction):
""" Ship class for Asteroids game
Parameters
----------
location : list of ints
x, y pixel position of the center of the ship
velocity : int
velocity of the ship
direction : int
0-19 direction of travel of the ship
"""
Sprite.__init__(self, location, velocity, direction)
self.rotation_map = self.rotation_map_constructor()
self.rotation = 0
self.update_point_list()
self.thruster = 0
def clone(self):
toReturn = Sprite.clone(self)
toReturn.passable = self.passable
toReturn.damage = self.damage
toReturn.pickup = self.pickup.clone() if self.pickup else None
toReturn.moveable = self.moveable.clone() if self.moveable else None
return toReturn
def SetUpShipSprite(x,y, towerEntity):
img = pygame.image.load('sprites/ship1.png')
# @TODO anthonyluu: remove this after we switch to 64x64
smaller_img = pygame.transform.scale(img, (PIXEL_RESOLUTION, PIXEL_RESOLUTION))
towerEntity.sprite = Sprite(x=x, y=y, frames=[[smaller_img]])
towerEntity.sprite.rect.x = x*PIXEL_RESOLUTION;
towerEntity.sprite.rect.y = y*PIXEL_RESOLUTION;
towerEntity.light_sprite = None;
def translate(self):
Sprite.translate(self)
glPushMatrix()
# This assumes that the camera is at (0, 0, 0)! Really this is not a good assumption.
objToCamProj = self._normalize(array([-self.x, 0, -self.z], 'd'))
lookAt = array([0, 0, 1], 'd')
upAux = self._cross(lookAt, objToCamProj)
angleCosine = add.reduce(lookAt * objToCamProj)
if angleCosine < 0.99990 and angleCosine > -0.9999:
glRotatef(math.acos(angleCosine) * 180 / 3.14, *upAux)
objToCam = self._normalize(array([-self.x, -self.y, -self.z], 'd'))
angleCosine = add.reduce(objToCamProj * objToCam)
if angleCosine < 0.99990 and angleCosine > -0.9999:
glRotatef(math.acos(angleCosine)*180/3.14, 1, 0, 0)
else:
glRotatef(math.acos(angleCosine)*180/3.14, -1, 0, 0)
def __init__(self, yFaceDirection, **kwArgs):
super().__init__(**kwArgs)
rm = ResourceManager.activeManager
# Set Systems
self._yFaceDirection = yFaceDirection
# Set Characteristics
self._alive = True
self._armor = 3
self._health = 1000
self._speed = 550
self._velocity = vec(0,0)
# Set Rendering and Physics Data
self._sprite = Sprite(rm.request("SpaceJet.anim"), t=self.getTransform().createChild())
self._sprite.setFrame(1+3)
self._explosionSprite = Sprite(rm.request("Explosion.anim"), t=self.getTransform().createChild())
self._explosionSprite.isDrawn = False
self._explosionSound = rm.request("Explosion.mp3")
self._bounds = CollisionRect(self._sprite.getWidth(), self._sprite.getHeight(), t=self.getTransform().createChild())
self._bounds.addEntity(self)
#self._boundsDisplay = SceneObject(dataSrc = self._bounds, t=self._bounds.getTransform(), color=Color.Green, \
# batch=pyglet.graphics.Batch(), group=LinePolygonMode)
# Set Flight Area
self._flightAreaEdges = [-400+self._sprite.getWidth()/2, 400-self._sprite.getWidth()/2, \
yFaceDirection*(-300+self._sprite.getHeight()/2), -100*yFaceDirection]
if yFaceDirection == -1:
s = self._flightAreaEdges[2]
self._flightAreaEdges[2] = self._flightAreaEdges[3]
self._flightAreaEdges[3] = s
# Create the default weapon
from Weapon import LaserGun
from Weapon import MissleLauncher
self._velocity = vec(0,0)
self._weapon = LaserGun(self, t=self.getTransform().createChild())
self._secondaryWep = MissleLauncher(self, t=self.getTransform().createChild())
class Player(object):
def __init__(self, name, init_x, init_y, image, stats, equipment,
inventory, skills):
self.utils = Utils()
self.name = name
self.x = init_x
self.y = init_y
self.sprite = Sprite((self.x * self.utils.MAP_TILE_WIDTH,
self.y * self.utils.MAP_TILE_HEIGHT), image,
self.name)
self.stats = stats
self.equipment = equipment
self.inventory = inventory
self.skills = skills
def gain_stat(self, stat, gain):
if stat in self.stats:
self.stats[stat] += gain
def equip(self, equipment):
self.equipment[equipment.equip_type] = equipment
equipment.is_equipped = True
def unequip(self, equip_slot):
self.equipment[equip_slot].is_equipped = False
self.equipment.pop(equip_slot)
def add_item(self, item):
self.inventory.update(item)
def remove_item(self, item):
self.inventory.pop(item)
def add_skill(self, skill):
self.skills.update(skill)
def remove_skill(self, skill):
self.skills.pop(skill)
def move(self, dx, dy):
self.x += dx
self.y += dy
self.sprite.move(dx * self.utils.MAP_TILE_WIDTH,
dy * self.utils.MAP_TILE_HEIGHT)
def __init__(self, location, velocity, direction, size, color):
""" Asteroid class for Asteroids game
Parameters
----------
location : list of ints
x, y pixel position of center of the asteroid
velocity : int
velocity of the asteroid (possible values 3, 6, 12)
direction : int
0-19 direction of travel of the asteroid
size : int
size of the asteroid (possible values 60, 30, 15)
color : tuple of ints
RGB values for asteroid color
"""
Sprite.__init__(self, location, velocity, direction)
self.size = size
self.color = color
def main():
scene = Scene()
scene.setTitle("Demo")
scene.setSize(800, 600)
# image by sujit1717
player = Player(scene, 'player.png', 50, 100)
player.setPosition(400, 300)
box = Sprite(scene, 'box.png', 50, 50)
box.setPosition(500, 500)
# define custom update method that'll be passed to the game loop
def checkPlayerCollisions():
if player.checkCollision():
box.setPosition(randint(0, scene.width), randint(0, scene.height))
# start the game loop
scene.startScene(checkPlayerCollisions)
def __init__(self, player: int, location: tuple, floor_height: float):
"""ctor"""
self.sprite = Sprite("assets/Sprites", (70, 80), 2.5, player != 1,
Player.SPRITE_SHEET_STATES)
if player == 1:
self.controls = Player.PLAYER_ONE_CONTROLS
else:
self.controls = Player.PLAYER_TWO_CONTROLS
self.location = Vector(location)
self.sprite_state = "IDLE"
self.speed = 0
self.ResetSpeed()
self.frame_counter = 0
self.floor_height = floor_height
self.velocity = Vector((0, 0))
self.acceleration = Vector((0, GRAVITY))
self.sprite_state_counter = 0
self.damage_time = 0
self.health = 100
self.imports_done = False
def make_button(self, title, surf, x, y, image=None):
pos = surf.get_offset()
print 'offset for this surface is: ' + str(pos)
font = pygame.font.Font(None, 16)
f = font.render(title, 1, (0, 0, 0))
t = pygame.Surface((f.get_width() + 2, f.get_height() + 2))
t.fill((255, 255, 255))
t.blit(f, (0, 0))
sp = Sprite((x + pos[0], y + pos[1]), t, title)
print "Sprite is at " + str(sp.rect.topleft)
self.sprites.add(sp)
return sp
def __init__(self, image, xPos, yPos, index):
pygame.sprite.Sprite.__init__(self)
Sprite.__init__(self, image, 0, 0, 0)
self.image = pygame.Surface((32, 32))
self.Index = index
self.XPosition = xPos
self.YPosition = yPos
self.Left = False
self.Right = False
if (Sprite.FBFrames == []):
Sprite.FBFrames.append(pygame.Surface((32, 32)).convert_alpha())
Sprite.FBFrames.append(pygame.Surface((32, 32)).convert_alpha())
Sprite.FBFrames.append(pygame.Surface((32, 32)).convert_alpha())
Sprite.FBFrames.append(pygame.Surface((32, 32)).convert_alpha())
Sprite.FBFrames[0].fill((0, 0, 0, 0))
Sprite.FBFrames[1].fill((0, 0, 0, 0))
Sprite.FBFrames[2].fill((0, 0, 0, 0))
Sprite.FBFrames[3].fill((0, 0, 0, 0))
Sprite.FBFrames[0].blit(image, (0, 0), (96, 0, 32, 32))
Sprite.FBFrames[1].blit(image, (0, 0), (96, 32, 32, 32))
Sprite.FBFrames[2].blit(image, (0, 0), (128, 0, 32, 32))
Sprite.FBFrames[3].blit(image, (0, 0), (128, 32, 32, 32))
def __init__(self, controller, ship, startPos, vel, dAccel, accel, maxVel, damage, animation, **kwArgs): super().__init__(**kwArgs) # Controller self._controller = controller # Generic state self._ship = ship self._damage = damage self._alive = True # Set Movement state self.setTransform(r.activeRenderer.getSceneGraph().newTransform(t=startPos.getTranslation(), r=startPos.getRotation())) self._velocity = vel self._dAccel = dAccel self._accel = accel self._maxVelocity = maxVel # Create Sprite and Bounds self._sprite = Sprite(animation, t=self.getTransform()) self._bounds = CollisionRect(self._sprite.getWidth(), self._sprite.getHeight(), t=self.getTransform().createChild()) self._bounds.addEntity(self)
pygame.init()
screen = pygame.display.set_mode(resolution)
pygame.display.set_caption("Flappy Bird")
clock = pygame.time.Clock()
background = pygame.image.load("bg.jpg").convert()
player_image = pygame.image.load("player.png").convert_alpha()
pipe_down_image = pygame.image.load("Pipe_Down.png").convert_alpha()
pipe_up_image = pygame.image.load("Pipe_Up.png").convert_alpha()
player_down = pygame.transform.rotate(player_image, -30)
player_dead = pygame.transform.rotate(player_image, -90)
player = Sprite(player_image, (100, 100))
player.set_gravity(True, fall_speed)
pipe_down = Sprite(pygame.transform.scale(pipe_down_image, (pipe_down_image.get_width(), pipe_down_image.get_height() + randrange(50, range_grow))), (400, 0))
pipe_up = Sprite(pygame.transform.scale(pipe_up_image, (pipe_up_image.get_width(), pipe_up_image.get_height() - 50)), (400, 520))
pipe_down1 = Sprite(pygame.transform.scale(pipe_down_image, (pipe_down_image.get_width(), pipe_down_image.get_height() + randrange(50, range_grow))), (600, 0))
pipe_up1 = Sprite(pygame.transform.scale(pipe_up_image, (pipe_up_image.get_width(), pipe_up_image.get_height() - 50)), (600, 520))
pipe_down2 = Sprite(pygame.transform.scale(pipe_down_image, (pipe_down_image.get_width(), pipe_down_image.get_height() + randrange(50, range_grow))), (800, 0))
pipe_up2 = Sprite(pygame.transform.scale(pipe_up_image, (pipe_up_image.get_width(), pipe_up_image.get_height() - 50)), (800, 520))
pipe_down3 = Sprite(pygame.transform.scale(pipe_down_image, (pipe_down_image.get_width(), pipe_down_image.get_height() + randrange(50, range_grow))), (1000, 0))
def draw(self):
if self.get_frame() != self._lastFrame:
self.updateFromSurface()
self._lastFrame = self.get_frame()
Sprite.draw(self)
class RemoteSpaceJet(Transformable):
_frameMap = {vec(-1, -1):0, vec(0, -1):1, vec(1, -1):2, \
vec(-1, 0):3, vec(0,0):4, vec(1,0):5, \
vec(-1, 1):6, vec(0, 1):7, vec(1, 1):8}
def __init__(self, remoteController, yFaceDirection, **kwArgs):
super().__init__(**kwArgs)
rm = ResourceManager.activeManager
# Set Systems
self._controller = remoteController
self._yFaceDirection = yFaceDirection
# Set Characteristics
self._alive = True
self._armor = 3
self._health = 1000
self._velocity = vec(0,0)
# Set Rendering and Physics Data
self._sprite = Sprite(rm.request("SpaceJet.anim"), t=self.getTransform().createChild())
self._sprite.setFrame(1+3)
self._explosionSprite = Sprite(rm.request("Explosion.anim"), t=self.getTransform().createChild())
self._explosionSprite.isDrawn = False
self._explosionSound = rm.request("Explosion.mp3")
self._bounds = CollisionRect(self._sprite.getWidth(), self._sprite.getHeight(), t=self.getTransform().createChild())
self._bounds.addEntity(self)
#self._boundsDisplay = SceneObject(dataSrc = self._bounds, t=self._bounds.getTransform(), color=Color.Green, \
# batch=pyglet.graphics.Batch(), group=LinePolygonMode)
# Set Flight Area
self._flightAreaEdges = [-400+self._sprite.getWidth()/2, 400-self._sprite.getWidth()/2, \
yFaceDirection*(-300+self._sprite.getHeight()/2), -100*yFaceDirection]
if yFaceDirection == -1:
s = self._flightAreaEdges[2]
self._flightAreaEdges[2] = self._flightAreaEdges[3]
self._flightAreaEdges[3] = s
self.rotate(math.pi)
''''''''''''''''''''''''''''''''''''''''''''''''
# Update State Remotely
def remoteUpdate(self, controlStruc):
if(controlStruc):
# Read Data From Control Structure
health = controlStruc.get('health', self._health)
position = controlStruc.get('position', self.getPosition())
velocity = controlStruc.get('velocity', self._velocity)
frameNum = controlStruc.get('frame', self._sprite.getFrame())
# Set Alive and Position
self._health = health
self.setTranslation(position)
# Set Velocity and Check for Movement
self._velocity = velocity*self._yFaceDirection
if(self._health > 0 and self._velocity != vec(0,0)):
self._sprite.setFrame(frameNum)
# Update State Locally -> No Message Received
def update(self, dt):
if self._alive:
# Move according to last received velocity (aka 'Dead Reckoning')
self.translate(self._velocity*dt)
# Check Flight Area
p = self.getPosition(); np = p.copy()
fa = self._flightAreaEdges
if p.x < fa[0]:
np.x = fa[0]
if p.x > fa[1]:
np.x = fa[1]
if p.y < fa[2]:
np.y = fa[2]
if p.y > fa[3]:
np.y = fa[3]
if p != np:
self.setTranslation(np)
# Update Sprite Data
moving = False; direc = vec(0, 0)
if(self._velocity != vec(0,0)):
moving = True
if(self._velocity.x != 0):
direc.x = math.copysign(1, self._velocity.x)
if(self._velocity.y != 0):
direc.y = math.copysign(1, self._velocity.y)
# Draw Sprite Accordingly
self._sprite.setFrame(self._frameMap[vec(direc.x if self._yFaceDirection==1 else -direc.x, direc.y*self._yFaceDirection)])
if not moving and self._sprite.getFrame() != 4:
self._sprite.setFrame(4)
# Update Sprite and Bounds
if self._sprite.update(dt):
self._updateDimensions()
self._bounds.update(dt)
self._checkDeath(dt)
def notifyCollisions(self, primitive, colliderSet):
pass
''''''''''''''''''''''''''''''''''''''''''''''''
def _checkDeath(self, dt):
if self._health <= 0 and self._alive:
self._explosionSprite.setAnimation("Iterating")
self._explosionSprite.isDrawn = True
self._explosionSound.play()
self._alive = False
self._explosionSprite.update(dt)
if(self._explosionSprite.hasEnded()):
self.removeFromWorld()
def removeFromWorld(self):
self._controller.removeEntity(self)
self._bounds.removeEntity(self)
self.getTransform().killSubtree()
self.removeTransform()
''''''''''''''''''''''''''''''''''''''''''''''''
def _updateDimensions(self):
w, h = self._sprite.getDimensions()
self._bounds.resize(w, h)
def getCollisionPrimitive(self):
return self._bounds
def explosionEnded(self):
return self._explosionSprite.hasEnded()
def __del__(self):
self._movie.stop()
Sprite.__del__(self)
def __init__(self, x, y, path=""): Sprite.__init__(self, x, y, path, 3) self.state = NONE self.down = False self.justPressed = False
class SpaceJet(Transformable):
_frameMap = {vec(-1, -1):0, vec(0, -1):1, vec(1, -1):2, \
vec(-1, 0):3, vec(0,0):4, vec(1,0):5, \
vec(-1, 1):6, vec(0, 1):7, vec(1, 1):8}
def __init__(self, yFaceDirection, **kwArgs):
super().__init__(**kwArgs)
rm = ResourceManager.activeManager
# Set Systems
self._yFaceDirection = yFaceDirection
# Set Characteristics
self._alive = True
self._armor = 3
self._health = 1000
self._speed = 550
self._velocity = vec(0,0)
# Set Rendering and Physics Data
self._sprite = Sprite(rm.request("SpaceJet.anim"), t=self.getTransform().createChild())
self._sprite.setFrame(1+3)
self._explosionSprite = Sprite(rm.request("Explosion.anim"), t=self.getTransform().createChild())
self._explosionSprite.isDrawn = False
self._explosionSound = rm.request("Explosion.mp3")
self._bounds = CollisionRect(self._sprite.getWidth(), self._sprite.getHeight(), t=self.getTransform().createChild())
self._bounds.addEntity(self)
#self._boundsDisplay = SceneObject(dataSrc = self._bounds, t=self._bounds.getTransform(), color=Color.Green, \
# batch=pyglet.graphics.Batch(), group=LinePolygonMode)
# Set Flight Area
self._flightAreaEdges = [-400+self._sprite.getWidth()/2, 400-self._sprite.getWidth()/2, \
yFaceDirection*(-300+self._sprite.getHeight()/2), -100*yFaceDirection]
if yFaceDirection == -1:
s = self._flightAreaEdges[2]
self._flightAreaEdges[2] = self._flightAreaEdges[3]
self._flightAreaEdges[3] = s
# Create the default weapon
from Weapon import LaserGun
from Weapon import MissleLauncher
self._velocity = vec(0,0)
self._weapon = LaserGun(self, t=self.getTransform().createChild())
self._secondaryWep = MissleLauncher(self, t=self.getTransform().createChild())
''''''''''''''''''''''''''''''''''''''''''''''''
def update(self, dt):
self.readKeyboardInput(dt)
if self._sprite.update(dt):
self._updateDimensions()
self._bounds.update(dt)
self._weapon.update(dt)
self._secondaryWep.update(dt)
return self._checkDeath(dt)
def notifyCollisions(self, primitive, colliderSet):
pass
''''''''''''''''''''''''''''''''''''''''''''''''
def _checkDeath(self, dt):
if self._health <= 0 and self._alive:
self._explosionSprite.setAnimation("Iterating")
self._explosionSprite.isDrawn = True
self._explosionSound.play()
self._alive = False
self._explosionSprite.update(dt)
if not self._alive and self._explosionSprite.hasEnded():
self.removeFromWorld()
def removeFromWorld(self):
from GameWorld import GameWorld
GameWorld.activeWorld.removeEntity(self)
self._bounds.removeEntity(self)
self.getTransform().killSubtree()
self.removeTransform()
def readKeyboardInput(self, dt):
if not self._alive:
return
actions = Keyboard.localKeyboard.getActions()
moving = False
for action in actions:
if action.name == "Move":
direc = action.params[0]
direc = direc*self._yFaceDirection
self._sprite.setFrame(self._frameMap[vec(direc.x if self._yFaceDirection==1 else -direc.x, direc.y*self._yFaceDirection)])
self.translate(direc*self._speed*dt)
self._velocity = direc*self._speed
# Check Flight Area
p = self.getPosition(); np = p.copy()
fa = self._flightAreaEdges
if p.x < fa[0]:
np.x = fa[0]
if p.x > fa[1]:
np.x = fa[1]
if p.y < fa[2]:
np.y = fa[2]
if p.y > fa[3]:
np.y = fa[3]
if p != np:
self.setTranslation(np)
moving = True
elif action.name == "FirePrimary":
self._weapon.fire(vec(0, self._yFaceDirection))
elif action.name == "FireSecondary":
self._secondaryWep.fire(vec(0, self._yFaceDirection))
if not moving and self._sprite.getFrame() != 4:
self._sprite.setFrame(4)
''''''''''''''''''''''''''''''''''''''''''''''''
def _updateDimensions(self):
w, h = self._sprite.getDimensions()
self._bounds.resize(w, h)
def getCollisionPrimitive(self):
return self._bounds
def explosionEnded(self):
return self._explosionSprite.hasEnded()
def __init__(self): Sprite.__init__(self, 0, 0, "assets/game/ball") self.source = self.image.copy()
rendMan = Renderer(winSize=winDimensions)
Renderer.activeRenderer = rendMan
sg = rendMan.getSceneGraph()
rm = ResourceManager("Tests\\data")
ResourceManager.activeManager = rm
rm.registerExtension(".jpg", "img", ["img"], pyglet.image.load)
rm.registerExtension(".bmp", "img", ["img"], pyglet.image.load)
rm.registerExtension(".png", "img", ["img"], pyglet.image.load)
rm.registerExtension(".anim", "anim", ["anim"], Animation)
anim1 = rm.request("CharizardEvolve.anim")
anim2 = rm.request("PShip.anim")
s1 = Sprite(anim1, t=sg.newTransform())
s2 = Sprite(anim2, t=sg.newTransform(t=vec(-200,100)))
s1.setAnimation("Alternating")
s2.setAnimation("Looping")
print("")
rm.debugDisplay()
print("")
def update(dt):
s1.update(dt)
s2.update(dt)
def __init__(self, font, text, color): surf = font.render(text, 1, color) Sprite.__init__(self, surf)
