Here you will find the source code for the Kitty Hero game, as described in the book Beginning Graphics Programming with Processing 3

Copyright 2018 Antony Lees

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 def setup():
  size(600, 1000, P3D)
  
  # game board
  global standard_tile
  standard_tile = "standard"
  global hole_tile
  hole_tile = "hole"
  global hole_hit_tile
  hole_hit_tile = "hit"
  global target_tile
  target_tile = "target"
  global number_of_columns
  number_of_columns = 5
  global tiles
  tiles = []
  global tile_size
  tile_size = width/number_of_columns/2
  global number_of_rows
  number_of_rows = (height/tile_size) * 2 
  global x_offset
  x_offset = (width-tile_size * number_of_columns)/2
  grace_period = 1
  
  # initialise tiles
  for i in range(number_of_rows):
  # set y coordinates (-y so scrolls downwards)
      y = -i * tile_size
      for j in range(number_of_columns):
          # set x coordinate
          x = j * tile_size + x_offset
          if i > grace_period:
            tile_type = random_tile_type()
            tile = Tile(x, y, tile_type)
            tiles.append(tile)
          
  #cat
  global cat_size
  cat_size = tile_size
  global cat
  cat = Cat(cat_size)
  # initial position
  cat.x = width/2
  cat.y = height/2
  
  # display
  global score
  score = 0
  global lives
  lives = 3
  
  # speed
  global lowest_speed
  lowest_speed = 5
  global highest_speed
  highest_speed = 20
  global speed
  speed = lowest_speed

def draw():
   background(0)
   lights()
   
   global score 
   fill(255)
   textSize(tile_size/2.5)
   text("Score: {}".format(score), 10, tile_size/2)
   
   global lives
   text("Lives: {}".format(lives), width-(tile_size*1.5), tile_size/2)

   # set speed but keep within limits
   speed = constrain(score/2, lowest_speed, highest_speed)

   pushMatrix()
   rotateX(radians(50))
   cat.draw_cat()
           
   for tile in tiles:
     if lives >= 1:
        tile.y = tile.y + speed
        tile.draw_tile()
        # check each tile for hits
        if tile.target_hit(cat.x, cat.y):
            score += 1
        if tile.hole_hit(cat.x, cat.y):
            lives -=1
            
   popMatrix()
   recycle_tiles()
   
# recycle tiles off the screen
def recycle_tiles():
    # get y coord of last tile
    y = 0
    global tiles
    for tile in tiles:
        if tile.y < y:
            y = tile.y
        
    # moves tiles to the end (x coord can stay the same)
    new_y = y - tile_size
    for tile in tiles:
    # if off the screen
        if tile.y > height:
            tile.y = new_y
            tile.type = random_tile_type()
     
# generate a random type of tile
def random_tile_type():
    tile_type = standard_tile
    # randomised tile chances
    if random(0, 5) > 4:
        tile_type = hole_tile
    if random(0, 50) > 45:
        tile_type = target_tile
    return tile_type

