maksarsanjeev
438 lines
17 KiB
Swift
438 lines
17 KiB
Swift
import Foundation
|
||
import CoreGraphics
|
||
|
||
// ============================================================
|
||
// CONSTANTS — exact mirror of upload-sequence.html
|
||
// All values in island-coordinate points (island = 640 × 176)
|
||
// ============================================================
|
||
|
||
enum USC {
|
||
static let W: Double = 640
|
||
static let ISL_H: Double = 176
|
||
static let CARD_X: Double = 10; static let CARD_Y: Double = 42
|
||
static let CARD_W: Double = 620; static let CARD_H: Double = 124; static let CARD_R: Double = 20
|
||
static let REST_X: Double = 140; static let REST_Y: Double = 104
|
||
static let D_BOX: Double = 62
|
||
static let FOLLOW_MIN: Double = 60 // CARD_X + 50
|
||
static let FOLLOW_MAX: Double = 580 // CARD_X + CARD_W - 50
|
||
static let TEXT_X: Double = 196; static let TEXT_Y: Double = 94
|
||
static let BAR_X0: Double = 46; static let BAR_X1: Double = 520; static let BAR_Y: Double = 118
|
||
static let CHOOSE_X: Double = 60; static let CHOOSE_Y: Double = 101; static let CHOOSE_D: Double = 62
|
||
static let LOCK_IN: Double = 60
|
||
static let LOCK_OUT: Double = 90
|
||
static let MOUTH_AJAR: Double = 0.20
|
||
static let MOUTH_OPEN: Double = 0.42
|
||
static let MOUTH_MAX: Double = 0.50
|
||
// Phase timestamps (t_ref, drop = 1.95)
|
||
static let T_DROP: Double = 1.95
|
||
static let T_SUCK_START: Double = 2.03
|
||
static let T_SUCK_END: Double = 2.33
|
||
static let T_CLOSE_END: Double = 2.42
|
||
static let T_CHEW1: Double = 2.60
|
||
static let T_CHEW_END: Double = 2.88
|
||
static let T_SHRINK_END: Double = 3.23
|
||
static let T_BAR_IN: Double = 3.00
|
||
static let T_PROG_START: Double = 3.25
|
||
static let DT: Double = 1.0 / 240.0
|
||
// Entry offset: gives 0.40 s of following before drop
|
||
static let ENTRY_T_REF: Double = T_DROP - 0.40 // = 1.55
|
||
}
|
||
|
||
// ============================================================
|
||
// EASING — port of reference E.out / E.in / E.inOut / E.back
|
||
// ============================================================
|
||
|
||
func usEOut(_ t: Double) -> Double { 1 - pow(1-t, 3) }
|
||
func usEIn(_ t: Double) -> Double { t*t*t }
|
||
func usEInOut(_ t: Double) -> Double { t < 0.5 ? 4*t*t*t : 1 - pow(-2*t+2,3)/2 }
|
||
func usEBack(_ t: Double) -> Double { let c1=1.70158,c3=c1+1; return 1+c3*pow(t-1,3)+c1*pow(t-1,2) }
|
||
|
||
func usSeg(_ t: Double, _ a: Double, _ b: Double) -> Double { max(0, min(1,(t-a)/(b-a))) }
|
||
func usLerp(_ a: Double, _ b: Double, _ t: Double) -> Double { a+(b-a)*t }
|
||
|
||
// Squeeze keyframes for suckEnd→chew1 phase (inline to avoid Swift @escaping issues)
|
||
func usSqueezeY(_ t: Double) -> Double {
|
||
let t0=USC.T_SUCK_END, t1=t0+0.07, t2=t0+0.20, t3=USC.T_CHEW1
|
||
if t<=t0 { return 1.06 }
|
||
if t<=t1 { return usLerp(1.06, 0.82, usEOut(usSeg(t,t0,t1))) }
|
||
if t<=t2 { return usLerp(0.82, 1.10, usEOut(usSeg(t,t1,t2))) }
|
||
if t<=t3 { return usLerp(1.10, 1.00, usEInOut(usSeg(t,t2,t3))) }
|
||
return 1.0
|
||
}
|
||
func usSqueezeX(_ t: Double) -> Double {
|
||
let t0=USC.T_SUCK_END, t1=t0+0.07, t2=t0+0.20, t3=USC.T_CHEW1
|
||
if t<=t0 { return 0.97 }
|
||
if t<=t1 { return usLerp(0.97, 1.14, usEOut(usSeg(t,t0,t1))) }
|
||
if t<=t2 { return usLerp(1.14, 0.95, usEOut(usSeg(t,t1,t2))) }
|
||
if t<=t3 { return usLerp(0.95, 1.00, usEInOut(usSeg(t,t2,t3))) }
|
||
return 1.0
|
||
}
|
||
|
||
func usProgressCurve(_ u: Double) -> Double {
|
||
if u < 0.40 { return 0.60 * usEOut(u/0.40) }
|
||
if u < 0.85 { return 0.60 + 0.32 * usEInOut((u-0.40)/0.45) }
|
||
return 0.92 + 0.08 * usEIn((u-0.85)/0.15)
|
||
}
|
||
func usProgressAt(_ t: Double, progStart: Double, progEnd: Double) -> Double {
|
||
t < progStart ? 0 : usProgressCurve(usSeg(t, progStart, progEnd))
|
||
}
|
||
|
||
// ============================================================
|
||
// SPRING — port of reference spring(s, target, response, damping, dt)
|
||
// ============================================================
|
||
|
||
struct USSpring {
|
||
var v: Double
|
||
var vel: Double = 0
|
||
mutating func step(target: Double, response: Double, damping: Double, dt: Double) {
|
||
let k = pow(2 * .pi / response, 2)
|
||
let c = 2 * damping * sqrt(k)
|
||
let a = k*(target-v) - c*vel
|
||
vel += a*dt; v += vel*dt
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// SIMULATION STATE — mirrors reference newSim()
|
||
// ============================================================
|
||
|
||
struct USSimState {
|
||
var t: Double = 0
|
||
var bx: USSpring = USSpring(v: USC.REST_X)
|
||
var by: USSpring = USSpring(v: USC.REST_Y)
|
||
var tilt: Double = 0
|
||
var mouth: USSpring = USSpring(v: 0)
|
||
var locked: Bool = false
|
||
var lockAt: Double = -9
|
||
var entered: Double = -9 // t_ref of zone entry; -9 = not entered
|
||
var gulp: Bool = false
|
||
var ok: Bool = false
|
||
var lastPct: Int = 0
|
||
}
|
||
|
||
// ============================================================
|
||
// FRAME DATA — output of frame(), read by UploadCanvasView
|
||
// ============================================================
|
||
|
||
enum USEyeShape { case pill, cup, content }
|
||
|
||
struct USMouthRect { var x,y,w,h: Double }
|
||
|
||
struct USFrame {
|
||
var t: Double = 0
|
||
var cursorX: Double = 600; var cursorY: Double = 280
|
||
var morph: Double = 0
|
||
var x: Double = USC.REST_X; var y: Double = USC.REST_Y; var d: Double = USC.D_BOX
|
||
var sx: Double = 1; var sy: Double = 1; var tilt: Double = 0; var hop: Double = 0
|
||
var mouth: Double = 0
|
||
var mouthRect = USMouthRect(x:0,y:0,w:0,h:0)
|
||
var eye: USEyeShape = .pill
|
||
var lookX: Double = 0; var lookY: Double = 0
|
||
var fileVisible: Bool = true; var suck: Double = 0
|
||
var zoneOver: Bool = false
|
||
var zoneAlpha: Double = 1
|
||
var textAlpha: Double = 1
|
||
var barReveal: Double = 0
|
||
var barAlpha: Double = 0
|
||
var progress: Double = 0
|
||
var flash: Double = 0
|
||
var check: Double = 0
|
||
var greenWash: Double = 0
|
||
var chooseAlpha: Double = 0
|
||
var uploadDuration: Double = 2.4
|
||
var progEnd: Double = USC.T_PROG_START + 2.4
|
||
var growStart: Double = USC.T_PROG_START + 2.4 + 0.25
|
||
var growEnd: Double = USC.T_PROG_START + 2.4 + 0.70
|
||
}
|
||
|
||
// ============================================================
|
||
// ENGINE
|
||
// ============================================================
|
||
|
||
@MainActor
|
||
final class UploadSequenceEngine {
|
||
static let shared = UploadSequenceEngine()
|
||
|
||
var uploadDuration: Double = 2.4
|
||
var progEnd: Double { USC.T_PROG_START + uploadDuration }
|
||
var growStart: Double { progEnd + 0.25 }
|
||
var growEnd: Double { progEnd + 0.70 }
|
||
|
||
private(set) var isActive: Bool = false
|
||
private var entryWallTime: Double = 0 // Date().timeIntervalSinceReferenceDate at entry
|
||
private var dropWallTime: Double? = nil
|
||
|
||
private var sim = USSimState()
|
||
|
||
// Real cursor in island coords
|
||
var cursorX: Double = 600
|
||
var cursorY: Double = 280
|
||
private var prevCursorX: Double = 600
|
||
private var prevCursorY: Double = 280
|
||
private var prevCursorTime: Double = 0
|
||
private var cursorSpeed: Double = 0
|
||
|
||
// MARK: - Session lifecycle
|
||
|
||
func enterZone(x: CGFloat, y: CGFloat) {
|
||
let now = Date().timeIntervalSinceReferenceDate
|
||
cursorX = Double(x); cursorY = Double(y)
|
||
prevCursorX = cursorX; prevCursorY = cursorY; prevCursorTime = now
|
||
cursorSpeed = 0
|
||
sim = USSimState()
|
||
sim.t = USC.ENTRY_T_REF
|
||
sim.entered = USC.ENTRY_T_REF
|
||
sim.bx = USSpring(v: USC.REST_X)
|
||
sim.by = USSpring(v: USC.REST_Y)
|
||
entryWallTime = now
|
||
dropWallTime = nil
|
||
isActive = true
|
||
}
|
||
|
||
func updateCursor(x: CGFloat, y: CGFloat) {
|
||
let now = Date().timeIntervalSinceReferenceDate
|
||
let dt = now - prevCursorTime
|
||
if dt > 0.001 {
|
||
let dx = Double(x) - prevCursorX, dy = Double(y) - prevCursorY
|
||
cursorSpeed = hypot(dx, dy) / dt
|
||
}
|
||
prevCursorX = Double(x); prevCursorY = Double(y); prevCursorTime = now
|
||
cursorX = Double(x); cursorY = Double(y)
|
||
}
|
||
|
||
func exitZone() {
|
||
// Keep engine active — island stays open per spec
|
||
}
|
||
|
||
func performDrop(uploadDuration ud: Double) {
|
||
uploadDuration = ud
|
||
let now = Date().timeIntervalSinceReferenceDate
|
||
dropWallTime = now
|
||
// Reset sim.t to T_DROP so the canonical post-drop timeline starts correctly,
|
||
// regardless of how long the user hovered. Spring state (position/velocity) is preserved.
|
||
sim.t = USC.T_DROP
|
||
}
|
||
|
||
func deactivate() {
|
||
isActive = false
|
||
dropWallTime = nil
|
||
}
|
||
|
||
// MARK: - t_ref from wall clock
|
||
|
||
func tRef(at date: Date) -> Double {
|
||
guard isActive else { return 0 }
|
||
let now = date.timeIntervalSinceReferenceDate
|
||
if let dw = dropWallTime {
|
||
return USC.T_DROP + max(0, now - dw)
|
||
}
|
||
// No cap — spring keeps stepping as long as user hovers.
|
||
// computeFrame clamps phase-sensitive outputs to pre-drop state.
|
||
let elapsed = max(0, now - entryWallTime)
|
||
return USC.ENTRY_T_REF + elapsed
|
||
}
|
||
|
||
// MARK: - Public entry point
|
||
|
||
func frame(at date: Date) -> USFrame {
|
||
guard isActive else { return USFrame() }
|
||
let t = tRef(at: date)
|
||
simulateTo(t)
|
||
return computeFrame(t: t)
|
||
}
|
||
|
||
// MARK: - Simulation
|
||
|
||
private func simulateTo(_ tTarget: Double) {
|
||
while sim.t < tTarget - 1e-10 {
|
||
let dt = min(USC.DT, tTarget - sim.t)
|
||
stepOnce(dt: dt)
|
||
sim.t += dt
|
||
}
|
||
}
|
||
|
||
private func stepOnce(dt: Double) {
|
||
let isDragging = (dropWallTime == nil)
|
||
|
||
// Horizontal follow + lock (only while dragging and in zone)
|
||
if isDragging && sim.entered >= 0 {
|
||
let dist = hypot(cursorX - sim.bx.v, (cursorY + 14) - sim.by.v)
|
||
if !sim.locked && dist < USC.LOCK_IN && cursorSpeed < 180 {
|
||
sim.locked = true; sim.lockAt = sim.t
|
||
}
|
||
if sim.locked && dist > USC.LOCK_OUT { sim.locked = false }
|
||
let tx = max(USC.FOLLOW_MIN, min(USC.FOLLOW_MAX, cursorX))
|
||
if sim.locked {
|
||
sim.bx.step(target: tx, response:0.18, damping:0.75, dt:dt)
|
||
sim.by.step(target: USC.REST_Y, response:0.18, damping:0.75, dt:dt)
|
||
} else {
|
||
sim.bx.step(target: tx, response:0.35, damping:0.70, dt:dt)
|
||
sim.by.step(target: USC.REST_Y, response:0.35, damping:0.70, dt:dt)
|
||
}
|
||
}
|
||
|
||
// Tilt
|
||
let tiltTarget = isDragging ? max(-0.18, min(0.18, sim.bx.vel * 0.0015)) : 0.0
|
||
sim.tilt = usLerp(sim.tilt, tiltTarget, 1 - pow(0.0005, dt))
|
||
|
||
// Mouth — post-drop close only after drop has actually happened
|
||
let t = sim.t
|
||
if !isDragging && t >= USC.T_SUCK_END {
|
||
sim.mouth.v = max(0, usLerp(USC.MOUTH_MAX, 0, usEIn(usSeg(t, USC.T_SUCK_END, USC.T_CLOSE_END))))
|
||
} else {
|
||
var mt = 0.0
|
||
if sim.entered >= 0 {
|
||
mt = (sim.locked || !isDragging) ? USC.MOUTH_OPEN : USC.MOUTH_AJAR
|
||
}
|
||
if !isDragging && t < USC.T_SUCK_END { mt = USC.MOUTH_MAX }
|
||
sim.mouth.step(target: mt, response:0.25, damping:0.60, dt:dt)
|
||
if sim.mouth.v < 0 { sim.mouth.v = 0 }
|
||
}
|
||
}
|
||
|
||
// MARK: - Frame computation (mirrors reference frame(t))
|
||
|
||
private func computeFrame(t: Double) -> USFrame {
|
||
var f = USFrame()
|
||
f.t = t
|
||
f.cursorX = cursorX; f.cursorY = cursorY
|
||
f.uploadDuration = uploadDuration
|
||
f.progEnd = progEnd
|
||
f.growStart = growStart
|
||
f.growEnd = growEnd
|
||
|
||
let entered = sim.entered >= 0 ? sim.entered : 1e9
|
||
let isDragging = (dropWallTime == nil)
|
||
// For all phase-based calculations, clamp t to just before T_DROP while pre-drop
|
||
// so long hovers don't accidentally trigger post-drop visuals.
|
||
let pt = isDragging ? min(t, USC.T_DROP - USC.DT) : t
|
||
|
||
// Morph: 0→1 (entry), 1→0 (shrink to ball), 0→1 (grow back to box at choose)
|
||
var morph: Double
|
||
if pt < USC.T_CHEW_END {
|
||
morph = usEBack(usSeg(pt, entered, entered + 0.38))
|
||
} else if pt < growStart {
|
||
morph = 1 - usEOut(usSeg(pt, USC.T_CHEW_END, USC.T_SHRINK_END))
|
||
} else {
|
||
morph = usEBack(usSeg(pt, growStart, growEnd))
|
||
}
|
||
morph = max(0, min(morph, 1.08))
|
||
f.morph = morph
|
||
|
||
// Position / diameter
|
||
var x = sim.bx.v, y = sim.by.v, d = USC.D_BOX
|
||
if pt >= USC.T_CHEW_END && pt < USC.T_PROG_START {
|
||
let k = usEInOut(usSeg(pt, USC.T_CHEW_END, USC.T_SHRINK_END))
|
||
x = usLerp(sim.bx.v, USC.BAR_X0, k)
|
||
y = usLerp(sim.by.v, USC.BAR_Y, k)
|
||
d = usLerp(USC.D_BOX, 14, k)
|
||
}
|
||
if pt >= USC.T_PROG_START {
|
||
let p = usProgressAt(pt, progStart: USC.T_PROG_START, progEnd: progEnd)
|
||
x = usLerp(USC.BAR_X0, USC.BAR_X1, p); y = USC.BAR_Y; d = 14
|
||
}
|
||
if pt >= progEnd {
|
||
x = USC.BAR_X1
|
||
y = USC.BAR_Y - 8 * sin(.pi * usSeg(pt, progEnd, progEnd + 0.20))
|
||
}
|
||
if pt >= growStart {
|
||
x = usLerp(USC.BAR_X1, USC.CHOOSE_X, usEInOut(usSeg(pt, growStart, growEnd)))
|
||
y = usLerp(USC.BAR_Y, USC.CHOOSE_Y, usEInOut(usSeg(pt, growStart, growEnd)))
|
||
d = usLerp(14, USC.CHOOSE_D, usEBack(usSeg(pt, growStart, growEnd)))
|
||
}
|
||
f.x = x; f.y = y; f.d = d
|
||
|
||
// Squeeze
|
||
var sx = 1.0, sy = 1.0
|
||
if pt >= USC.T_DROP && pt < USC.T_SUCK_START {
|
||
let k = usEOut(usSeg(pt, USC.T_DROP, USC.T_SUCK_START))
|
||
sy = usLerp(1, 0.92, k); sx = usLerp(1, 1.06, k)
|
||
}
|
||
if pt >= USC.T_SUCK_START && pt < USC.T_SUCK_END {
|
||
let k = usEInOut(usSeg(pt, USC.T_SUCK_START, USC.T_SUCK_END))
|
||
sy = usLerp(0.92, 1.06, k); sx = usLerp(1.06, 0.97, k)
|
||
}
|
||
if pt >= USC.T_SUCK_END && pt < USC.T_CHEW1 {
|
||
sy = usSqueezeY(pt); sx = usSqueezeX(pt)
|
||
}
|
||
if pt >= USC.T_CHEW1 && pt < USC.T_CHEW_END {
|
||
let k = ((pt-USC.T_CHEW1).truncatingRemainder(dividingBy: 0.14)) / 0.14
|
||
sy = 1 - 0.05*sin(.pi*k); sx = 1 + 0.03*sin(.pi*k)
|
||
}
|
||
if pt >= USC.T_CHEW_END && pt < USC.T_SHRINK_END {
|
||
let k = usSeg(pt, USC.T_CHEW_END, USC.T_SHRINK_END)
|
||
sy = 1 + 0.12*sin(.pi*k); sx = 1 - 0.06*sin(.pi*k)
|
||
}
|
||
if pt >= USC.T_PROG_START && pt < progEnd {
|
||
let v = (usProgressAt(pt+0.01, progStart: USC.T_PROG_START, progEnd: progEnd)
|
||
- usProgressAt(pt, progStart: USC.T_PROG_START, progEnd: progEnd)) / 0.01
|
||
let st = max(0, min(1, v*0.18))
|
||
sx = 1 + 0.25*st; sy = 1 - 0.15*st
|
||
}
|
||
if pt >= growStart && pt < growEnd {
|
||
sy = 1 + 0.06*sin(.pi * usSeg(pt, growStart, growEnd))
|
||
}
|
||
f.sx = sx; f.sy = sy; f.tilt = sim.tilt
|
||
f.hop = (sim.lockAt > 0 && isDragging)
|
||
? -5 * sin(.pi * usSeg(pt, sim.lockAt, sim.lockAt + 0.15)) : 0
|
||
|
||
f.mouth = sim.mouth.v
|
||
|
||
// Eyes
|
||
var eye: USEyeShape = .pill
|
||
if sim.locked && pt < USC.T_SUCK_END { eye = .cup }
|
||
if pt >= USC.T_SUCK_END && pt < USC.T_CHEW_END + 0.10 { eye = .content }
|
||
if pt >= progEnd && pt < growEnd + 0.30 { eye = .content }
|
||
f.eye = eye
|
||
|
||
let lkx = pt < USC.T_SUCK_END ? cursorX - x : (pt < USC.T_PROG_START ? 0.0 : 40.0)
|
||
let lky = pt < USC.T_SUCK_END ? (cursorY+10) - y : 0.0
|
||
f.lookX = max(-1, min(1, lkx/200)); f.lookY = max(-1, min(1, lky/150))
|
||
|
||
f.fileVisible = pt < USC.T_SUCK_END
|
||
f.suck = usSeg(pt, USC.T_SUCK_START, USC.T_SUCK_END)
|
||
|
||
// Content alpha values
|
||
f.zoneOver = sim.entered >= 0 && pt < USC.T_CHEW_END
|
||
f.zoneAlpha = 1 - usSeg(pt, USC.T_CHEW_END, USC.T_CHEW_END + 0.20)
|
||
f.textAlpha = f.zoneAlpha * ((x > USC.TEXT_X-40 && isDragging) ? 0.25 : 1.0)
|
||
f.barReveal = usEOut(usSeg(pt, USC.T_BAR_IN, USC.T_BAR_IN+0.25))
|
||
* (1 - usSeg(pt, growStart, growStart+0.20))
|
||
f.barAlpha = usSeg(pt, USC.T_BAR_IN+0.05, USC.T_BAR_IN+0.25)
|
||
* (1 - usSeg(pt, growStart, growStart+0.20))
|
||
f.progress = usProgressAt(pt, progStart: USC.T_PROG_START, progEnd: progEnd)
|
||
f.flash = pt >= progEnd ? sin(.pi * usSeg(pt, progEnd, progEnd+0.30)) : 0
|
||
f.check = pt >= progEnd ? usEBack(usSeg(pt, progEnd, progEnd+0.25)) : 0
|
||
let hoverGreen = f.zoneOver ? 0.22 : 0.0
|
||
var uploadGreen = 0.0
|
||
if pt >= USC.T_PROG_START {
|
||
// Grows gradually from 0→0.50 as upload progresses (tied to f.progress)
|
||
let baseGreen = f.progress * 0.50
|
||
// Brief flash burst at completion
|
||
let flashExtra = pt >= progEnd ? 0.20 * sin(.pi * usSeg(pt, progEnd, progEnd + 0.40)) : 0
|
||
// Fade out as Mochi grows back to choose position
|
||
let fadeOut = 1.0 - usSeg(pt, growEnd, growEnd + 0.60)
|
||
uploadGreen = (baseGreen + flashExtra) * fadeOut
|
||
}
|
||
f.greenWash = max(hoverGreen, uploadGreen)
|
||
f.chooseAlpha = usSeg(pt, growStart+0.15, growEnd)
|
||
|
||
// Mouth rect in island coords (used by drawFile for clipping)
|
||
let R = d / 2 / 1.04
|
||
let mc = max(0, min(morph, 1.0))
|
||
let rx = R * (1.04 - 0.04*mc)
|
||
let ry = R * (0.97 - 0.03*mc)
|
||
let mh = f.mouth * R * mc
|
||
let mw = 2*rx - 0.24*R
|
||
let mxOff = -mw/2
|
||
let myOff = -ry + 0.10*R
|
||
f.mouthRect = USMouthRect(
|
||
x: x + mxOff * sx,
|
||
y: y + f.hop + myOff * sy,
|
||
w: mw * sx,
|
||
h: mh * sy
|
||
)
|
||
return f
|
||
}
|
||
}
|