Data Types

1. Numbers

Numbers are used throughout the game for values that can be counted, measured, compared, or calculated. In my game, numbers control player health, boss health, attack cooldowns, laser speed, coin value, score, position, and movement.

• this.playerMaxHealth stores the maximum health for the player.
• this.playerHealth stores the current health during the battle.
• this.attackCooldownMs stores the number of milliseconds between attacks.
• this.laserSpeed controls how fast the laser moves.
• this.coinValue controls how many points each coin is worth.
• this.levelScore stores the final score for the level.

this.playerMaxHealth = config.playerHealth ?? 5;
this.playerHealth = this.playerMaxHealth;
this.attackCooldownMs = config.attackCooldownMs ?? 450;
this.laserSpeed = config.laserSpeed ?? 14;
this.coinValue = config.coinValue ?? 25;
this.levelScore = 0;

This proves the numbers requirement because the game uses numeric values to control health, timing, projectile movement, coin rewards, and score calculation.

2. Strings

Strings are text values. In my game, strings are used for the selected game mode, player names, sprite image paths, localStorage keys, enemy names, and HUD messages.

• 'singlePlayer' and 'twoPlayer' are string values for game mode.
• 'Ishan' and 'Player 2' are default player-name strings.
• 'ishan-jha.png' is a sprite image path string.
• 'peppaGameMode' and 'peppaPlayer1CharName' are localStorage key strings.
• Template literals create HUD messages such as coin collection and laser hit feedback.

this.gameMode = config.gameMode ?? localStorage.getItem('peppaGameMode') ?? 'singlePlayer';
this.playerName = config.playerName || 'Ishan';

const p1CharImage = localStorage.getItem('peppaPlayer1CharImage') || 'ishan-jha.png';
const p2CharName = localStorage.getItem('peppaPlayer2CharName') || 'Player 2';

this.updateHud(`Coin collected! +${this.coinValue} score`);

This proves the strings requirement because the game uses text values to store modes, names, file paths, browser storage keys, and player-facing messages.

3. Booleans

Booleans are values that are either true or false. In my game, booleans are used as flags to track whether the battle is over, whether an attack was requested, whether a laser belongs to a player, whether a coin was collected, and whether the boss has been defeated.

• this.battleEnded prevents the game from continuing after a win or loss.
• this.attackRequested tracks whether Player 1 pressed the attack key.
• this.player2AttackRequested tracks whether Player 2 pressed the attack key.
• isPlayerLaser identifies whether a laser belongs to a player.
• this.isDefeated tracks whether the boss has been defeated.

this.battleEnded = false;
this.attackRequested = false;
this.player2AttackRequested = false;

this.lasers.push({
    x: fromX,
    y: fromY,
    isPlayerLaser,
    life: 60
});

this.isDefeated = false;

This proves the booleans requirement because the game uses true-or-false values to control decisions, stop repeated actions, and track whether events have happened.

4. Arrays

Arrays are lists of values. In my game, arrays store active lasers, coins, game classes, power-up options, and leaderboard entries. This lets the game handle many objects without creating a separate variable for every single laser, coin, or leaderboard score.

• this.lasers stores all active laser projectiles.
• this.coins stores all collectible coins.
• this.classes stores the game objects that should be created for the level.
• this.leaderboard stores score entries.
• this.options stores power-up choices.

this.lasers = [];
this.coins = [];
this.leaderboard = [];

this.classes = [
    { class: GameEnvBackground, data: image_data_background },
    { class: Player, data: sprite_data_ishan }
];

this.options = [
    { name: 'Extra Speed', description: 'Move faster in battle' },
    { name: 'Extra Health', description: 'Start with more health' },
    { name: 'Extra Damage', description: 'Deal more damage per laser' }
];

This proves the arrays requirement because the game uses arrays to store and update collections of lasers, coins, class definitions, leaderboard scores, and power-up choices.

5. Objects / JSON

Objects store related information using key-value pairs. In my game, objects are used for configuration settings, sprite data, laser data, character data, spawn positions, leaderboard entries, and power-up data. These objects are similar to JSON because they organize data with property names and values.

• config is an object that controls level settings.
• charData stores a character's image, name, and accent color.
• Laser objects store position, velocity, source, and lifetime.
• this.playerSpawn stores x and y spawn coordinates.
• Power-up objects store a name and description.

const charData = {
    image: char.image,
    name: char.name,
    accentColor: accentColor
};

this.playerSpawn = {
    x: width * 0.12,
    y: height * 0.72
};

this.lasers.push({
    x: fromX,
    y: fromY,
    vx,
    vy,
    isPlayerLaser,
    source: sourceId,
    life: 60,
    maxLife: 60
});

This proves the objects / JSON requirement because the game uses object literals to group related data together and pass structured information between different parts of the game.

this.gameMode = config.gameMode ?? localStorage.getItem('peppaGameMode') ?? 'singlePlayer'; // String
this.playerMaxHealth = config.playerHealth ?? 5;      // Number
this.player2Health = this.player2MaxHealth;          // Number
this.attackRequested = false;                      // Boolean
this.player2AttackRequested = false;               // Boolean
this.lasers = [];                                     // Array
this.coins = [];                                      // Array
this.playerSpawn = { x: width * 0.12, y: height * 0.72 }; // Object

The updated game uses many JavaScript data types. Strings store the game mode and player names, numbers store health and score values, booleans track whether attacks were requested, arrays store lasers and coins, and objects store spawn positions and sprite data.

A strong example is this.gameMode. It can be 'singlePlayer' or 'twoPlayer', and the rest of the code changes behavior based on that string.

Arrays are used to store multiple game objects, lasers, coins, and leaderboard entries. This lets the game update many items every frame without needing separate variables for each one.

this.classes = [
    { class: GameEnvBackground, data: image_data_background },
    { class: Player, data: sprite_data_ishan }
];

if (this.gameMode === 'twoPlayer') {
    this.classes.push({ class: Player, data: sprite_data_player2 });
} else {
    this.classes.push({ class: PeppaBossEnemy, data: sprite_data_enemy });
}

This is important because the game builds a different class list depending on the selected mode. Two-player mode adds a second player, while single-player mode adds the boss enemy.

this.lasers.push({
    x: fromX,
    y: fromY,
    vx,
    vy,
    isPlayerLaser,
    source: sourceId,
    life: 60,
    maxLife: 60
});

The source property makes the laser system more flexible. A laser can come from player1, player2, or the boss, so the collision system knows who should be damaged.