Cat Scratch Game

Embarking on a journey to create a captivating and engaging Cat Scratch Game can be an exciting adventure for both beginners and experienced developers. This game, inspired by the classic cat scratch fever, offers a unique blend of strategy and fun. Whether you're looking to build a simple version for personal enjoyment or a more complex one for a broader audience, this guide will walk you through the essential steps and considerations.

Table of Contents

Understanding the Basics of a Cat Scratch Game

A Cat Scratch Game is a type of game where players strategically place their moves to avoid being scratched by a cat. The game can be designed in various ways, from a simple 2D grid to a more complex 3D environment. The core mechanics involve players navigating through a maze or grid while avoiding obstacles and traps set by the cat.

Designing the Game Mechanics

Before diving into the coding, it's crucial to have a clear understanding of the game mechanics. Here are some key elements to consider:

Game Board: Decide on the size and layout of the game board. A 10x10 grid is a good starting point for a 2D game.
Player Movement: Define how the player can move. Common options include arrow keys or WASD keys.
Cat Behavior: Determine the cat's movement pattern. It could be random, following a specific path, or chasing the player.
Scoring System: Implement a scoring system to keep track of the player's progress. Points can be awarded for avoiding scratches or reaching certain milestones.
Game Over Conditions: Define the conditions for game over, such as being scratched by the cat or running out of time.

Setting Up the Development Environment

To develop a Cat Scratch Game, you'll need a suitable development environment. Here are the steps to set up your environment:

Choose a Programming Language: Popular choices include Python with Pygame, JavaScript with HTML5 Canvas, or C# with Unity.
Install Necessary Tools: For example, if you choose Python, install Python and Pygame. For JavaScript, you can use a code editor like Visual Studio Code.
Create a Project Folder: Organize your files and assets in a dedicated project folder.

💡 Note: Ensure you have a basic understanding of the chosen programming language and its libraries before starting the development.

Creating the Game Board

The game board is the foundation of your Cat Scratch Game. Here’s how you can create a simple 2D grid using Python and Pygame:

import pygame
import sys

# Initialize Pygame
pygame.init()

# Screen dimensions
screen_width = 800
screen_height = 800
cell_size = 80

# Colors
white = (255, 255, 255)
black = (0, 0, 0)

# Set up the screen
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('Cat Scratch Game')

# Create the game board
def draw_board():
    for row in range(10):
        for col in range(10):
            rect = pygame.Rect(col * cell_size, row * cell_size, cell_size, cell_size)
            pygame.draw.rect(screen, white, rect, 1)

# Main game loop
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill(black)
    draw_board()
    pygame.display.flip()

pygame.quit()
sys.exit()

Implementing Player Movement

Next, let's add player movement to the game. The player will be represented by a small square that can move around the grid.

import pygame
import sys

# Initialize Pygame
pygame.init()

# Screen dimensions
screen_width = 800
screen_height = 800
cell_size = 80

# Colors
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)

# Set up the screen
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('Cat Scratch Game')

# Player settings
player_size = 40
player_pos = [4 * cell_size, 4 * cell_size]
player_speed = cell_size

# Create the game board
def draw_board():
    for row in range(10):
        for col in range(10):
            rect = pygame.Rect(col * cell_size, row * cell_size, cell_size, cell_size)
            pygame.draw.rect(screen, white, rect, 1)

# Draw the player
def draw_player():
    pygame.draw.rect(screen, red, (player_pos[0], player_pos[1], player_size, player_size))

# Main game loop
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_pos[0] > 0:
        player_pos[0] -= player_speed
    if keys[pygame.K_RIGHT] and player_pos[0] < screen_width - player_size:
        player_pos[0] += player_speed
    if keys[pygame.K_UP] and player_pos[1] > 0:
        player_pos[1] -= player_speed
    if keys[pygame.K_DOWN] and player_pos[1] < screen_height - player_size:
        player_pos[1] += player_speed

    screen.fill(black)
    draw_board()
    draw_player()
    pygame.display.flip()

pygame.quit()
sys.exit()

Adding the Cat Character

Now, let's add the cat character to the game. The cat will move randomly around the grid, trying to scratch the player.

import pygame
import sys
import random

# Initialize Pygame
pygame.init()

# Screen dimensions
screen_width = 800
screen_height = 800
cell_size = 80

# Colors
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
blue = (0, 0, 255)

# Set up the screen
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('Cat Scratch Game')

# Player settings
player_size = 40
player_pos = [4 * cell_size, 4 * cell_size]
player_speed = cell_size

