`db1e11e`

undisclosed updates

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 month ago

SHA: db1e11ea17331e53dc5b54044b57cf0f6ba97399
Parents: 054467b
Tree: cc20753

2 changed files

Status	File	+	-
M	`js/entities.js`	311	233
M	`js/game.js`	53	12

js/entities.jsmodified

      this.bobSpeed = random(0.02, 0.04)
      this.bobAmount = 0
++    // Wind effect properties
++    this.windSway = 0 // Current sway amount
++    this.windSwayTarget = 0 // Target sway for smooth animation
++    this.windBob = 0 // Additional vertical movement from wind
++    this.basketSwing = 0 // For balloon basket swinging
++
      // Type-specific initialization
      if (this.type === 'balloon') {
        this.bobAmount = 8 // Balloons bob more
      let bob = sin(frameCount * this.bobSpeed + this.bobOffset) * this.bobAmount
      this.y = this.originalY + bob
++    // ENHANCED: Apply wind effects
++    if (windActive) {
++      // Different wind responses by type
++      if (this.type === 'balloon') {
++        // Balloons are highly affected by wind
++        this.windSwayTarget = cos(windDirection) * windStrength * 15 // Strong horizontal push
++        this.windBob =
++          sin(frameCount * 0.04 + this.bobOffset) * windStrength * 3 // Extra vertical movement
++
++        // Basket swings opposite to balloon movement (pendulum effect)
++        this.basketSwing =
++          -this.windSway * 0.5 + sin(frameCount * 0.06) * windStrength * 0.3
++
++        // Actually move the balloon
++        this.originalX += cos(windDirection) * windStrength * 0.08
++
++        // Keep on screen with stronger resistance at edges
++        if (this.originalX < 50) {
++          this.originalX = 50
++          this.windSwayTarget *= -0.5 // Bounce back effect
++        }
++        if (this.originalX > width - 50) {
++          this.originalX = width - 50
++          this.windSwayTarget *= -0.5
++        }
++      } else if (this.type === 'beetle') {
++        // Beetles resist but still affected
++        this.windSwayTarget = cos(windDirection) * windStrength * 3
++        // Fight against wind
++        this.driftAngle -= cos(windDirection) * windStrength * 0.01
++      } else if (this.type === 'leaf') {
++        // Leaves flutter in wind
++        this.windSwayTarget = cos(windDirection) * windStrength * 5
++        this.rotation += windStrength * 0.02 // Spin faster
++      }
++    } else {
++      // No wind, return to normal
++      this.windSwayTarget = 0
++      this.windBob = 0
++      this.basketSwing = 0
++    }
++
++    // Smooth sway animation
++    this.windSway = lerp(this.windSway, this.windSwayTarget, 0.1)
++
++    // Apply wind sway to position
++    this.x = this.originalX + this.windSway
++
++    // Apply wind bob to vertical position
++    this.y = this.originalY + bob + this.windBob
++
      // Beetle-specific drift
      if (this.type === 'beetle') {
        // Store initial position if not set
+   }
    display () {
++  push()
++  translate(this.x, this.y)
++
++  if (this.type === 'balloon') {
++    // ============================================
++    // HOT AIR BALLOON WITH CANVAS TEXTURE
++    // ============================================
      push()
--    translate(this.x, this.y)
++
++    // ENHANCED: Tilt balloon based on wind
++    if (windActive) {
++      rotate(this.windSway * 0.01)  // Slight tilt in wind direction
++    }
--    if (this.type === 'balloon') {
++    // Balloon shadow
--      // ============================================
++    noStroke()
--      // HOT AIR BALLOON WITH CANVAS TEXTURE
++    fill(0, 0, 0, 30)
--      // ============================================
++    ellipse(5, 5, this.radius * 2.1)
++
++    // Main balloon with canvas panel texture
++    // Draw vertical panels like a real hot air balloon
++    let numPanels = 8
++    for (let i = 0; i < numPanels; i++) {
        push()
--      // Balloon shadow
++      // Rotate for each panel
--      noStroke()
++      rotate((TWO_PI / numPanels) * i)
--      fill(0, 0, 0, 30)
--      ellipse(5, 5, this.radius * 2.1)
--
--      // Main balloon with canvas panel texture
--      // Draw vertical panels like a real hot air balloon
--      let numPanels = 8
--      for (let i = 0; i < numPanels; i++) {
--        push()
--
--        // Rotate for each panel
--        rotate((TWO_PI / numPanels) * i)
--
--        // Alternate panel colors for classic hot air balloon look
--        if (i % 2 === 0) {
--          fill(
--            red(this.balloonColor),
--            green(this.balloonColor),
--            blue(this.balloonColor)
--          )
--        } else {
--          // Slightly darker alternate panels
--          fill(
--            red(this.balloonColor) * 0.9,
--            green(this.balloonColor) * 0.9,
--            blue(this.balloonColor) * 0.9
--          )
--        }
--        // Draw panel as pie slice
++      // Alternate panel colors for classic hot air balloon look
--        noStroke()
++      if (i % 2 === 0) {
--        arc(
++        fill(
--          0,
++          red(this.balloonColor),
--          0,
++          green(this.balloonColor),
--          this.radius * 2,
++          blue(this.balloonColor)
--          this.radius * 2,
++        )
--          -PI / numPanels,
++      } else {
--          PI / numPanels,
++        // Slightly darker alternate panels
--          PIE
++        fill(
++          red(this.balloonColor) * 0.9,
++          green(this.balloonColor) * 0.9,
++          blue(this.balloonColor) * 0.9
+         )
--
--        pop()
--      }
--
--      // Add panel seams (the ropes/stitching between panels)
--      stroke(60, 40, 20, 110)
--      strokeWeight(1)
--      for (let i = 0; i < numPanels; i++) {
--        let angle = (TWO_PI / numPanels) * i
--        let x1 = cos(angle) * this.radius * 0.2
--        let y1 = sin(angle) * this.radius * 0.2
--        let x2 = cos(angle) * this.radius * 0.95
--        let y2 = sin(angle) * this.radius * 0.95
--        line(x1, y1, x2, y2)
+       }
--      // Add circular reinforcement bands
++      // Draw panel as pie slice
--      noFill()
--      stroke(80, 50, 30, 80)
--      strokeWeight(1.5)
--      ellipse(0, 0, this.radius * 1.4)
--      ellipse(0, 0, this.radius * 0.8)
--
--      // Matte fabric shading (subtle, non-glossy)
--      noStroke()
--      // Soft radial shading toward top-left to imply ambient light without specular shine
--      for (
--        let r = this.radius * 1.2;
--        r > this.radius * 0.2;
--        r -= this.radius * 0.15
--      ) {
--        fill(255, 255, 255, 8) // very low alpha
--        ellipse(-this.radius * 0.25, -this.radius * 0.35, r * 0.25, r * 0.18)
--      }
--      // Global matte overlay to reduce plastic look
        noStroke()
--      fill(230, 210, 190, 18)
++      arc(
--      ellipse(0, 0, this.radius * 2, this.radius * 2)
++        0,
--
++        0,
--      // Bottom opening of balloon (where flame goes)
++        this.radius * 2,
--      fill(40, 20, 10)
++        this.radius * 2,
--      ellipse(0, this.radius * 0.9, this.radius * 0.4, this.radius * 0.15)
++        -PI / numPanels,
--
++        PI / numPanels,
--      // Support ropes from balloon to basket
++        PIE
--      stroke(80, 60, 40)
++      )
--      strokeWeight(2)
--      // Four support ropes
--      line(-this.radius * 0.3, this.radius * 0.85, -8, this.radius + 20)
--      line(this.radius * 0.3, this.radius * 0.85, 8, this.radius + 20)
--      line(-this.radius * 0.15, this.radius * 0.9, -4, this.radius + 20)
--      line(this.radius * 0.15, this.radius * 0.9, 4, this.radius + 20)
--      // FLAME EFFECT (between balloon and basket)
++      pop()
--      push()
++    }
--      translate(0, this.radius + 10)
--      // Flame glow
++    // Add panel seams (the ropes/stitching between panels)
--      noStroke()
++    stroke(60, 40, 20, 110)
--      fill(255, 200, 0, 30 + sin(frameCount * 0.2) * 20)
++    strokeWeight(1)
--      ellipse(0, 0, 30, 30)
++    for (let i = 0; i < numPanels; i++) {
--      fill(255, 150, 0, 50 + sin(frameCount * 0.3) * 30)
++      let angle = (TWO_PI / numPanels) * i
--      ellipse(0, 0, 20, 25)
++      let x1 = cos(angle) * this.radius * 0.2
++      let y1 = sin(angle) * this.radius * 0.2
++      let x2 = cos(angle) * this.radius * 0.95
++      let y2 = sin(angle) * this.radius * 0.95
++      line(x1, y1, x2, y2)
++    }
++
++    // Add circular reinforcement bands
++    noFill()
++    stroke(80, 50, 30, 80)
++    strokeWeight(1.5)
++    ellipse(0, 0, this.radius * 1.4)
++    ellipse(0, 0, this.radius * 0.8)
--      // Animated flame
++    // Matte fabric shading (subtle, non-glossy)
--      push()
++    noStroke()
--      let flameHeight = 12 + sin(frameCount * 0.4) * 4
++    // Soft radial shading toward top-left to imply ambient light without specular shine
--      let flameWave = sin(frameCount * 0.3) * 2
++    for (
++      let r = this.radius * 1.2;
++      r > this.radius * 0.2;
++      r -= this.radius * 0.15
++    ) {
++      fill(255, 255, 255, 8) // very low alpha
++      ellipse(-this.radius * 0.25, -this.radius * 0.35, r * 0.25, r * 0.18)
++    }
++    // Global matte overlay to reduce plastic look
++    noStroke()
++    fill(230, 210, 190, 18)
++    ellipse(0, 0, this.radius * 2, this.radius * 2)
++
++    // Bottom opening of balloon (where flame goes)
++    fill(40, 20, 10)
++    ellipse(0, this.radius * 0.9, this.radius * 0.4, this.radius * 0.15)
++
++    // Support ropes from balloon to basket
++    stroke(80, 60, 40)
++    strokeWeight(2)
++    // Four support ropes
++    line(-this.radius * 0.3, this.radius * 0.85, -8, this.radius + 20)
++    line(this.radius * 0.3, this.radius * 0.85, 8, this.radius + 20)
++    line(-this.radius * 0.15, this.radius * 0.9, -4, this.radius + 20)
++    line(this.radius * 0.15, this.radius * 0.9, 4, this.radius + 20)
++
++    // FLAME EFFECT (between balloon and basket)
++    push()
++    translate(0, this.radius + 10)
--      // Outer flame (orange)
++    // Flame glow
--      fill(255, 150, 0)
++    noStroke()
--      beginShape()
++    fill(255, 200, 0, 30 + sin(frameCount * 0.2) * 20)
--      vertex(-5, 5)
++    ellipse(0, 0, 30, 30)
--      bezierVertex(
++    fill(255, 150, 0, 50 + sin(frameCount * 0.3) * 30)
--        -5 + flameWave,
++    ellipse(0, 0, 20, 25)
--        -flameHeight * 0.5,
--        -2 + flameWave,
--        -flameHeight * 0.8,
--        flameWave,
--        -flameHeight
--      )
--      bezierVertex(
--        2 + flameWave,
--        -flameHeight * 0.8,
--        5 + flameWave,
--        -flameHeight * 0.5,
--        5,
--        5
--      )
--      endShape(CLOSE)
--      // Inner flame (yellow/white)
++    // Animated flame
--      fill(255, 255, 150)
++    push()
--      beginShape()
++    let flameHeight = 12 + sin(frameCount * 0.4) * 4
--      vertex(-2, 5)
++    let flameWave = sin(frameCount * 0.3) * 2
--      bezierVertex(
++
--        -2 + flameWave * 0.5,
++    // Outer flame (orange)
--        -flameHeight * 0.3,
++    fill(255, 150, 0)
--        -1 + flameWave * 0.5,
++    beginShape()
--        -flameHeight * 0.5,
++    vertex(-5, 5)
--        flameWave * 0.5,
++    bezierVertex(
--        -flameHeight * 0.7
++      -5 + flameWave,
--      )
++      -flameHeight * 0.5,
--      bezierVertex(
++      -2 + flameWave,
--        1 + flameWave * 0.5,
++      -flameHeight * 0.8,
--        -flameHeight * 0.5,
++      flameWave,
--        2 + flameWave * 0.5,
++      -flameHeight
--        -flameHeight * 0.3,
++    )
--        2,
++    bezierVertex(
--        5
++      2 + flameWave,
--      )
++      -flameHeight * 0.8,
--      endShape(CLOSE)
++      5 + flameWave,
++      -flameHeight * 0.5,
++      5,
++      5
++    )
++    endShape(CLOSE)
++
++    // Inner flame (yellow/white)
++    fill(255, 255, 150)
++    beginShape()
++    vertex(-2, 5)
++    bezierVertex(
++      -2 + flameWave * 0.5,
++      -flameHeight * 0.3,
++      -1 + flameWave * 0.5,
++      -flameHeight * 0.5,
++      flameWave * 0.5,
++      -flameHeight * 0.7
++    )
++    bezierVertex(
++      1 + flameWave * 0.5,
++      -flameHeight * 0.5,
++      2 + flameWave * 0.5,
++      -flameHeight * 0.3,
++      2,
++      5
++    )
++    endShape(CLOSE)
--      // Flame tip (bright white)
++    // Flame tip (bright white)
--      fill(255, 255, 255)
++    fill(255, 255, 255)
--      ellipse(flameWave * 0.5, -flameHeight * 0.5, 3, 5)
++    ellipse(flameWave * 0.5, -flameHeight * 0.5, 3, 5)
--      pop()
++    pop()
--      pop()
++    pop()
--      // BIGGER, MORE DETAILED BASKET
++    // BIGGER, MORE DETAILED BASKET WITH SWING
--      push()
++    push()
--      translate(0, this.radius + 25)
++    translate(0, this.radius + 25)
++
++    // ENHANCED: Apply basket swing
++    if (windActive) {
++      rotate(this.basketSwing * 0.02)
++    }
--      // Basket shadow
++    // Basket shadow
--      noStroke()
++    noStroke()
--      fill(0, 0, 0, 20)
++    fill(0, 0, 0, 20)
--      rect(-11, 2, 22, 15, 2)
++    rect(-11, 2, 22, 15, 2)
--      // Main basket - bigger to see ant better
++    // Main basket - bigger to see ant better
--      fill(101, 67, 33)
++    fill(101, 67, 33)
--      stroke(80, 50, 20)
++    stroke(80, 50, 20)
--      strokeWeight(1.5)
++    strokeWeight(1.5)
--      rect(-10, 0, 20, 14, 2) // Bigger basket
++    rect(-10, 0, 20, 14, 2) // Bigger basket
--      // Woven basket texture
++    // Woven basket texture
--      stroke(80, 50, 20, 150)
++    stroke(80, 50, 20, 150)
--      strokeWeight(1)
++    strokeWeight(1)
--      // Vertical weaves
++    // Vertical weaves
--      for (let i = -8; i < 8; i += 3) {
++    for (let i = -8; i < 8; i += 3) {
--        line(i, 1, i, 13)
++      line(i, 1, i, 13)
--      }
++    }
--      // Horizontal weaves
++    // Horizontal weaves
--      for (let i = 3; i < 12; i += 3) {
++    for (let i = 3; i < 12; i += 3) {
--        line(-9, i, 9, i)
++      line(-9, i, 9, i)
--      }
++    }
--      // Basket rim (thicker, more pronounced)
++    // Basket rim (thicker, more pronounced)
--      stroke(60, 40, 20)
++    stroke(60, 40, 20)
--      strokeWeight(2)
++    strokeWeight(2)
--      line(-10, 0, 10, 0)
++    line(-10, 0, 10, 0)
--      // Corner reinforcements
++    // Corner reinforcements
--      fill(80, 50, 20)
++    fill(80, 50, 20)
--      noStroke()
++    noStroke()
--      ellipse(-9, 0, 3)
++    ellipse(-9, 0, 3)
--      ellipse(9, 0, 3)
++    ellipse(9, 0, 3)
--      pop()
++    pop()
--      // DETAILED ANT PILOT (bigger, more visible)
++    // DETAILED ANT PILOT (bigger, more visible)
--      push()
++    push()
--      translate(0, this.radius + 28)
++    translate(0, this.radius + 28)
++
++    // ENHANCED: Ant holds on tighter in wind
++    if (windActive) {
++      rotate(-this.basketSwing * 0.01)  // Ant leans opposite to basket
++    }
--      // Ant body
++    // Ant body
--      fill(20)
++    fill(20)
--      noStroke()
++    noStroke()
--      ellipse(0, 0, 8, 5) // Thorax
++    ellipse(0, 0, 8, 5) // Thorax
--      ellipse(0, -3, 6, 5) // Head
++    ellipse(0, -3, 6, 5) // Head
--      ellipse(0, 3, 7, 6) // Abdomen
++    ellipse(0, 3, 7, 6) // Abdomen
--      // Ant eyes
++    // Ant eyes
--      fill(255, 100, 100)
++    fill(255, 100, 100)
--      ellipse(-2, -3, 2)
++    ellipse(-2, -3, 2)
--      ellipse(2, -3, 2)
++    ellipse(2, -3, 2)
--      // Antennae
++    // Antennae
--      stroke(20)
++    stroke(20)
--      strokeWeight(1)
++    strokeWeight(1)
--      line(-1, -5, -3, -8)
++    line(-1, -5, -3, -8)
--      line(1, -5, 3, -8)
++    line(1, -5, 3, -8)
--      // Little ant arms holding basket edge
++    // Little ant arms holding basket edge
--      strokeWeight(1.5)
++    strokeWeight(1.5)
--      line(-3, 0, -6, -3)
++    line(-3, 0, -6, -3)
--      line(3, 0, 6, -3)
++    line(3, 0, 6, -3)
--      // Ant legs visible over basket edge
++    // Ant legs visible over basket edge
--      line(-2, 2, -4, 5)
++    line(-2, 2, -4, 5)
--      line(2, 2, 4, 5)
++    line(2, 2, 4, 5)
--      // Optional: Tiny pilot goggles
++    // Optional: Tiny pilot goggles
--      stroke(100, 50, 0)
++    stroke(100, 50, 0)
--      strokeWeight(1)
++    strokeWeight(1)
--      noFill()
++    noFill()
--      ellipse(-2, -3, 3)
++    ellipse(-2, -3, 3)
--      ellipse(2, -3, 3)
++    ellipse(2, -3, 3)
--      line(-0.5, -3, 0.5, -3)
++    line(-0.5, -3, 0.5, -3)
--      pop()
++    pop()
--      // Sandbags hanging from basket (optional detail)
++    // Sandbags hanging from basket (optional detail)
--      push()
++    push()
--      translate(0, this.radius + 25)
++    translate(0, this.radius + 25)
--      fill(80, 60, 40)
++
--      noStroke()
++    // ENHANCED: Sandbags swing in wind
--      ellipse(-12, 10, 4, 5)
++    if (windActive) {
--      ellipse(12, 10, 4, 5)
++      rotate(this.basketSwing * 0.03)
--      // Sandbag ropes
++    }
--      stroke(60, 40, 20)
++
--      strokeWeight(0.5)
++    fill(80, 60, 40)
--      line(-10, 7, -12, 10)
++    noStroke()
--      line(10, 7, 12, 10)
++    ellipse(-12, 10, 4, 5)
--      pop()
++    ellipse(12, 10, 4, 5)
++    // Sandbag ropes
++    stroke(60, 40, 20)
++    strokeWeight(0.5)
++    line(-10, 7, -12, 10)
++    line(10, 7, 12, 10)
++    pop()
--      pop()
++    pop()
--    } else if (this.type === 'beetle') {
++  } else if (this.type === 'beetle') {
        push()
        rotate(this.rotation)

js/game.jsmodified

    // PHASE 4B: Apply wind to airborne entities
    if (windActive) {
--    // Push spider if airborne
++    // Push spider if airborne - MORE DRAMATIC
      if (spider.isAirborne) {
--      spider.vel.x += cos(windDirection) * windStrength * 0.1
++      spider.vel.x += cos(windDirection) * windStrength * 0.15 // Increased from 0.1
++      spider.vel.y += sin(frameCount * 0.05) * windStrength * 0.03 // Add vertical wobble
+     }
--    // Push flies
++    // Push flies - MORE VISIBLE
      for (let fly of flies) {
        if (!fly.stuck && !fly.caught) {
--        fly.vel.x += cos(windDirection) * windStrength * 0.05
++        fly.vel.x += cos(windDirection) * windStrength * 0.08 // Increased from 0.05
++        fly.vel.y += sin(frameCount * 0.1 + fly.wingPhase) * windStrength * 0.02 // Turbulence
+       }
+     }
--    // Make webs sway
++    // ENHANCED: Make webs sway and stretch
      for (let strand of webStrands) {
        if (!strand.broken) {
--        strand.vibrate(windStrength * 0.5)
++        // Stronger vibration
++        strand.vibrate(windStrength * 0.8) // Increased from 0.5
++
++        // Apply lateral force to web path points for realistic sway
++        if (strand.path && strand.path.length > 2) {
++          for (let i = 1; i < strand.path.length - 1; i++) {
++            let point = strand.path[i]
++            // Middle points sway more than ends
++            let swayFactor = sin((i / strand.path.length) * PI)
++            point.x += cos(windDirection) * windStrength * swayFactor * 0.3
++            // Add some vertical movement too
++            point.y +=
++              sin(frameCount * 0.08 + i * 0.1) *
++              windStrength *
++              swayFactor *
++              0.15
++          }
++        }
++
          // Check if strand is overstretched and should break
--        if (strand.tension > 1.2 && windStrength > 3) {
++        if (strand.tension > 1.0 && windStrength > 4) {
--          if (random() < 0.01) {
++          // Lowered from 1.2
--            // Small chance per frame
++          if (random() < (0.02 * windStrength) / 5) {
++            // Increased chance based on wind strength
              strand.broken = true
              notifications.push(
                new Notification('Wind snapped a web!', color(255, 150, 100))
+             )
++            // Add dramatic snap particles
++            for (let j = 0; j < 8; j++) {
++              let p = new Particle(
++                strand.path[Math.floor(strand.path.length / 2)].x,
++                strand.path[Math.floor(strand.path.length / 2)].y
++              )
++              p.vel = createVector(
++                cos(windDirection) * random(3, 6),
++                random(-2, 2)
++              )
++              p.color = color(255, 255, 255)
++              p.size = random(2, 5)
++              particles.push(p)
++            }
+           }
+         }
+       }
  function startWindGust () {
    windActive = true
    windDirection = random() < 0.5 ? 0 : PI // Left or right
--  windStrength = random(2, 5) // Variable strength
++  windStrength = random(3, 6)  // Increased from (2, 5)
    windDuration = random(300, 600) // 5-10 seconds
    windTimer = 0
    windParticles = []
--  // Notification
++  // More dramatic notification
    let direction = windDirection === 0 ? '→' : '←'
++  let intensity = windStrength > 4.5 ? 'Strong' : windStrength > 3.5 ? 'Moderate' : 'Light'
    notifications.push(
--    new Notification(`Wind gust ${direction}`, color(200, 200, 255))
++    new Notification(`${intensity} wind gust ${direction}`, color(200, 200, 255))
+   )
++
++  // Screen shake for strong winds
++  if (windStrength > 4.5) {
++    screenShake = 5
++  }
+ }
  function updateWind () {