pre-mortem 0.1.0

package/src/blocks.ts

@@ -0,0 +1,182 @@
+import Matter from 'matter-js';
+
+export enum BlockType {
+  BOOTSTRAP = 'bootstrap',
+  VC = 'vc',
+  SLACKER = 'slacker',
+  CONTROL_FREAK = 'control_freak',
+  PRIMA_DONNA = 'prima_donna',
+  QUIET_QUITTER = 'quiet_quitter',
+  SLACK_SPAMMER = 'slack_spammer'
+}
+
+export interface BlockConfig {
+  w: number;
+  h: number;
+  color: string;
+  density: number;
+  friction: number;
+  restitution: number;
+  label: string;
+  possibleLabels?: string[];
+}
+
+export const BLOCK_DEFINITIONS: Record<BlockType, BlockConfig> = {
+  [BlockType.BOOTSTRAP]: {
+    w: 132, 
+    h: 44, 
+    color: '#555555', // Concrete/Rust
+    density: 0.005, // High relative density (Matter.js default is 0.001)
+    friction: 0.8,
+    restitution: 0.0,
+    label: 'Refactoring',
+    possibleLabels: [
+      // The Work (Old & New)
+      'Refactoring', 'Unit Tests', 'Bug Fixes', 'User Support',
+      'Documentation', 'Security Audit', 'Compliance', 'Cleanup',
+      'Optimization', 'CI/CD Pipeline', 'Code Review', 'DB Tuning',
+      'API Design', 'Accessibility', 'Localization', 'Error Logs',
+      'Backups', 'Legacy Code', 'Hiring', 'Customer Love',
+      'Bossware', 'YAML Hell', 'DNS Propagation', 'Regex', 'npm audit',
+      'GDPR / SOC2', 'Migration', 'Certificate Expiry', 'On-Call',
+      'Technical Debt', 'Works on my machine', 'Yak Shaving'
+    ]
+  },
+  [BlockType.VC]: {
+    w: 120,
+    h: 40,
+    color: '#FF00FF', // Neon Pink
+    density: 0.0005, // Slightly heavier (was 0.0001)
+    friction: 0.3, // Less slippery (was 0.1)
+    restitution: 0.6, // Less bouncy (was 0.9)
+    label: 'AI Blockchain',
+    possibleLabels: [
+      // The Hype (Old & New)
+      'GenAI', 'Blockchain', 'Web3', 'Metaverse', 'NFTs',
+      'Viral Growth', 'Pivot', 'Synergy', 'Disruption',
+      'Thought Leader', 'Influencers', 'Hyper-Scale', 'Quantum',
+      'Big Data', 'Growth Hack', 'Paradigm Shift', '10x Engineer',
+      'Visionary', 'Series B Pitch', 'Exit Strategy',
+      'Vibe Coding', 'Founder Mode', 'Prompt Engineering', 'AGI',
+      'AI Wrapper', 'Unlimited PTO', 'Radical Candor', 'Community Led',
+      'Pre-Revenue', 'Fractional CxO'
+    ]
+  },
+  [BlockType.SLACKER]: {
+    w: 64, // 80 * 0.8
+    h: 64, // 80 * 0.8
+    color: '#FFFFFF', 
+    density: 0.01,
+    friction: 1.0, 
+    restitution: 0.1, 
+    label: 'The Slacker',
+    possibleLabels: ['The Slacker'] 
+  },
+  [BlockType.CONTROL_FREAK]: {
+    w: 64, // Square to match image aspect ratio
+    h: 64, 
+    color: '#FF0000', density: 0.012, friction: 0.5, restitution: 0.2, 
+    label: 'Control Freak', possibleLabels: ['Control Freak']
+  },
+  [BlockType.PRIMA_DONNA]: {
+    w: 56, h: 56, // 70 * 0.8
+    color: '#FFFF00', density: 0.008, friction: 0.1, restitution: 1.2, 
+    label: 'Prima Donna', possibleLabels: ['Prima Donna']
+  },
+  [BlockType.QUIET_QUITTER]: {
+    w: 48, h: 48, // 60 * 0.8
+    color: '#00FFFF', density: 0.005, friction: 0.01, restitution: 0.9, 
+    label: 'Quiet Quitter', possibleLabels: ['Quiet Quitter']
+  },
+  [BlockType.SLACK_SPAMMER]: {
+    w: 60, h: 60, // 75 * 0.8
+    color: '#00FF00', density: 0.01, friction: 0.4, restitution: 0.4, 
+    label: 'Slack Spammer', possibleLabels: ['Slack Spammer']
+  }
+};
+
+export const getRandomLabel = (type: BlockType): string => {
+  const labels = BLOCK_DEFINITIONS[type].possibleLabels || [];
+  return labels[Math.floor(Math.random() * labels.length)];
+}
+
+export const createBlock = (x: number, y: number, type: BlockType) => {
+  const def = BLOCK_DEFINITIONS[type];
+  const labelText = getRandomLabel(type);
+  
+  const options = {
+    density: def.density,
+    friction: def.friction,
+    restitution: def.restitution,
+    render: {
+      fillStyle: def.color,
+      strokeStyle: '#000',
+      lineWidth: 2,
+    },
+    label: labelText,
+  };
+
+  if (type === BlockType.VC) {
+    // "Long Side Trapezoid" / Distorted Wedge
+    // Create an irregular quadrilateral that is annoying to stack
+    const w = def.w;
+    const h = def.h;
+    
+    // Randomize the top corners to create a slanted roof (Wedge)
+    // or skew the sides (Parallelogram)
+    const y1 = Math.random() * 15; // Top-Left drop
+    const y2 = Math.random() * 15; // Top-Right drop
+    const skew = (Math.random() - 0.5) * 20; // skew x
+
+    const vertices = [
+      { x: 0 + skew, y: y1 },           // TL
+      { x: w + skew, y: y2 },           // TR
+      { x: w, y: h },                   // BR
+      { x: 0, y: h }                    // BL
+    ];
+
+    return Matter.Bodies.fromVertices(x, y, [vertices], options);
+    return Matter.Bodies.fromVertices(x, y, [vertices], options);
+  } else if (type === BlockType.SLACKER || 
+             type === BlockType.CONTROL_FREAK || 
+             type === BlockType.PRIMA_DONNA || 
+             type === BlockType.QUIET_QUITTER || 
+             type === BlockType.SLACK_SPAMMER) {
+      
+      const textureMap: Record<string, string> = {
+          [BlockType.SLACKER]: './slacker.png',
+          [BlockType.CONTROL_FREAK]: './control-freak.png',
+          [BlockType.PRIMA_DONNA]: './prima-donna.png',
+          [BlockType.QUIET_QUITTER]: './quet-quitter.png', // User typo kept
+          [BlockType.SLACK_SPAMMER]: './slack-spammer.png'
+      };
+
+      const spriteOptions = {
+          ...options,
+          render: {
+              sprite: {
+                  texture: textureMap[type],
+                  xScale: (def.w / 512) * 2, // Approximate
+                  yScale: (def.h / 512) * 2
+              },
+              lineWidth: 3,
+              strokeStyle: '#ffffff'
+          }
+      };
+
+      if (type === BlockType.QUIET_QUITTER) {
+          return Matter.Bodies.circle(x, y, def.w / 2, spriteOptions);
+      } else if (type === BlockType.CONTROL_FREAK) {
+          return Matter.Bodies.trapezoid(x, y, def.w, def.h, 0.5, spriteOptions);
+      } else if (type === BlockType.PRIMA_DONNA) {
+           return Matter.Bodies.polygon(x, y, 5, def.w / 2, spriteOptions); // Pentagon
+      } else if (type === BlockType.SLACK_SPAMMER) {
+           return Matter.Bodies.polygon(x, y, 6, def.w / 2, spriteOptions); // Hexagon
+      } else {
+           // Default Slacker (Square)
+           return Matter.Bodies.rectangle(x, y, def.w, def.h, spriteOptions);
+      }
+  } else {
+    return Matter.Bodies.rectangle(x, y, def.w, def.h, options);
+  }
+};

