Super_Alien.py

Super_Alien.py

from scene import *
import json
import sound

A = Action

standing_texture = Texture('plf:AlienBlue_front')
walk_textures = [Texture('plf:AlienBlue_walk1'), Texture('plf:AlienBlue_walk2')]
jump_texture = Texture('plf:AlienBlue_jump')

background_objects_json_str = '''
[{"x": 700, "y": 64, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"}, 
{"x": 635, "y": 64, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"},
{"x": 570, "y": 64, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"},
{"x": 505, "y": 64, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"},
{"x": 825, "y": 180, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"},
{"x": 890, "y": 180, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"},
{"x": 675, "y": 350, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"},
{"x": 740, "y": 350, "w": 65, "h": 50, "img": "plf:Ground_PlanetMid"}]'''

def calculate_overlaps(actor_frame,tile_frame):
  if actor_frame.x + actor_frame.w/2 <= (tile_frame.x + tile_frame.w/2):
    x_overlap = actor_frame.x + actor_frame.w - tile_frame.x
    x_postion = 'left'
  else:
    x_overlap = tile_frame.x + tile_frame.w - actor_frame.x
    x_postion = 'right'
  if (actor_frame.y + actor_frame.h/2) >= (tile_frame.y + tile_frame.h/2):
    y_overlap = tile_frame.y + tile_frame.h - actor_frame.y 
    y_position = 'above'
  else:
    y_overlap = actor_frame.y + actor_frame.h - tile_frame.y
    y_position = 'below'
  return(x_overlap, y_overlap, x_postion, y_position) 
    
#print calculate_overlaps(Rect(500,100,50,150), Rect(540,0,300,200)) # should print (10,100)
#print calculate_overlaps(Rect(500,100,30,150), Rect(540,0,300,200)) # should print (-10,100)
#print calculate_overlaps(Rect(600,220,50,150), Rect(540,0,300,200)) # should print (110,-20)
#print calculate_overlaps(Rect(850,190,50,150), Rect(540,0,300,200)) # should print (-10,10)
#print calculate_overlaps(Rect(550,200,50,110), Rect(540,300,300,200)) # should print (60,10)
#print calculate_overlaps(Rect(100,100,50,50), Rect(200,100,50,50)) #should print (-50,50)
#print calculate_overlaps(Rect(123,200,100,50), Rect(123,50,10,50)) #should print (20,-100)
#print calculate_overlaps(Rect(345,567,123,89), Rect(322,544,123,89)) #should print (100,66)

class GameEnvironment(object):
  def __init__(self):
    self.background_speed = 1
    self.jump = 500
    self.gravity = -600

class MyScene (Scene):
  def setup(self):
    self.env = GameEnvironment()
    self.ground = Node(parent=self)
    groundimage = 'plf:Ground_PlanetMid'
    w = SpriteNode(groundimage).size.w
    h = SpriteNode(groundimage).size.h
    x = 0
    while x <= self.size.w + w:
      tile = SpriteNode(groundimage, position=(x, h/2))
      self.ground.add_child(tile)
      x += w
    self.background_color = 'midnightblue'
    self.background_objects = []
    json_object = json.loads(background_objects_json_str)
    for x in json_object:
      item = SpriteNode(x['img'])
      item.anchor_point = (0.5, 0)
      item.position = (x['x'], x['y'])
      item.size = (x['w'], x['h'])
      self.add_child(item)
      self.background_objects.append(item)
    self.player = SpriteNode(standing_texture)
    self.player.anchor_point = (0.5, 0)
    self.player_actual_h = 78
    self.player_actual_w = 60
    self.add_child(self.player)
    self.new_game()
    
  def new_game(self):
    self.walk_step = -1
    self.player.position = (80, 63)
    self.player.texture = standing_texture
    self.player_y_speed = 0.0
    self.player_x_speed = 0.0
    self.max_speed = 40.0
    self.player_landed = True
    self.player_jumped = False
    
  def update_player(self):
    g = gravity()
    old_x = self.player.position.x
    old_y = self.player.position.y
    y = self.player.position.y 
    x = self.player.position.x 
    
    if y > 63:
      self.player_landed = False
    else:
      self.player_landed = True
      
    if self.player_landed == False:
      self.player.texture = jump_texture
      
    if abs(g.y) <= 0.05 and self.player_landed:
      self.player_x_speed = 0
    
    if abs(g.y) > 0.05 and self.player_landed:
      self.player_x_speed = -g.y * self.max_speed
      self.player.x_scale = -cmp(g.y, 0)
      step = int(self.player.position.x / 40) % 2
      
      if step != self.walk_step:
        self.player.texture = walk_textures[step]
        sound.play_effect('rpg:Footstep00', 0.05, 1.0 + 0.5 * step)
        self.walk_step = step
    elif self.player_landed:
      self.player.texture = standing_texture
      self.walk_step = -1
      
    if not self.player_landed:
      x = x + self.player_x_speed
    else:
      if abs(g.y) > 0.05:
        x = max(0, min(self.size.w, x + self.player_x_speed))
    
    if self.player_jumped:
      self.player_jumped = False
      self.player_landed = False
      self.player_y_speed = self.env.jump
    elif not self.player_landed:
      self.player_y_speed = self.player_y_speed + self.env.gravity * self.dt
      
    if not self.player_landed:
      y += self.player_y_speed * self.dt
      if y <= 63:
        y = 63
        
    desired_frame = Rect(x-self.player_actual_w/2, y, self.player_actual_w, self.player_actual_h)
    
    for object in self.background_objects:
      (x_overlap, y_overlap, x_position, y_position) = calculate_overlaps(desired_frame, object.frame)
      if x_overlap < 0 or y_overlap < 0:
        new_frame = desired_frame
      else:
        if x_overlap < y_overlap:
          if x_position == 'left':
            self.player_x_speed = - self.player_x_speed
            new_x = desired_frame.x - x_overlap
          else:
            new_x = desired_frame.x + x_overlap
          desired_frame = Rect(new_x,desired_frame.y,desired_frame.w,desired_frame.h)
        else: 
          self.player_y_speed = 0
          if y_position == 'above':
            new_y = desired_frame.y + y_overlap
          else:
            new_y = desired_frame.y - y_overlap
          desired_frame = Rect(desired_frame.x,new_y,desired_frame.w,desired_frame.h)       
        
    self.player.position = (desired_frame.x + desired_frame.w/2, desired_frame.y) 
    

  def update(self):
    self.oldx = self.player.position.x
    self.oldy = self.player.position.y
    x = self.oldx
    y = self.oldy
    self.update_player()
    '''
     for dirtblock in self.background_objects:
        pos = dirtblock.position
        pos.x -= self.env.background_speed
        dirtblock.position = pos'''
        
  def touch_began(self, touch):
#    if self.player_landed:
      self.player_jumped = True
      sound.play_effect('game:Boing_1')
      self.player_y_speed += 3
    

run(MyScene(), LANDSCAPE)