class Cat:

  def __init__(self, cat_size):
    self.x = 0
    self.y = 0
    self.cat_colour = color(255, 200, 0)
    self.cat_size = cat_size
    self.tail_length = cat_size/4
    self.tail_thickness = cat_size/7
    self.tail = []
    # initialise tail parts using 2 dimensional list
    for i in range (self.tail_length):
        self.tail.append([0, 0])

  def draw_cat(self):
    # draw body in separate matrix so can rotate
    pushMatrix()
    noStroke()
    translate(self.x, self.y)
    rotateX(frameCount/20.0) # roll
    sphereDetail(7)
    fill(self.cat_colour)
    sphere(cat_size * 0.4) 
    popMatrix()

    pushMatrix()
    noStroke()
    # draw head
    translate(self.x, self.y - (cat_size/2))
    sphereDetail(8)
    sphere(self.cat_size * 0.2)
    # draw ears
    # left
    pushMatrix()
    #fill(0, 0, 255)
    translate(-cat_size*0.1, -cat_size*0.05, cat_size*0.15)
    rotateY(0.5)
    rotateX(4)
    sphereDetail(1)
    sphere(cat_size*0.1)
    popMatrix()
    # right
    pushMatrix()
    translate(cat_size*0.1, -cat_size*0.05, cat_size*0.15)
    rotateY(3)
    rotateX(2)
    sphereDetail(1)
    sphere(cat_size*0.1)
    popMatrix()
    #triangle(-size*0.1, -size*0.05, -size*0.05, -size*0.2, -size*0.25, -size*0.3)
    #triangle(size*0.1, -size*0.05, size*0.05, -size*0.20, size*0.25, -size*0.3)
    # draw tail
    sphereDetail(8)
    # tail end
    self.tail[self.tail_length-1][0] = (sin(frameCount * 0.2) * 10)
    self.tail[self.tail_length-1][1] = cat_size/2
    # rest of tail
    for i in range(self.tail_length-1):
        self.tail[i][0] = self.tail[i+1][0]
        self.tail[i][1] = self.tail[i+1][1] + (self.tail_thickness/2)
        pushMatrix()
        #ellipse(tail[i].x, tail[i].y, tailThickness, tailThickness)
        translate(self.tail[i][0], self.tail[i][1])
        sphere(self.tail_thickness)
        popMatrix()
    popMatrix()
    
# class for tiles
class Tile:
    
  global standard_tile_colour
  standard_tile_colour = color(255) # white
  global hole_tile_colour
  hole_tile_colour = color(0) # black
  global hole_hit_tile_colour
  hole_hit_tile_colour = color(255, 0, 0) #red
  global target_tile_colour
  target_tile_colour = color(255, 255, 0) # yellow
  
  def __init__(self, x, y, type):
      self.x = x
      self.y = y
      self.type = type

  def draw_tile(self):
      stroke(0)
      if self.type == standard_tile:
        tile_colour = fill(standard_tile_colour)
      elif self.type == hole_tile:
        tile_colour = fill(hole_tile_colour)
      elif self.type == hole_hit_tile:
        tile_colour = fill(hole_hit_tile_colour)
      elif self.type == target_tile:
        tile_colour = fill(target_tile_colour)
      square(self.x, self.y, tile_size)
  
  def target_hit(self, cat_x, cat_y):
    target_hit = self.hit(cat_x, cat_y) and self.type == target_tile
    if target_hit:
      self.type = standard_tile
    return target_hit

  def hole_hit(self, cat_x, cat_y):
    hole_hit = self.hit(cat_x, cat_y) and self.type == hole_tile
    if hole_hit:
      self.type = hole_hit_tile
    return hole_hit
  
  # check if we hit a tile
  def hit(self, cat_x, cat_y):
      hit = cat_y >= self.y and cat_y <= self.y + tile_size and cat_x >= self.x and cat_x <= self.x + tile_size
      return hit

    
def mouseMoved():
    cat.x = mouseX
    cat.y = mouseY
    
def setup():
    # set the size of the window
    size(600, 400)
    global ships
    ships = []
    
    for i in range(10):
        ships.append(PirateShip())
        
    # waves
    global wave_max_height
    wave_max_height = 20
    global wave_min_height
    wave_min_height = 5
    global wave_height
    wave_height = wave_max_height
    global up
    up = 1
    global down
    down = -1
    global wave_direction
    wave_direction = up