# Cat settings
cat_size = 40
cat_pos = [random.randint(0, 9) * cell_size, random.randint(0, 9) * cell_size]
cat_speed = cell_size

# Create the game board
def draw_board():
    for row in range(10):
        for col in range(10):
            rect = pygame.Rect(col * cell_size, row * cell_size, cell_size, cell_size)
            pygame.draw.rect(screen, white, rect, 1)

# Draw the player
def draw_player():
    pygame.draw.rect(screen, red, (player_pos[0], player_pos[1], player_size, player_size))

# Draw the cat
def draw_cat():
    pygame.draw.rect(screen, blue, (cat_pos[0], cat_pos[1], cat_size, cat_size))

# Move the cat randomly
def move_cat():
    direction = random.choice(['UP', 'DOWN', 'LEFT', 'RIGHT'])
    if direction == 'UP' and cat_pos[1] > 0:
        cat_pos[1] -= cat_speed
    elif direction == 'DOWN' and cat_pos[1] < screen_height - cat_size:
        cat_pos[1] += cat_speed
    elif direction == 'LEFT' and cat_pos[0] > 0:
        cat_pos[0] -= cat_speed
    elif direction == 'RIGHT' and cat_pos[0] < screen_width - cat_size:
        cat_pos[0] += cat_speed

# Main game loop
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_pos[0] > 0:
        player_pos[0] -= player_speed
    if keys[pygame.K_RIGHT] and player_pos[0] < screen_width - player_size:
        player_pos[0] += player_speed
    if keys[pygame.K_UP] and player_pos[1] > 0:
        player_pos[1] -= player_speed
    if keys[pygame.K_DOWN] and player_pos[1] < screen_height - player_size:
        player_pos[1] += player_speed

    move_cat()

    screen.fill(black)
    draw_board()
    draw_player()
    draw_cat()
    pygame.display.flip()

pygame.quit()
sys.exit()

Implementing Game Over Conditions

To make the game more challenging, let's add game over conditions. The game will end if the player is scratched by the cat.

import pygame
import sys
import random

# Initialize Pygame
pygame.init()

# Screen dimensions
screen_width = 800
screen_height = 800
cell_size = 80

# Colors
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
blue = (0, 0, 255)

# Set up the screen
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('Cat Scratch Game')

# Player settings
player_size = 40
player_pos = [4 * cell_size, 4 * cell_size]
player_speed = cell_size

# Cat settings
cat_size = 40
cat_pos = [random.randint(0, 9) * cell_size, random.randint(0, 9) * cell_size]
cat_speed = cell_size

# Game over flag
game_over = False

# Create the game board
def draw_board():
    for row in range(10):
        for col in range(10):
            rect = pygame.Rect(col * cell_size, row * cell_size, cell_size, cell_size)
            pygame.draw.rect(screen, white, rect, 1)

# Draw the player
def draw_player():
    pygame.draw.rect(screen, red, (player_pos[0], player_pos[1], player_size, player_size))

# Draw the cat
def draw_cat():
    pygame.draw.rect(screen, blue, (cat_pos[0], cat_pos[1], cat_size, cat_size))

# Move the cat randomly
def move_cat():
    direction = random.choice(['UP', 'DOWN', 'LEFT', 'RIGHT'])
    if direction == 'UP' and cat_pos[1] > 0:
        cat_pos[1] -= cat_speed
    elif direction == 'DOWN' and cat_pos[1] < screen_height - cat_size:
        cat_pos[1] += cat_speed
    elif direction == 'LEFT' and cat_pos[0] > 0:
        cat_pos[0] -= cat_speed
    elif direction == 'RIGHT' and cat_pos[0] < screen_width - cat_size:
        cat_pos[0] += cat_speed

# Check for game over
def check_game_over():
    global game_over
    if player_pos == cat_pos:
        game_over = True

