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