​

let gameStarted = false;

let backgroundImage, boatImage, alligatorImage;

let playerX, playerY, playerSpeed;

let flowers = []; // Array to hold individual flower objects

let alligators = [];

let collectedFlowers = 0;

let gameTimer = 60;

let isGameOver = false;

let followSpeed = 0.4; // Slower speed for gentle flow

let flowerGenerationInterval = 1000; // Interval for generating new flowers in milliseconds

let lastGenerationTime = 0;

let rippleOffset = 0;

let musicBeat = 0;

let boatSize = 300; // Increased boat size

let music;

let collectSound, gameOverSound;

let fft;

let rippleYOffsets = []; // Array to store ripple Y offsets

let particles = []; // Array to hold particle objects for visual effects

​

function preload() {

  // Load images

  backgroundImage = loadImage('start.png'); // Start screen background

  boatImage = loadImage('boat.png'); // Boat image

  alligatorImage = loadImage('aligator.png'); // Alligator image

  // Load sounds

  music = loadSound('bonbibi.mp3'); // Background music

  //collectSound = loadSound('assets/collect.mp3'); // Sound when collecting a flower

  //gameOverSound = loadSound('assets/gameover.mp3'); // Sound for game over

}

​

function setup() {

  createCanvas(windowWidth, windowHeight);

  textAlign(CENTER, CENTER);

  textSize(32);

  resetGame();

  generateAlligators();

  // Initialize background music

  music.loop();

  // Initialize FFT for music analysis

  fft = new p5.FFT();

  fft.setInput(music);

  // Initialize ripple Y offsets for multiple ripples

  for (let i = 0; i < width; i += 50) {

    rippleYOffsets.push(random(TWO_PI));

  }

}

​

function draw() {

  if (!gameStarted) {

    drawStartScreen();

  } else if (isGameOver) {

    drawGameOverScreen();

  } else {

    drawRiverChallenge();

  }

}

​

function drawStartScreen() {

  background(backgroundImage);

  // Typewriter-style text

  fill(255);

  drawTypewriterText("Press ENTER to Start Your Adventure", width / 2, height / 2 - 50);

  textSize(24);

  text("Quest for Sundarbans: Collect Flowers and Avoid Alligators!", width / 2, height / 4);

  text("How to Play: Use Arrow Keys to Move the Boat.", width / 2, height / 2 + 50);

​

  // Start the game when ENTER is pressed

  if (keyIsPressed && keyCode === ENTER) {

    gameStarted = true;

    music.play(); // Ensure music plays when the game starts

  }

}

​

function drawRiverChallenge() {

  drawRiverBackground();

  drawBoat();

  updateAndDrawFlowers();

  drawAlligators();

  drawCollectedFlowers();

  drawTimer();

​

  movePlayer();

  checkCollisions();

​

  if (gameTimer <= 0) {

    isGameOver = true;

    music.stop();

    gameOverSound.play(); // Play game over sound

  }

}

​

function drawGameOverScreen() {

  background(0, 0, 0, 150); // Semi-transparent black background

  fill(255, 0, 0);

  textSize(48);

  text("Game Over!", width / 2, height / 2 - 50);

  textSize(32);

  fill(255);

  text(`Flowers Collected: ${collectedFlowers}`, width / 2, height / 2);

  textSize(24);

  text("Press 'R' to Restart", width / 2, height / 2 + 50);

}

​

function drawRiverBackground() {

  background('#87CEFA'); // Light blue color for river

​

  // Draw advanced ripple effects using Perlin noise

  noFill();

  stroke(173, 216, 230, 150); // Light blue color for ripples

  strokeWeight(2);

  beginShape();

  let y = height / 2;

  for (let x = 0; x <= width; x += 10) {

    let yOffset = map(noise(x * 0.005, rippleOffset), 0, 1, -20, 20);

    vertex(x, y + yOffset);

  }

  endShape();

​

  rippleOffset += 0.005; // Control ripple speed

​

  // Optional: Draw multiple ripple layers

  stroke(135, 206, 235, 100); // Slightly different shade

  strokeWeight(1);

  beginShape();

  for (let x = 0; x <= width; x += 10) {

    let yOffset = map(noise(x * 0.01, rippleOffset * 1.5), 0, 1, -10, 10);

    vertex(x, y + yOffset);

  }

  endShape();

}