# Main game loop
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    if not game_over:
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT] and player_pos[0] > 0:
            player_pos[0] -= player_speed
        if keys[pygame.K_RIGHT] and player_pos[0] < screen_width - player_size:
            player_pos[0] += player_speed
        if keys[pygame.K_UP] and player_pos[1] > 0:
            player_pos[1] -= player_speed
        if keys[pygame.K_DOWN] and player_pos[1] < screen_height - player_size:
            player_pos[1] += player_speed

        move_cat()
        check_game_over()

    screen.fill(black)
    draw_board()
    draw_player()
    draw_cat()
    pygame.display.flip()

    if game_over:
        font = pygame.font.Font(None, 74)
        text = font.render('Game Over', True, red)
        screen.blit(text, (screen_width // 2 - text.get_width() // 2, screen_height // 2 - text.get_height() // 2))
        pygame.display.flip()
        pygame.time.wait(2000)
        running = False

pygame.quit()
sys.exit()

Adding a Scoring System

To make the game more engaging, let's add a scoring system. The player will earn points for each move they make without being scratched by the cat.

import pygame
import sys
import random

# Initialize Pygame
pygame.init()

# Screen dimensions
screen_width = 800
screen_height = 800
cell_size = 80

# Colors
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
blue = (0, 0, 255)

# Set up the screen
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption('Cat Scratch Game')

# Player settings
player_size = 40
player_pos = [4 * cell_size, 4 * cell_size]
player_speed = cell_size

# Cat settings
cat_size = 40
cat_pos = [random.randint(0, 9) * cell_size, random.randint(0, 9) * cell_size]
cat_speed = cell_size

# Game over flag
game_over = False

# Score
score = 0

# Create the game board
def draw_board():
    for row in range(10):
        for col in range(10):
            rect = pygame.Rect(col * cell_size, row * cell_size, cell_size, cell_size)
            pygame.draw.rect(screen, white, rect, 1)

# Draw the player
def draw_player():
    pygame.draw.rect(screen, red, (player_pos[0], player_pos[1], player_size, player_size))

# Draw the cat
def draw_cat():
    pygame.draw.rect(screen, blue, (cat_pos[0], cat_pos[1], cat_size, cat_size))

# Move the cat randomly
def move_cat():
    direction = random.choice(['UP', 'DOWN', 'LEFT', 'RIGHT'])
    if direction == 'UP' and cat_pos[1] > 0:
        cat_pos[1] -= cat_speed
    elif direction == 'DOWN' and cat_pos[1] < screen_height - cat_size:
        cat_pos[1] += cat_speed
    elif direction == 'LEFT' and cat_pos[0] > 0:
        cat_pos[0] -= cat_speed
    elif direction == 'RIGHT' and cat_pos[0] < screen_width - cat_size:
        cat_pos[0] += cat_speed

# Check for game over
def check_game_over():
    global game_over
    if player_pos == cat_pos:
        game_over = True

# Update score
def update_score():
    global score
    score += 1

# Main game loop
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    if not game_over:
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT] and player_pos[0] > 0:
            player_pos[0] -= player_speed
            update_score()
        if keys[pygame.K_RIGHT] and player_pos[0] < screen_width - player_size:
            player_pos[0] += player_speed
            update_score()
        if keys[pygame.K_UP] and player_pos[1] > 0:
            player_pos[1] -= player_speed
            update_score()
        if keys[pygame.K_DOWN] and player_pos[1] < screen_height - player_size:
            player_pos[1] += player_speed
            update_score()

        move_cat()
        check_game_over()

    screen.fill(black)
    draw_board()
    draw_player()
    draw_cat()
    pygame.display.flip()

    if game_over:
        font = pygame.font.Font(None, 74)
        text = font.render('Game Over', True, red)
        screen.blit(text, (screen_width // 2 - text.get_width() // 2, screen_height // 2 - text.get_height() // 2))
        pygame.display.flip()
        pygame.time.wait(2000)
        running = False

    # Display score
    font = pygame.font.Font(None, 36)
    score_text = font.render(f'Score: {score}', True, white)
    screen.blit(score_text, (10, 10))
    pygame.display.flip()

pygame.quit()
sys.exit()

Enhancing the Game with Additional Features

To make your Cat Scratch Game more exciting, consider adding additional features such as:

Levels: Create multiple levels with increasing difficulty. Each level can have a different layout and more challenging cat movements.
Power-Ups: Introduce power-ups that the player can collect to gain temporary advantages, such as increased speed or invincibility.
Sound Effects: Add sound effects for movements, scratches, and game over to enhance the gaming experience.
Graphics: Improve the visuals by using better graphics for the player, cat, and game board.

💡 Note: Adding too many features at once can make the game complex. Start with the basics and gradually add more features as you become more comfortable with the development process.

Testing and Debugging

Testing and debugging are crucial steps in developing any game. Here are some tips to ensure your Cat Scratch Game runs smoothly:

Playtest Regularly: Playtest the game frequently to identify and fix bugs early in the development process.
Use Debugging Tools: Utilize debugging tools and print statements to track down and resolve issues.
Gather Feedback: Share your game with friends or online communities to gather feedback and make improvements.

💡 Note: Testing should be an ongoing process throughout the development cycle, not just at the end.