@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-MIPO6F72.js

@@ -0,0 +1,334 @@
+'use strict';
+
+var chunkATCURNUV_js = require('./chunk-ATCURNUV.js');
+var chunkA2MAX6S4_js = require('./chunk-A2MAX6S4.js');
+var chunk5325XSCH_js = require('./chunk-5325XSCH.js');
+var chunkKPA6K5IB_js = require('./chunk-KPA6K5IB.js');
+var chunkH5DFSCJ6_js = require('./chunk-H5DFSCJ6.js');
+var chunkY4K22JL6_js = require('./chunk-Y4K22JL6.js');
+var chunkG3EEC44R_js = require('./chunk-G3EEC44R.js');
+var chunkRCQ2MPBV_js = require('./chunk-RCQ2MPBV.js');
+var chunkMRFUNRAP_js = require('./chunk-MRFUNRAP.js');
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
+
+// src/game/kit/templates/shootout.ts
+var shootout_exports = {};
+chunkJGBCIKJV_js.__export(shootout_exports, {
+  PenaltyShootout: () => PenaltyShootout,
+  SHOOTOUT: () => SHOOTOUT,
+  buyClassicBall: () => buyClassicBall,
+  classicBall: () => classicBall,
+  goalTokens: () => goalTokens,
+  goldBoots: () => goldBoots,
+  goldBootsOffer: () => goldBootsOffer,
+  kente: () => kente,
+  kitDraw: () => kitDraw,
+  nightPitch: () => nightPitch,
+  penaltyShootoutTemplate: () => penaltyShootoutTemplate,
+  shootoutEconomy: () => shootoutEconomy,
+  starPack: () => starPack,
+  stars: () => stars,
+  tokens: () => tokens
+});
+
+// src/game/samples/penalty-kick.ts
+var PITCH = {
+  ballRadius: 0.11,
+  ballDensity: 77,
+  spotZ: 0,
+  goalLineZ: -11,
+  goalHalfWidth: 3.66,
+  goalHeight: 2.44,
+  postHalfThickness: 0.06,
+  netDepth: 1.6,
+  keeperHalfWidth: 0.35,
+  keeperHalfHeight: 0.95,
+  keeperHalfDepth: 0.2,
+  keeperDiveSpeed: 4.2,
+  keeperReactionSeconds: 0.18,
+  groundHalfExtent: 40
+}, SHOT = {
+  swipeSpeedToMetres: 14,
+  minSpeed: 8,
+  maxSpeed: 32,
+  lateralGain: 1.1,
+  loftPerSpeed: 0.22,
+  maxLoft: 7,
+  curlSpin: 28,
+  magnus: 45e-4,
+  settleSeconds: 3.5,
+  resetSeconds: 1.2
+}, BALL_ANGULAR_DAMPING = 0.4, KEEPER_LEFT = 0, KEEPER_RIGHT = 2, MS_PER_SECOND = 1e3, KEY_SHOT_SWIPE = -0.35, KEY_SHOT_DURATION_MS = 180, PITCH_COLOR = 3116870, BALL_COLOR = 16119285, POST_COLOR = 16777215, KEEPER_COLOR = 16756736, CAMERA_HEIGHT = 1.6, CAMERA_BACK = 4.5, CAMERA_FOV = 55, SUN_INTENSITY = 2.2, AMBIENT_INTENSITY = 0.6, SUN_PITCH = -0.9, PenaltyKick = class {
+  constructor(options = {}) {
+    this.name = "penalty-kick";
+    this.state = "ready";
+    this.goals = 0;
+    this.shots = 0;
+    this.ball = chunkMRFUNRAP_js.NO_ENTITY;
+    this.keeper = chunkMRFUNRAP_js.NO_ENTITY;
+    this.camera = chunkMRFUNRAP_js.NO_ENTITY;
+    this.goalSensor = chunkMRFUNRAP_js.NO_ENTITY;
+    this.kick = null;
+    this.stateSeconds = 0;
+    this.keeperTarget = 0;
+    this.keeperDelay = 0;
+    this.goalsSlot = null;
+    this.shotsSlot = null;
+    this.keeperController = -1;
+    this.keeperCollider = -1;
+    this.velocity = new chunkRCQ2MPBV_js.Vec3();
+    this.spin = new chunkRCQ2MPBV_js.Vec3();
+    this.force = new chunkRCQ2MPBV_js.Vec3();
+    this.position = new chunkRCQ2MPBV_js.Vec3();
+    this.desired = new chunkRCQ2MPBV_js.Vec3();
+    this.orientation = new chunkRCQ2MPBV_js.Quat();
+    this.move = new chunkG3EEC44R_js.CharacterMove();
+    this.keeperAt = new chunkRCQ2MPBV_js.Vec3();
+    this.lastBall = new chunkRCQ2MPBV_js.Vec3();
+    this.contactEvents = options.contactEvents ?? true;
+  }
+  enter(game) {
+    let gfx = game.graphics, solid = (color) => gfx.createMaterial({ kind: "standard", color, roughness: 0.8 }), box = gfx.createGeometry(chunkY4K22JL6_js.boxGeometry(1, 1, 1)), sphere = gfx.createGeometry(chunkY4K22JL6_js.sphereGeometry(PITCH.ballRadius)), ground = this.block(game, 0, -0.5, 0, PITCH.groundHalfExtent, 0.5, PITCH.groundHalfExtent);
+    gfx.mesh(ground, box, solid((3116870))), game.transforms.setScale(ground, PITCH.groundHalfExtent * 2, 1, PITCH.groundHalfExtent * 2);
+    let postMaterial = solid((16777215)), t = PITCH.postHalfThickness, h = PITCH.goalHeight / 2;
+    for (let side of [-1, 1]) {
+      let post = this.block(game, side * (PITCH.goalHalfWidth + t), h, PITCH.goalLineZ, t, h, t);
+      gfx.mesh(post, box, postMaterial), game.transforms.setScale(post, t * 2, PITCH.goalHeight, t * 2);
+    }
+    let bar = this.block(game, 0, PITCH.goalHeight + t, PITCH.goalLineZ, PITCH.goalHalfWidth + 2 * t, t, t);
+    gfx.mesh(bar, box, postMaterial), game.transforms.setScale(bar, (PITCH.goalHalfWidth + 2 * t) * 2, t * 2, t * 2), this.block(game, 0, h, PITCH.goalLineZ - PITCH.netDepth, PITCH.goalHalfWidth + 1, h + 1, t), this.contactEvents && (this.goalSensor = game.world.spawn(), game.transforms.add(this.goalSensor, 0, h, PITCH.goalLineZ - PITCH.netDepth / 2 - PITCH.ballRadius), game.physics.addCollider(this.goalSensor, {
+      shape: { kind: "cuboid", halfExtents: [PITCH.goalHalfWidth, h, PITCH.netDepth / 2 - t] },
+      sensor: true
+    })), this.keeper = game.world.spawn(), game.transforms.add(this.keeper, 0, PITCH.keeperHalfHeight, PITCH.goalLineZ + 0.5), game.physics.addBody(this.keeper, { kind: "kinematic" }), this.keeperCollider = game.physics.addCollider(this.keeper, {
+      shape: { kind: "cuboid", halfExtents: [PITCH.keeperHalfWidth, PITCH.keeperHalfHeight, PITCH.keeperHalfDepth] },
+      events: this.contactEvents
+    }), this.keeperController = game.physics.createCharacterController({ offset: 0.01, snapToGround: 0.1 }), gfx.mesh(this.keeper, box, solid((16756736))), game.transforms.setScale(this.keeper, PITCH.keeperHalfWidth * 2, PITCH.keeperHalfHeight * 2, PITCH.keeperHalfDepth * 2), this.ball = game.world.spawn(), game.transforms.add(this.ball, 0, PITCH.ballRadius, PITCH.spotZ), game.physics.addBody(this.ball, { kind: "dynamic", ccd: true, linearDamping: 0.05, angularDamping: (0.4) }), game.physics.addCollider(this.ball, {
+      shape: { kind: "ball", radius: PITCH.ballRadius },
+      density: PITCH.ballDensity,
+      restitution: 0.55,
+      friction: 0.7,
+      events: this.contactEvents
+    }), gfx.mesh(this.ball, sphere, solid((16119285))), this.camera = game.world.spawn(), game.transforms.add(this.camera, 0, (1.6), PITCH.spotZ + (4.5)), gfx.camera(this.camera, (55)), game.audio.setListener(this.camera);
+    let sun = game.world.spawn();
+    game.transforms.add(sun, 4, 10, 6), game.transforms.setRotationQuat(sun, this.orientation.setEuler((-0.9), 0.4, 0)), gfx.create(sun, { kind: "light", light: "directional", intensity: (2.2), castShadow: true });
+    let sky = game.world.spawn();
+    game.transforms.add(sky), gfx.create(sky, { kind: "light", light: "hemisphere", intensity: (0.6), groundColor: (3116870) }), this.kick = game.input.defineButton("kick", [{ device: "key", code: "Space" }]), this.goalsSlot = game.ui.hudNumber("goals"), this.shotsSlot = game.ui.hudNumber("shots"), game.ui.defineAction("restart");
+  }
+  fixedUpdate(game) {
+    switch (this.stateSeconds += game.time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT], this.state) {
+      case "ready": {
+        let swipe = game.input.swipe;
+        swipe.ready ? this.shoot(game, swipe.deltaX, swipe.deltaY, swipe.durationMs, swipe.curl) : this.kick !== null && game.input.justPressed(this.kick) && this.shoot(game, 0, (-0.35), (180), 0);
+        break;
+      }
+      case "flight":
+        this.applyMagnus(game), this.driveKeeper(game), this.judge(game);
+        break;
+      default:
+        this.stateSeconds >= SHOT.resetSeconds && this.reset(game);
+        break;
+    }
+  }
+  shoot(game, deltaX, deltaY, durationMs, curl) {
+    if (deltaY >= 0) return;
+    let seconds = Math.max(durationMs, 1) / (1e3), swipeSpeed = Math.hypot(deltaX, deltaY) / seconds, speed = clamp(swipeSpeed * SHOT.swipeSpeedToMetres, SHOT.minSpeed, SHOT.maxSpeed), lateral = deltaX / -deltaY * SHOT.lateralGain, loft = Math.min(speed * SHOT.loftPerSpeed, SHOT.maxLoft);
+    game.physics.setLinearVelocity(this.ball, this.velocity.set(lateral * speed, loft, -speed)), game.physics.setAngularVelocity(this.ball, this.spin.set(0, -curl * SHOT.curlSpin, 0)), game.transforms.position(this.ball, this.lastBall), this.keeperTarget = (game.random.int((0), (2)) - 1) * (PITCH.goalHalfWidth - PITCH.keeperHalfWidth), this.keeperDelay = PITCH.keeperReactionSeconds, this.shots++, this.shotsSlot !== null && game.ui.setNumber(this.shotsSlot, this.shots), this.enterState("flight");
+  }
+  applyMagnus(game) {
+    let dt = game.time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT];
+    game.transforms.position(this.ball, this.position), this.velocity.copy(this.position).sub(this.lastBall).scale(1 / dt), this.lastBall.copy(this.position), this.spin.scale(1 - (0.4) * dt), this.force.cross(this.spin, this.velocity).scale(SHOT.magnus * dt), game.physics.applyImpulse(this.ball, this.force);
+  }
+  driveKeeper(game) {
+    let dt = game.time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT];
+    if (this.keeperDelay > 0) {
+      this.keeperDelay -= dt;
+      return;
+    }
+    game.transforms.position(this.keeper, this.position);
+    let reach = PITCH.keeperDiveSpeed * dt;
+    this.desired.set(clamp(this.keeperTarget - this.position.x, -reach, reach), 0, 0), game.physics.moveCharacter(this.keeperController, this.keeperCollider, this.desired, this.move);
+  }
+  judge(game) {
+    this.contactEvents ? this.judgeContacts(game) : this.judgeGeometry(game), this.state === "flight" && (game.transforms.position(this.ball, this.position), (this.stateSeconds >= SHOT.settleSeconds || this.position.z < PITCH.goalLineZ - PITCH.netDepth * 2) && this.enterState("missed"));
+  }
+  judgeContacts(game) {
+    let physics = game.physics;
+    for (let i = 0; i < physics.contactCount(); i++) {
+      if (!physics.contactStarted(i)) continue;
+      let a = physics.contactEntityA(i), b = physics.contactEntityB(i);
+      if (a === this.ball || b === this.ball) {
+        if (a === this.goalSensor || b === this.goalSensor) {
+          this.scoreGoal(game);
+          return;
+        }
+        if (a === this.keeper || b === this.keeper) {
+          this.saveShot(game);
+          return;
+        }
+      }
+    }
+  }
+  judgeGeometry(game) {
+    let ball = game.transforms.position(this.ball, this.position), keeper = game.transforms.position(this.keeper, this.keeperAt), r = PITCH.ballRadius;
+    if (Math.abs(ball.x - keeper.x) < PITCH.keeperHalfWidth + r && Math.abs(ball.y - keeper.y) < PITCH.keeperHalfHeight + r && Math.abs(ball.z - keeper.z) < PITCH.keeperHalfDepth + r) {
+      this.saveShot(game);
+      return;
+    }
+    ball.z < PITCH.goalLineZ - r && Math.abs(ball.x) < PITCH.goalHalfWidth && ball.y < PITCH.goalHeight && this.scoreGoal(game);
+  }
+  scoreGoal(game) {
+    this.goals++, this.goalsSlot !== null && game.ui.setNumber(this.goalsSlot, this.goals), game.ui.haptic("success"), this.enterState("goal");
+  }
+  saveShot(game) {
+    game.ui.haptic("heavy"), this.enterState("saved");
+  }
+  reset(game) {
+    game.physics.teleport(this.ball, this.desired.set(0, PITCH.ballRadius, PITCH.spotZ)), game.transforms.position(this.keeper, this.position), game.physics.moveCharacter(this.keeperController, this.keeperCollider, this.desired.set(-this.position.x, 0, 0), this.move), this.enterState("ready");
+  }
+  enterState(state) {
+    this.state = state, this.stateSeconds = 0;
+  }
+  block(game, x, y, z, hx, hy, hz) {
+    let entity = game.world.spawn();
+    return game.transforms.add(entity, x, y, z), game.physics.addCollider(entity, { shape: { kind: "cuboid", halfExtents: [hx, hy, hz] }, friction: 0.8, restitution: 0.3 }), entity;
+  }
+};
+function clamp(value, min, max) {
+  return value < min ? min : value > max ? max : value;
+}
+
+// src/game/kit/templates/shootout.ts
+var SHOOTOUT = {
+  kicksPerSeries: 5,
+  seriesPauseSeconds: 1.5,
+  goalTrauma: 0.45,
+  saveTrauma: 0.3,
+  goalStopSeconds: 0.09,
+  goalFlashSeconds: 0.25,
+  goalFlash: 16777215
+}, tokens = chunkA2MAX6S4_js.softCurrency("tokens", "Tokens"), stars = chunkA2MAX6S4_js.premiumCurrency("stars", "Stars"), classicBall = chunkA2MAX6S4_js.softItem("classic-ball", "Classic ball", { stackable: false }), goldBoots = chunkA2MAX6S4_js.premiumItem("gold-boots", "Gold boots", { stackable: false }), kente = chunkA2MAX6S4_js.premiumItem("kente-kit", "Kente kit", { stackable: false }), nightPitch = chunkA2MAX6S4_js.premiumItem("night-pitch", "Night pitch", { stackable: false }), goalTokens = chunkA2MAX6S4_js.faucet("goal-tokens", tokens, 50), buyClassicBall = chunkA2MAX6S4_js.softExchange("buy-classic-ball", [chunkA2MAX6S4_js.grant(tokens, 200)], [chunkA2MAX6S4_js.grant(classicBall, 1)]), kitDraw = chunkA2MAX6S4_js.randomExchange(
+  "kit-draw",
+  "Kit draw",
+  chunkA2MAX6S4_js.grant(stars, 30),
+  chunkA2MAX6S4_js.discloseOdds([
+    { value: kente, quantity: 1, partsPerMillion: 6e5 },
+    { value: nightPitch, quantity: 1, partsPerMillion: 3e5 },
+    { value: goldBoots, quantity: 1, partsPerMillion: 1e5 }
+  ])
+), starPack = chunkA2MAX6S4_js.fixedOffer("star-pack", "Star pack", 25, [chunkA2MAX6S4_js.grant(stars, 60)]), goldBootsOffer = chunkA2MAX6S4_js.fixedOffer("gold-boots-offer", "Gold boots", 40, [chunkA2MAX6S4_js.grant(goldBoots, 1)]), shootoutEconomy = {
+  currencies: [tokens, stars],
+  items: [classicBall, goldBoots, kente, nightPitch],
+  faucets: [goalTokens],
+  exchanges: [buyClassicBall],
+  offers: [starPack, goldBootsOffer],
+  randomExchanges: [kitDraw]
+}, AXES = 3, PenaltyShootout = class {
+  constructor(results = null, rules = SHOOTOUT) {
+    this.rules = rules;
+    this.name = "penalty-shootout";
+    this.kick = new PenaltyKick({ contactEvents: false });
+    this.shake = new chunk5325XSCH_js.ScreenShake({ maxOffset: 0.18, maxRoll: 0.03 });
+    this.hitStop = new chunk5325XSCH_js.HitStop();
+    this.flash = new chunkKPA6K5IB_js.ScreenFlash();
+    this.phase = "playing";
+    this.series = 0;
+    this.seriesGoals = 0;
+    this.seriesKicks = 0;
+    this.totalGoals = 0;
+    this.bestSeries = 0;
+    this.cameraBase = new Float64Array((3));
+    this.cameraPose = new Float64Array((3));
+    this.previous = "ready";
+    this.pauseSeconds = 0;
+    this.kicksSlot = null;
+    this.bestSlot = null;
+    this.results = results;
+  }
+  get camera() {
+    return this.kick.camera;
+  }
+  enter(game) {
+    this.kick.enter(game);
+    let p = game.transforms.store.fields.position, row = game.transforms.row(this.kick.camera) * (3);
+    for (let i = 0; i < (3); i++) this.cameraBase[i] = p[row + i];
+    this.kicksSlot = game.ui.hudNumber("kicks left", this.rules.kicksPerSeries), this.bestSlot = game.ui.hudNumber("best series");
+  }
+  fixedUpdate(game) {
+    if (this.phase === "finished") {
+      this.pauseSeconds -= game.loop.time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT], this.pauseSeconds <= 0 && this.startSeries(game);
+      return;
+    }
+    this.kick.fixedUpdate(game);
+    let state = this.kick.state;
+    if (state === this.previous) return;
+    let was = this.previous;
+    this.previous = state, was === "flight" && (this.seriesKicks++, state === "goal" ? (this.seriesGoals++, this.totalGoals++, this.shake.add(SHOOTOUT.goalTrauma), this.hitStop.trigger(SHOOTOUT.goalStopSeconds), this.flash.trigger(this.rules.goalFlash, SHOOTOUT.goalFlashSeconds)) : state === "saved" && this.shake.add(SHOOTOUT.saveTrauma), this.kicksSlot !== null && game.ui.setNumber(this.kicksSlot, this.rules.kicksPerSeries - this.seriesKicks), this.seriesKicks >= this.rules.kicksPerSeries && this.finishSeries(game));
+  }
+  update(game) {
+    let time = game.time;
+    this.hitStop.drive(game.loop), this.shake.update(time), this.flash.update(time);
+    let o = this.shake.offset, pose = this.cameraPose;
+    for (let i = 0; i < (3); i++) pose[i] = this.cameraBase[i] + o[i];
+    chunkATCURNUV_js.writePosition(game.transforms, this.kick.camera, pose, 0);
+  }
+  finishSeries(game) {
+    this.phase = "finished", this.pauseSeconds = this.rules.seriesPauseSeconds, this.series++, this.seriesGoals > this.bestSeries && (this.bestSeries = this.seriesGoals), this.bestSlot !== null && game.ui.setNumber(this.bestSlot, this.bestSeries), game.ui.haptic(this.seriesGoals >= this.rules.kicksPerSeries ? "success" : "medium"), this.results?.seriesEnded(this.seriesGoals, this.seriesKicks);
+  }
+  startSeries(game) {
+    this.phase = "playing", this.seriesGoals = 0, this.seriesKicks = 0, this.kicksSlot !== null && game.ui.setNumber(this.kicksSlot, this.rules.kicksPerSeries);
+  }
+}, AIMS_X = new Float64Array([0.62, 0.38, 0.6, 0.4, 0.55]), AIM_Y = 0.44, START_X = 0.5, START_Y = 0.85, SWIPE_FRAMES = 9, SETTLE_FRAMES = 20, POINTER = 1, ShootoutBot = class {
+  constructor() {
+    this.phase = 0;
+    this.wait = 0;
+    this.aim = 0;
+  }
+  drive(scene, game, frame) {
+    let input = game.input, t = chunkH5DFSCJ6_js.templateFrameStamp(frame);
+    if (this.phase === 0) {
+      if (scene.phase !== "playing" || scene.kick.state !== "ready") {
+        this.wait = 0;
+        return;
+      }
+      if (++this.wait < (20)) return;
+      input.pointerEvent("down", (1), (0.5), (0.85), t), this.phase = 1, this.wait = 0;
+      return;
+    }
+    if (++this.wait < (9)) {
+      let k = this.wait / (9);
+      input.pointerEvent("move", (1), (0.5) + (AIMS_X[this.aim] - (0.5)) * k, (0.85) + ((0.44) - (0.85)) * k, t);
+      return;
+    }
+    input.pointerEvent("up", (1), AIMS_X[this.aim], (0.44), t), this.aim = (this.aim + 1) % AIMS_X.length, this.phase = 0, this.wait = 0;
+  }
+}, DIGEST_FIELDS = 5, digestScratch = new Int32Array((5)), penaltyShootoutTemplate = {
+  id: "penalty-shootout",
+  title: "Penalty shootout",
+  sources: ["src/game/kit/templates/shootout.ts", "src/game/samples/penalty-kick.ts"],
+  economy: shootoutEconomy,
+  scene: () => new PenaltyShootout(),
+  bot: () => new ShootoutBot(),
+  progress: (scene) => scene.totalGoals,
+  digest(scene) {
+    let d = digestScratch;
+    return d[0] = scene.totalGoals, d[1] = scene.kick.shots, d[2] = scene.series, d[3] = scene.seriesKicks, d[4] = scene.bestSeries, chunkH5DFSCJ6_js.digestInts(d, (5));
+  }
+};
+
+exports.PenaltyShootout = PenaltyShootout;
+exports.SHOOTOUT = SHOOTOUT;
+exports.buyClassicBall = buyClassicBall;
+exports.classicBall = classicBall;
+exports.goalTokens = goalTokens;
+exports.goldBoots = goldBoots;
+exports.goldBootsOffer = goldBootsOffer;
+exports.kente = kente;
+exports.kitDraw = kitDraw;
+exports.nightPitch = nightPitch;
+exports.penaltyShootoutTemplate = penaltyShootoutTemplate;
+exports.shootoutEconomy = shootoutEconomy;
+exports.shootout_exports = shootout_exports;
+exports.starPack = starPack;
+exports.stars = stars;
+exports.tokens = tokens;