​

function drawBoat() {

  image(boatImage, playerX, playerY, boatSize, boatSize);

}

​

function updateAndDrawFlowers() {

  let currentTime = millis();

  if (currentTime - lastGenerationTime > flowerGenerationInterval) {

    generateFlower();

    lastGenerationTime = currentTime;

  }

​

  for (let i = flowers.length - 1; i >= 0; i--) {

    let flower = flowers[i];

    updateFlower(flower);

    drawFlower(flower.x, flower.y, flower.size, flower.rotation, flower.type);

    flower.rotation += 0.01; // Update rotation angle for animation

​

    // Make flowers pulse with music beat

    let spectrum = fft.analyze();

    let bass = fft.getEnergy("bass");

    let scaleFactor = 1 + 0.05 * sin(musicBeat + flower.y * 0.1);

    flower.size = flower.originalSize * scaleFactor;

  }

  musicBeat += 0.05;

​

  // Update and draw particles

  updateAndDrawParticles();

}

​

function updateFlower(flower) {

  flower.y += followSpeed;

  if (flower.y > height) {

    flowers.splice(flowers.indexOf(flower), 1); // Remove flower from array

  }

}

​

function drawFlower(x, y, size, rotation, type) {

  push();

  translate(x, y);

  rotate(rotation);

​

  // Draw glow synchronized with music beat

  let spectrum = fft.analyze();

  let bass = fft.getEnergy("bass");

  let glowIntensity = map(bass, 0, 255, 100, 300);

  drawingContext.shadowBlur = glowIntensity;

  drawingContext.shadowColor = color(255, 255, 255, 150);

  switch (type) {

    case 0:

      drawDaisy(0, 0, size, rotation);

      break;

    case 1:

      drawTulip(0, 0, size, rotation);

      break;

    case 2:

      drawRose(0, 0, size, rotation);

      break;

    case 3:

      drawSunflower(0, 0, size, rotation);

      break;

    case 4:

      drawLily(0, 0, size, rotation);

      break;

    case 5:

      drawMarigold(0, 0, size, rotation);

      break;

  }

​

  pop();

}

​

function drawAlligators() {

  for (let i = 0; i < alligators.length; i++) {

    let alligator = alligators[i];

    push();

    translate(alligator.x, alligator.y);

    // Optional: Add sway animation

    rotate(sin(frameCount * 0.05 + i) * 0.1);

    image(alligatorImage, 0, 0, 150, 75); // Increased alligator size

    pop();

    alligator.y += alligator.speed;

    if (alligator.y > height + 50) {

      alligator.y = -random(100, 300);

      alligator.x = random(50, width - 200); // Prevent overlapping

      ensureAlligatorSpacing(i);

    }

  }

}

​

function ensureAlligatorSpacing(index) {

  for (let i = 0; i < alligators.length; i++) {

    if (i !== index) {

      let distance = dist(alligators[i].x, alligators[i].y, alligators[index].x, alligators[index].y);

      if (distance < 200) { // Increased spacing

        alligators[index].x = random(50, width - 200);

      }

    }

  }

}

​

function drawCollectedFlowers() {

  fill(255);

  textSize(24);

  textAlign(LEFT, TOP);

  text(`Flowers Collected: ${collectedFlowers}`, 20, 20);

}

​

function drawTimer() {

  fill(255);

  textSize(24);

  textAlign(RIGHT, TOP);

  let timerText = `Time Remaining: ${gameTimer} s`;

  text(timerText, width - 20, 20);

​

  if (frameCount % 60 === 0 && gameTimer > 0) {

    gameTimer--;

  }

}