package/src/game.ts

@@ -0,0 +1,366 @@
+import Matter from 'matter-js';
+import { createBlock, BlockType } from './blocks';
+import { GameState, StageConfig } from './gamestate';
+
+export interface GameConfig {
+  logoUrl?: string; // Optional logo URL
+  width?: number;
+  height?: number;
+  initialRunway?: number;
+  stages?: StageConfig[];
+  onCrisis?: (shout: string, desc: string) => void;
+  chaosInterval?: number; // in ms
+}
+
+export class PreMortemGame {
+  private engine: Matter.Engine;
+  private render: Matter.Render;
+  private runner: Matter.Runner;
+  private container: HTMLElement;
+  private width: number;
+  private height: number;
+  private mouseConstraint!: Matter.MouseConstraint;
+  private currentQuote: { text: string, author: string } | null = null;
+  private chaosTimer: number = 10000; // Debug: Initial event after 10s
+  private chaosInterval: number = 90000; // Default 1.5 mins
+  private onCrisis?: (shout: string, desc: string) => void;
+
+  public gameState: GameState;
+  public spawnVertical: boolean = false;
+  
+  constructor(container: HTMLElement, config: GameConfig = {}) {
+    this.container = container;
+    this.width = config.width || container.clientWidth || 800;
+    this.height = config.height || container.clientHeight || 600;
+    this.onCrisis = config.onCrisis;
+    this.chaosInterval = config.chaosInterval || 90000; // 1.5 min default
+    // Set first timer to 10s for debug as requested, or use config if provided
+    this.chaosTimer = config.chaosInterval ? config.chaosInterval : 10000; 
+
+    const defaultStages: StageConfig[] = [
+        { name: 'Seed Round', threshold: 0, burnRate: 2_000 },
+        { name: 'Series A', threshold: 100_000_000, burnRate: 10_000, fundingBonus: 250_000 },
+        { name: 'Series B', threshold: 250_000_000, burnRate: 25_000, fundingBonus: 500_000 },
+        { name: 'Series C', threshold: 500_000_000, burnRate: 50_000, fundingBonus: 1_000_000 },
+        { name: 'Series D', threshold: 700_000_000, burnRate: 75_000, fundingBonus: 2_000_000 },
+        { name: 'Series E', threshold: 850_000_000, burnRate: 100_000, fundingBonus: 5_000_000 },
+        { name: 'Unicorn Status', threshold: 1_000_000_000, burnRate: 150_000, fundingBonus: 10_000_000 },
+    ];
+
+    this.gameState = new GameState({
+      initialRunway: config.initialRunway || 200_000, 
+      stages: config.stages || defaultStages
+    });
+
+    this.engine = Matter.Engine.create();
+    this.render = Matter.Render.create({
+      element: this.container,
+      engine: this.engine,
+      options: {
+        width: this.width,
+        height: this.height,
+        wireframes: false,
+        background: '#1a1a1a', 
+      },
+    });
+
+    this.runner = Matter.Runner.create();
+    
+    this.initWorld();
+    this.initMouse();
+    this.initRenderLoop();
+    this.initGameLoop();
+    this.initControls();
+    
+    this.gameState.subscribe(() => {
+        if (this.gameState.status === 'paused') {
+            this.runner.enabled = false;
+        } else if (this.gameState.status === 'playing') {
+            this.runner.enabled = true;
+        }
+    });
+  }
+
+  private initControls() {
+      window.addEventListener('keydown', (e) => {
+          if ((e.key === 'r' || e.key === 'R') && this.gameState.isPlaying()) {
+             this.rotateHeldBody();
+          }
+      });
+  }
+
+  private rotateHeldBody() {
+      const body = this.mouseConstraint.body;
+      if (body) {
+          Matter.Body.rotate(body, 45 * (Math.PI / 180));
+      }
+  }
+
+  private initWorld() {
+    const { width, height } = this;
+    const groundHeight = 60;
+    
+    const ground = Matter.Bodies.rectangle(width / 2, height - groundHeight / 2, width, groundHeight, { 
+      isStatic: true,
+      render: { fillStyle: '#333' }
+    });
+    
+    Matter.Composite.add(this.engine.world, [ground]);
+  }
+
+  private initMouse() {
+    const mouse = Matter.Mouse.create(this.render.canvas);
+    this.mouseConstraint = Matter.MouseConstraint.create(this.engine, {
+      mouse: mouse,
+      constraint: {
+        stiffness: 0.2,
+        render: { visible: false }
+      }
+    });
+
+    Matter.Composite.add(this.engine.world, this.mouseConstraint);
+    this.render.mouse = mouse;
+  }
+
+  public start() {
+    Matter.Render.run(this.render);
+    Matter.Runner.run(this.runner, this.engine);
+  }
+
+  public stop() {
+    Matter.Render.stop(this.render);
+    Matter.Runner.stop(this.runner);
+  }
+
+  private initRenderLoop() {
+    Matter.Events.on(this.render, 'afterRender', () => {
+      const context = this.render.context;
+      const cx = this.width / 2;
+      const officeWidth = 400;
+      const dangerWidth = 700; 
+      const topOffset = 100;
+      
+      const officeRect = { x: cx - officeWidth/2, y: topOffset, w: officeWidth, h: this.height - topOffset };
+      const dangerRect = { x: cx - dangerWidth/2, y: topOffset - 50, w: dangerWidth, h: this.height - topOffset + 100 };
+
+      // Office Zone
+      context.beginPath();
+      context.setLineDash([10, 10]);
+      context.lineWidth = 2;
+      context.strokeStyle = 'rgba(255, 255, 255, 0.3)';
+      context.strokeRect(officeRect.x, officeRect.y, officeRect.w, officeRect.h);
+      
+      context.font = '10px "Inter", sans-serif';
+      context.fillStyle = 'rgba(255, 255, 255, 0.3)';
+      context.textAlign = 'center';
+      context.fillText("ACCURATE VALUATION ZONE", cx, officeRect.y - 15);
+
+      // Quote
+      if (!this.currentQuote) {
+          const quotes = [
+              { text: "WE ARE A\nFAMILY", author: "- CEO" },
+              { text: "CHANGE THE\nWORLD", author: "- Founder" },
+              { text: "DISRUPT\nEVERYTHING", author: "- VC" },
+              { text: "MOVE FAST\nBREAK THINGS", author: "- Tech Lead" },
+              { text: "RADICAL\nCANDOR", author: "- HR" },
+              { text: "UNLIMITED\nPTO", author: "- Recruiter" },
+              { text: "VISIONARY\nLEADER", author: "- LinkedIn" },
+              { text: "10X\nGROWTH", author: "- Investor" },
+              { text: "PIVOT\nTO AI", author: "- Board" }
+          ];
+          this.currentQuote = quotes[Math.floor(Math.random() * quotes.length)];
+      }
+      
+      context.save();
+      context.translate(cx, officeRect.y + officeRect.h / 3);
+      context.rotate(-Math.PI / 12);
+      context.textAlign = 'center';
+      context.textBaseline = 'middle';
+      context.font = '900 48px "Inter", sans-serif';
+      context.fillStyle = 'rgba(255, 255, 255, 0.05)';
+      
+      const lines = this.currentQuote.text.split('\n');
+      lines.forEach((line, i) => context.fillText(line, 0, i * 50));
+      
+      context.font = 'italic 700 24px "Inter", sans-serif';
+      context.fillStyle = 'rgba(255, 255, 255, 0.04)'; 
+      context.fillText(this.currentQuote.author, 0, lines.length * 50 + 10);
+      context.restore();
+
+      // Danger Zone
+      context.beginPath();
+      context.setLineDash([]);
+      context.lineWidth = 1;
+      context.strokeStyle = 'rgba(255, 50, 50, 0.2)';
+      context.strokeRect(dangerRect.x, dangerRect.y, dangerRect.w, dangerRect.h);
+
+      // Block Labels
+      context.font = 'bold 13px "Inter", sans-serif';
+      context.textAlign = 'center';
+      context.textBaseline = 'middle';
+      context.fillStyle = '#FFFFFF';
+
+      this.engine.world.bodies.forEach((body) => {
+        if (!body.label || body.label.includes('Body')) return;
+        if (body.isStatic) return;
+
+        const data = (body as any).gameData;
+        const isVested = data && data.vested;
+
+        context.save();
+        context.translate(body.position.x, body.position.y);
+        context.rotate(body.angle);
+        
+        if (isVested) {
+            context.shadowColor = '#00ff7f';
+            context.shadowBlur = 10;
+            context.fillStyle = '#00ff7f';
+            context.fillText(body.label + " ✓", 0, 0);
+        } else {
+            context.shadowColor = 'black';
+            context.shadowBlur = 4;
+            context.fillStyle = '#FFFFFF';
+            context.fillText(body.label, 0, 0);
+        }
+        
+        context.restore();
+      });
+    });
+  }
+
+  private initGameLoop() { 
+    Matter.Events.on(this.runner, 'afterUpdate', () => {
+      if (!this.gameState.isPlaying()) return;
+
+      const dt = this.runner.delta;
+      this.gameState.tick(dt / 1000);
+
+      // Chaos Timer
+      if (this.gameState.valuation >= 1_000_000) { 
+          this.chaosTimer -= dt;
+          if (this.chaosTimer <= 0) {
+              this.triggerChaosEvent();
+              this.chaosTimer = this.chaosInterval;
+          }
+      }
+
+      const cx = this.width / 2;
+      const officeWidth = 400; 
+      const dangerWidth = 700; 
+
+      this.engine.world.bodies.forEach(body => {
+          if (body.isStatic) return;
+          const data = (body as any).gameData;
+          
+          const isOutside = Math.abs(body.position.x - cx) > dangerWidth / 2 || 
+                            body.position.y > this.height + 50;
+
+          if (isOutside) {
+              Matter.Composite.remove(this.engine.world, body);
+              const reasons = ["VC Scolding!", "Server Outage!", "GDPR Violation!", "TechCrunch Hit Piece!", "IP Lawsuit!"];
+              this.gameState.penalty(50_000, reasons[Math.floor(Math.random() * reasons.length)]); 
+              return;
+          }
+
+          if (data && !data.vested) {
+              const IsStill = body.speed < 0.15 && Math.abs(body.angularVelocity) < 0.05;
+              const Inside = Math.abs(body.position.x - cx) < officeWidth / 2;
+
+              if (IsStill && Inside) {
+                  data.vestTimer += this.runner.delta; 
+                  if (data.vestTimer > 1000) { 
+                      data.vested = true;
+                      this.gameState.addValuation(data.value);
+                  }
+              } else {
+                  data.vestTimer = 0; 
+              }
+          }
+      });
+    });
+  }
+
+  private triggerChaosEvent() {
+      const eventId = Math.floor(Math.random() * 5);
+      switch (eventId) {
+          case 0:
+              this.onCrisis?.("STRATEGIC PIVOT", "CEO: 'We are pivoting to AI!' (Gravity Shift)");
+              this.engine.world.gravity.x = 0.2; // Reduced from 0.5 as requested
+              setTimeout(() => { this.engine.world.gravity.x = 0; }, 5000);
+              break;
+          case 1:
+              this.onCrisis?.("THE BIG REORG", "HR: 'New Org Chart Announced!' (No Friction)");
+              this.engine.world.bodies.forEach(b => {
+                  if (b.isStatic) return;
+                  (b as any).oldFriction = b.friction;
+                  b.friction = 0;
+                  b.frictionStatic = 0;
+              });
+              setTimeout(() => {
+                  this.engine.world.bodies.forEach(b => {
+                      if (b.isStatic) return;
+                      b.friction = (b as any).oldFriction || 0.1;
+                      b.frictionStatic = 0.5;
+                  });
+              }, 5000);
+              break;
+          case 2:
+              this.onCrisis?.("LEGACY DEPRECATION", "CTO: 'Deprecating v1 API!' (Ghost Blocks)");
+              const active = this.engine.world.bodies.filter(b => !b.isStatic);
+              if (active.length > 3) {
+                  const target = active[Math.floor(Math.random() * active.length)];
+                  target.isSensor = true;
+                  setTimeout(() => { target.isSensor = false; }, 4000);
+              }
+              break;
+          case 3:
+              this.onCrisis?.("FEATURE CREEP", "PM: 'Just one more feature...' (1.2x Scaling)");
+              this.engine.world.bodies.forEach(b => {
+                  if (!b.isStatic) Matter.Body.scale(b, 1.2, 1.2);
+              });
+              break;
+          case 4:
+              this.onCrisis?.("VIRAL SPIKE", "DevOps: 'Traffic Spike!' (Earthquake)");
+              let shakes = 0;
+              const interval = setInterval(() => {
+                  this.engine.world.bodies.forEach(b => {
+                      if (!b.isStatic) Matter.Body.applyForce(b, b.position, { x: (Math.random()-0.5)*0.05, y: (Math.random()-0.5)*0.05 });
+                  });
+                  if (++shakes > 20) clearInterval(interval);
+              }, 100);
+              break;
+      }
+  }
+
+  public toggleRotation() {
+    this.spawnVertical = !this.spawnVertical;
+  }
+
+  public spawnBlock(type: BlockType) {
+    if (!this.gameState.isPlaying()) return;
+    if (Math.random() < 1/15) {
+        const toxics = [BlockType.SLACKER, BlockType.CONTROL_FREAK, BlockType.PRIMA_DONNA, BlockType.QUIET_QUITTER, BlockType.SLACK_SPAMMER];
+        type = toxics[Math.floor(Math.random() * toxics.length)];
+    }
+
+    if (type === BlockType.BOOTSTRAP) this.gameState.spendMoney(5_000); 
+    else if (type === BlockType.VC) this.gameState.addMoney(75_000); // 1.5x of 50k
+
+    const x = this.width / 2 + (Math.random() - 0.5) * 40; 
+    const block = createBlock(x, y, type); // y is 100
+    let angle = this.spawnVertical ? 90 * (Math.PI / 180) : 0;
+    if (type === BlockType.VC) angle += (Math.random() - 0.5) * (30 * (Math.PI / 180));
+    Matter.Body.setAngle(block, angle);
+
+    (block as any).gameData = {
+        type,
+        value: type === BlockType.VC ? 50_000_000 : (type === BlockType.BOOTSTRAP ? 5_000_000 : 0),
+        vested: false,
+        vestTimer: 0
+    };
+    Matter.Composite.add(this.engine.world, block);
+  }
+}
+
+// Fixed constant y at the end
+const y = 100;