def draw():
    # light blue background
    background(102, 205, 170)
    
    # waves
    global wave_max_height
    global wave_min_height
    global wave_height
    global wave_direction
    noFill()
    # determine of the vwaes should be going up or down
    if wave_height <= wave_min_height:
        wave_direction = up
    if wave_height >= wave_max_height:
        wave_direction = down
    # change the wave height for next time
    wave_height += wave_direction
    # wave y coordinate
    wave_y = wave_max_height//2
    # while the y coordinate is less than the height of the window
    while wave_y <= height:
        # wave x coordinate
        wave_x = 0
        # while the x coordinate is less than the width of the window
        while wave_x <= width:
            # draw a semi=circle arc
            arc(wave_x, wave_y, wave_max_height, wave_height, 0, PI)
            # increase the x coordinate by 20
            wave_x += wave_max_height
        
        # increase the y coordinate by 20
        wave_y += wave_max_height
    
    global ships
    for ship in ships:
        ship.display()
        ship.move()
    
class PirateShip:
    # pirate ship variables
    x_position = 0
    y_position = 0
    ship_length = 0
    sails = 0
    sail_colour = 0
    porthole_count = 0
    sail_spacing = 0
    speed = 0
    
    def __init__(self):
        # initialise the ship
        self.initialise()
        
    def initialise(self):
        # initialise the ship at a random-ish location
        self.x_position = random(600, 700)
        self.y_position = random(50, 350)
        self.ship_length = random(40, 100)
        # speed
        self.speed = self.ship_length//20
        # sails
        self.sails = int(min((self.ship_length//30), 3))
        self.sail_colour = color(random(255), random(255), random(255))
        self.sail_spacing = floor(self.ship_length / 3)
        # portholes
        self.porthole_count = int(self.ship_length//12)

    def display(self):
        # calculate ship coordinates
        front_of_ship_x_position = self.x_position - (self.ship_length / 2)
        back_of_ship_x_position = self.x_position + self.ship_length + (self.ship_length / 3)

        # ship hull
        # brown lines and fill
        stroke(139, 71, 38)
        fill(139, 71, 38)
        # middle rectangle
        rect(self.x_position, self.y_position, self.ship_length, 20)
        # front and back
        triangle(front_of_ship_x_position, self.y_position, self.x_position, self.y_position, self.x_position, self.y_position + 20)
        triangle(self.x_position + self.ship_length, self.y_position, back_of_ship_x_position, self.y_position, self.x_position + self.ship_length, self.y_position + 20)

        # draw the sails
        initial_sail_x_position = self.x_position + 15
        # black lines
        stroke(0)
        for i in range(self.sails):
            # sail
            fill(self.sail_colour)
            quad(initial_sail_x_position + (self.sail_spacing * i), self.y_position - 40, initial_sail_x_position + (self.sail_spacing * i) + 10, self.y_position - 40, initial_sail_x_position + (self.sail_spacing * i) + 20, self.y_position - 10, initial_sail_x_position + (self.sail_spacing * i), self.y_position - 10)
            # mast
            fill(0)
            line(initial_sail_x_position + (self.sail_spacing * i), self.y_position - 10, initial_sail_x_position + (self.sail_spacing * i), self.y_position)
            line(initial_sail_x_position + (self.sail_spacing * i), self.y_position - 40, initial_sail_x_position + (self.sail_spacing * i), self.y_position - 50)
            # flag
            fill(0)
            rect(initial_sail_x_position + (self.sail_spacing * i), self.y_position - 50, 10, 5)
            # jolly roger
            stroke(255)
            line(initial_sail_x_position + (self.sail_spacing * i) + 2, self.y_position - 49, initial_sail_x_position + (self.sail_spacing * i) + 8, self.y_position - 46)
            line(initial_sail_x_position + (self.sail_spacing * i) + 8, self.y_position - 49, initial_sail_x_position + (self.sail_spacing * i) + 2, self.y_position - 46)
            stroke(0)
        
        # draw the portholes
        for i in range(self.porthole_count):
            # portholes
            fill(0)
            circle(self.x_position+(15*i),self.y_position+10,5)
            
        # ship has left the screen
        if back_of_ship_x_position <= 0:
            # start again
            self.initialise()
            
    def move(self):
        self.x_position -= self.speed