​

function movePlayer() {

  if (keyIsDown(LEFT_ARROW)) {

    playerX -= playerSpeed;

  }

  if (keyIsDown(RIGHT_ARROW)) {

    playerX += playerSpeed;

  }

  if (keyIsDown(UP_ARROW)) {

    playerY -= playerSpeed;

  }

  if (keyIsDown(DOWN_ARROW)) {

    playerY += playerSpeed;

  }

​

  playerX = constrain(playerX, 0, width - boatSize);

  playerY = constrain(playerY, 0, height - boatSize);

}

​

function checkCollisions() {

  for (let i = flowers.length - 1; i >= 0; i--) {

    let flower = flowers[i];

    let distance = dist(playerX + boatSize / 2, playerY + boatSize / 2, flower.x, flower.y);

    if (distance < 50) { // Collision threshold

      flowers.splice(i, 1);

      collectedFlowers++;

      collectSound.play(); // Play collect sound

      // Create particles for visual feedback

      for (let j = 0; j < 20; j++) {

        particles.push(new Particle(flower.x, flower.y));

      }

    }

  }

​

  for (let alligator of alligators) {

    let distance = dist(playerX + boatSize / 2, playerY + boatSize / 2, alligator.x + 75, alligator.y + 37.5);

    if (distance < 80) { // Collision threshold adjusted for alligator size

      isGameOver = true;

      music.stop();

      gameOverSound.play(); // Play game over sound

    }

  }

}

​

function keyPressed() {

  if (isGameOver && (key === 'R' || key === 'r')) {

    resetGame();

    gameStarted = true;

    music.play();

  }

}

​

function resetGame() {

  playerX = width / 2 - boatSize / 2;

  playerY = height - boatSize - 50;

  playerSpeed = 5;

  collectedFlowers = 0;

  gameTimer = 60;

  gameStarted = false;

  isGameOver = false;

  flowers = [];

  particles = [];

  generateAlligators();

}

​

function generateFlower() {

  let size = random(30, 60);

  let flowerType = floor(random(6));

  flowers.push({

    x: random(50, width - 50),

    y: -30,

    size: size,

    originalSize: size,

    rotation: random(TWO_PI),

    type: flowerType

  });

}

​

function generateAlligators() {

  alligators = [];

  for (let i = 0; i < 5; i++) {

    alligators.push({

      x: random(50, width - 200),

      y: random(-600, -100),

      speed: random(2, 5),

    });

  }

}

​

function drawTypewriterText(content, x, y) {

  let charIndex = floor(frameCount / 5) % (content.length + 1);

  fill(255, 223, 0);

  stroke(101, 67, 33);

  strokeWeight(5);

  rectMode(CENTER);

  rect(x, y, textWidth(content) + 40, 50, 10);

  noStroke();

  fill(0);

  text(content.substring(0, charIndex), x, y);

}

​

// Particle Class for visual effects

class Particle {

  constructor(x, y) {

    this.position = createVector(x, y);

    this.velocity = p5.Vector.random2D().mult(random(1, 3));

    this.lifespan = 255;

  }

​

  update() {

    this.position.add(this.velocity);

    this.lifespan -= 4;

  }

​

  display() {

    noStroke();

    fill(255, this.lifespan);

    ellipse(this.position.x, this.position.y, 8);

  }

​

  isFinished() {

    return this.lifespan < 0;

  }

}

​

// Particle effects for visual feedback

function updateAndDrawParticles() {

  for (let i = particles.length - 1; i >= 0; i--) {

    let p = particles[i];

    p.update();

    p.display();

    if (p.isFinished()) {

      particles.splice(i, 1);

    }

  }

}

​

// Flower Drawing Functions

function drawDaisy(x, y, size, rotation) {

  let petalCount = 9;

  let petalLength = size;

  let petalWidth = size / 3;

​

  stroke(0);

  fill('#D9E4E6');

  push();

  translate(x, y);

  rotate(rotation);

  for (let i = 0; i < petalCount; i++) {

    push();

    rotate(TWO_PI / petalCount * i);

    ellipse(0, -size / 2, petalWidth, petalLength);

    pop();

  }

  pop();

​

  fill('#F2F2F2');

  noStroke();

  ellipse(0, 0, size / 2);

}

​

function drawTulip(x, y, size, rotation) {

  let petalCount = 6;

  let petalWidth = size / 2;

​

  stroke(0);

  fill('#AEB7FE');

  push();

  translate(x, y);

  rotate(rotation);

  for (let i = 0; i < petalCount; i++) {

    push();

    rotate(TWO_PI / petalCount * i);

    ellipse(0, -size / 2, petalWidth, size);

    pop();

  }

  pop();

​

  fill('#EDEAE6');

  noStroke();

  ellipse(0, 0, size / 3);

}

​

function drawRose(x, y, size, rotation) {

  let petalCount = 10;

  let petalWidth = size / 3;

​

  stroke(0);

  fill('#D87373');

  push();

  translate(x, y);

  rotate(rotation);

  for (let i = 0; i < petalCount; i++) {

    push();

    rotate(TWO_PI / petalCount * i);

    ellipse(0, -size / 2, petalWidth, size / 1.5);

    pop();

  }

  pop();

​

  fill('#F5E6E8');

  noStroke();

  ellipse(0, 0, size / 4);

}

​

function drawSunflower(x, y, size, rotation) {

  let petalCount = 20;

  let petalLength = size * 1.5;

  let petalWidth = size / 2;

​

  stroke(0);

  fill('#FACA49');

  push();

  translate(x, y);

  rotate(rotation);

  for (let i = 0; i < petalCount; i++) {

    push();

    rotate(TWO_PI / petalCount * i);

    ellipse(0, -size / 2, petalWidth, petalLength);

    pop();

  }

  pop();

​

  fill('#6E4B1B');

  noStroke();

  ellipse(0, 0, size);

}

​

function drawLily(x, y, size, rotation) {

  let petalCount = 6;

  let petalWidth = size / 2;

​

  stroke(0);

  fill('#998D30');

  push();

  translate(x, y);

  rotate(rotation);

  for (let i = 0; i < petalCount; i++) {

    push();

    rotate(TWO_PI / petalCount * i);

    ellipse(0, -size / 2, petalWidth, size);

    pop();

  }

  pop();

​

  fill('#FBE7E7');

  noStroke();

  ellipse(0, 0, size / 4);

}

​

function drawMarigold(x, y, size, rotation) {

  let petalCount = 12; // Number of petals

  let petalLength = size; // Length of petals

  let petalWidth = size / 2; // Width of petals

​

  stroke(0);

  fill('#F4A263'); // Bright orange color

  push();

  translate(x, y);

  rotate(rotation); // Apply rotation

  for (let i = 0; i < petalCount; i++) {

    push();

    rotate(TWO_PI / petalCount * i);

    ellipse(0, -size / 2, petalWidth, petalLength);

    pop();

  }

  pop();

​

  fill('#FFD700'); // Center of the marigold

  noStroke();

  ellipse(0, 0, size / 3);

}

​

// Particle Class for visual effects

class Particle {

  constructor(x, y) {

    this.position = createVector(x, y);

    this.velocity = p5.Vector.random2D().mult(random(1, 3));

    this.lifespan = 255;

  }

​

  update() {

    this.position.add(this.velocity);

    this.lifespan -= 4;

  }

​

  display() {

    noStroke();

    fill(255, this.lifespan);

    ellipse(this.position.x, this.position.y, 8);

  }

​

  isFinished() {

    return this.lifespan < 0;

  }

}

​

// Particle effects for visual feedback

function updateAndDrawParticles() {

  for (let i = particles.length - 1; i >= 0; i--) {

    let p = particles[i];

    p.update();

    p.display();

    if (p.isFinished()) {

      particles.splice(i, 1);

    }

  }

}

​