zeroed-some/dougk / 0c90bc9

+  // Automatically unequips any other outfit of the same type or conflicting types

+    // Build list of types to unequip: same type + any conflicting types

+    const typesToUnequip = [newItem.type]

+    if (newItem.conflictsWith && Array.isArray(newItem.conflictsWith)) {

+      typesToUnequip.push(...newItem.conflictsWith)

+    }

+

+    // Find and unequip any item of conflicting types

+    const conflictingItems = this.equipped[character].filter(equippedId => {

+      if (!equippedItem) return false

+      // Check if equipped item's type is in our unequip list

+      if (typesToUnequip.includes(equippedItem.type)) return true

+      // Also check if the equipped item conflicts with our new item's type

+      if (equippedItem.conflictsWith && equippedItem.conflictsWith.includes(newItem.type)) return true

+      return false

+    // Remove conflicting items

+    for (const oldId of conflictingItems) {

+    return conflictingItems

+  // Doug outfits - full costumes with accessories

+  doug_chef: {

+    id: 'doug_chef',

+    name: 'Chef Doug',

+    character: CHARACTERS.DOUG,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    conflictsWith: [OUTFIT_TYPES.ACCESSORY_HEAD],

+    price: 65,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const whiteMat = new THREE.MeshToonMaterial({ color: 0xffffff, gradientMap })

+      const apronMat = new THREE.MeshToonMaterial({ color: 0xf5f5f5, gradientMap })

+      const strapMat = new THREE.MeshToonMaterial({ color: 0xe8e8e8, gradientMap })

+

+      // Chef's toque (tall puffy hat)

+      const toqueBase = new THREE.CylinderGeometry(0.18, 0.2, 0.08, 12)

+      const toqueBaseMesh = new THREE.Mesh(toqueBase, whiteMat)

+      toqueBaseMesh.position.set(0.1, 0.75, 0)

+      group.add(toqueBaseMesh)

+

+      // Puffy top of toque (multiple spheres for volume)

+      const puffGeom = new THREE.SphereGeometry(0.14, 8, 6)

+      const puff1 = new THREE.Mesh(puffGeom, whiteMat)

+      puff1.position.set(0.1, 0.9, 0)

+      group.add(puff1)

+

+      const puff2 = new THREE.Mesh(puffGeom, whiteMat)

+      puff2.position.set(0.08, 0.98, 0.05)

+      puff2.scale.set(0.9, 0.85, 0.9)

+      group.add(puff2)

+

+      const puff3 = new THREE.Mesh(puffGeom, whiteMat)

+      puff3.position.set(0.12, 0.95, -0.05)

+      puff3.scale.set(0.85, 0.8, 0.85)

+      group.add(puff3)

+

+      // Apron body

+      const apronBodyGeom = new THREE.BoxGeometry(0.08, 0.4, 0.45)

+      const apronBody = new THREE.Mesh(apronBodyGeom, apronMat)

+      apronBody.position.set(0.38, 0.2, 0)

+      group.add(apronBody)

+

+      // Apron bib (upper part)

+      const bibGeom = new THREE.BoxGeometry(0.06, 0.2, 0.3)

+      const bib = new THREE.Mesh(bibGeom, apronMat)

+      bib.position.set(0.4, 0.45, 0)

+      group.add(bib)

+

+      // Neck strap

+      const neckStrapGeom = new THREE.TorusGeometry(0.15, 0.015, 4, 12, Math.PI)

+      const neckStrap = new THREE.Mesh(neckStrapGeom, strapMat)

+      neckStrap.position.set(0.25, 0.55, 0)

+      neckStrap.rotation.z = Math.PI

+      neckStrap.rotation.y = Math.PI / 2

+      group.add(neckStrap)

+

+      // Waist ties (hanging at sides)

+      const tieGeom = new THREE.BoxGeometry(0.2, 0.02, 0.03)

+      const leftTie = new THREE.Mesh(tieGeom, strapMat)

+      leftTie.position.set(0.25, 0.25, 0.25)

+      leftTie.rotation.y = 0.3

+      group.add(leftTie)

+

+      const rightTie = new THREE.Mesh(tieGeom, strapMat)

+      rightTie.position.set(0.25, 0.25, -0.25)

+      rightTie.rotation.y = -0.3

+      group.add(rightTie)

+

+      // Apron pocket

+      const pocketGeom = new THREE.BoxGeometry(0.02, 0.1, 0.15)

+      const pocket = new THREE.Mesh(pocketGeom, strapMat)

+      pocket.position.set(0.42, 0.18, 0)

+      group.add(pocket)

+

+      return group

+    }

+  },

+

+  doug_superhero: {

+    id: 'doug_superhero',

+    name: 'Super Duck',

+    character: CHARACTERS.DOUG,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    price: 80,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const capeMat = new THREE.MeshToonMaterial({ color: 0xcc0000, gradientMap, side: THREE.DoubleSide })

+      const capeInnerMat = new THREE.MeshToonMaterial({ color: 0xffcc00, gradientMap, side: THREE.DoubleSide })

+      const maskMat = new THREE.MeshToonMaterial({ color: 0x1a1a1a, gradientMap })

+      const emblemMat = new THREE.MeshToonMaterial({ color: 0xffcc00, gradientMap })

+

+      // Cape - draped from shoulders

+      const capeShape = new THREE.Shape()

+      capeShape.moveTo(-0.35, 0)

+      capeShape.lineTo(-0.4, -0.5)

+      capeShape.quadraticCurveTo(0, -0.6, 0.4, -0.5)

+      capeShape.lineTo(0.35, 0)

+      capeShape.quadraticCurveTo(0, 0.05, -0.35, 0)

+

+      const capeGeom = new THREE.ShapeGeometry(capeShape)

+      const cape = new THREE.Mesh(capeGeom, capeMat)

+      cape.position.set(-0.2, 0.4, 0)

+      cape.rotation.y = Math.PI / 2

+      cape.rotation.x = 0.2

+      group.add(cape)

+

+      // Cape inner lining (yellow)

+      const capeInner = new THREE.Mesh(capeGeom, capeInnerMat)

+      capeInner.position.set(-0.22, 0.4, 0)

+      capeInner.rotation.y = Math.PI / 2

+      capeInner.rotation.x = 0.2

+      group.add(capeInner)

+

+      // Cape clasp at neck

+      const claspGeom = new THREE.SphereGeometry(0.04, 8, 6)

+      const claspL = new THREE.Mesh(claspGeom, emblemMat)

+      claspL.position.set(0.15, 0.52, 0.18)

+      group.add(claspL)

+

+      const claspR = new THREE.Mesh(claspGeom, emblemMat)

+      claspR.position.set(0.15, 0.52, -0.18)

+      group.add(claspR)

+

+      // Domino mask

+      const maskGeom = new THREE.BoxGeometry(0.06, 0.08, 0.35)

+      const mask = new THREE.Mesh(maskGeom, maskMat)

+      mask.position.set(0.48, 0.58, 0)

+      group.add(mask)

+

+      // Eye holes in mask

+      const eyeHoleGeom = new THREE.CircleGeometry(0.04, 8)

+      const eyeHoleMat = new THREE.MeshBasicMaterial({ color: 0x000000 })

+      const eyeL = new THREE.Mesh(eyeHoleGeom, eyeHoleMat)

+      eyeL.position.set(0.52, 0.58, 0.08)

+      eyeL.rotation.y = Math.PI / 2

+      group.add(eyeL)

+

+      const eyeR = new THREE.Mesh(eyeHoleGeom, eyeHoleMat)

+      eyeR.position.set(0.52, 0.58, -0.08)

+      eyeR.rotation.y = Math.PI / 2

+      group.add(eyeR)

+

+      // Chest emblem - "D" shield

+      const shieldGeom = new THREE.CircleGeometry(0.1, 6)

+      const shield = new THREE.Mesh(shieldGeom, emblemMat)

+      shield.position.set(0.42, 0.38, 0)

+      shield.rotation.y = Math.PI / 2

+      group.add(shield)

+

+      // D letter on shield

+      const dGeom = new THREE.TorusGeometry(0.04, 0.015, 4, 8, Math.PI)

+      const dLetter = new THREE.Mesh(dGeom, capeMat)

+      dLetter.position.set(0.44, 0.38, 0)

+      dLetter.rotation.y = Math.PI / 2

+      dLetter.rotation.z = -Math.PI / 2

+      group.add(dLetter)

+

+      return group

+    }

+  },

+

+  doug_hoodie: {

+    id: 'doug_hoodie',

+    name: 'Cozy Hoodie',

+    character: CHARACTERS.DOUG,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    conflictsWith: [OUTFIT_TYPES.ACCESSORY_HEAD],

+    price: 55,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const hoodieMat = new THREE.MeshToonMaterial({ color: 0x4a5568, gradientMap })

+      const hoodInnerMat = new THREE.MeshToonMaterial({ color: 0x2d3748, gradientMap })

+      const stringMat = new THREE.MeshToonMaterial({ color: 0xe2e8f0, gradientMap })

+

+      // Hoodie body

+      const bodyGeom = new THREE.SphereGeometry(0.46, 10, 8)

+      bodyGeom.scale(1.38, 0.76, 0.92)

+      const body = new THREE.Mesh(bodyGeom, hoodieMat)

+      body.position.set(0, 0.28, 0)

+      group.add(body)

+

+      // Hood (up, around head)

+      const hoodGeom = new THREE.SphereGeometry(0.28, 10, 8, 0, Math.PI * 2, 0, Math.PI * 0.6)

+      const hood = new THREE.Mesh(hoodGeom, hoodieMat)

+      hood.position.set(0.15, 0.58, 0)

+      hood.rotation.z = -0.3

+      hood.rotation.x = 0.1

+      group.add(hood)

+

+      // Hood inner lining

+      const hoodInnerGeom = new THREE.SphereGeometry(0.26, 10, 8, 0, Math.PI * 2, 0, Math.PI * 0.55)

+      const hoodInner = new THREE.Mesh(hoodInnerGeom, hoodInnerMat)

+      hoodInner.position.set(0.16, 0.58, 0)

+      hoodInner.rotation.z = -0.3

+      hoodInner.rotation.x = 0.1

+      group.add(hoodInner)

+

+      // Hoodie opening for face

+      const openingGeom = new THREE.TorusGeometry(0.18, 0.025, 6, 12)

+      const opening = new THREE.Mesh(openingGeom, hoodInnerMat)

+      opening.position.set(0.38, 0.6, 0)

+      opening.rotation.y = Math.PI / 2

+      opening.rotation.z = -0.1

+      group.add(opening)

+

+      // Drawstrings

+      const stringGeom = new THREE.CylinderGeometry(0.008, 0.008, 0.2, 4)

+      const stringL = new THREE.Mesh(stringGeom, stringMat)

+      stringL.position.set(0.42, 0.42, 0.1)

+      stringL.rotation.z = 0.3

+      group.add(stringL)

+

+      const stringR = new THREE.Mesh(stringGeom, stringMat)

+      stringR.position.set(0.42, 0.42, -0.1)

+      stringR.rotation.z = 0.3

+      group.add(stringR)

+

+      // String tips (little plastic aglets)

+      const agletGeom = new THREE.CylinderGeometry(0.012, 0.008, 0.03, 4)

+      const agletL = new THREE.Mesh(agletGeom, stringMat)

+      agletL.position.set(0.48, 0.32, 0.1)

+      group.add(agletL)

+

+      const agletR = new THREE.Mesh(agletGeom, stringMat)

+      agletR.position.set(0.48, 0.32, -0.1)

+      group.add(agletR)

+

+      // Front pocket (kangaroo pouch)

+      const pocketGeom = new THREE.SphereGeometry(0.2, 8, 6, 0, Math.PI, 0, Math.PI)

+      pocketGeom.scale(1.2, 0.5, 0.8)

+      const pocket = new THREE.Mesh(pocketGeom, hoodInnerMat)

+      pocket.position.set(0.4, 0.15, 0)

+      pocket.rotation.y = Math.PI / 2

+      pocket.rotation.z = Math.PI

+      group.add(pocket)

+

+      // Pocket opening

+      const pocketOpenGeom = new THREE.TorusGeometry(0.12, 0.015, 4, 12, Math.PI)

+      const pocketOpen = new THREE.Mesh(pocketOpenGeom, hoodieMat)

+      pocketOpen.position.set(0.42, 0.18, 0)

+      pocketOpen.rotation.y = Math.PI / 2

+      pocketOpen.rotation.x = Math.PI / 2

+      group.add(pocketOpen)

+

+      // Sleeves

+      const sleeveGeom = new THREE.CylinderGeometry(0.09, 0.11, 0.18, 6)

+      const leftSleeve = new THREE.Mesh(sleeveGeom, hoodieMat)

+      leftSleeve.position.set(0.05, 0.3, 0.38)

+      leftSleeve.rotation.x = Math.PI / 2

+      leftSleeve.rotation.z = 0.3

+      group.add(leftSleeve)

+

+      const rightSleeve = new THREE.Mesh(sleeveGeom, hoodieMat)

+      rightSleeve.position.set(0.05, 0.3, -0.38)

+      rightSleeve.rotation.x = -Math.PI / 2

+      rightSleeve.rotation.z = 0.3

+      group.add(rightSleeve)

+

+      // Ribbed cuffs

+      const cuffGeom = new THREE.TorusGeometry(0.085, 0.02, 4, 8)

+      const leftCuff = new THREE.Mesh(cuffGeom, hoodInnerMat)

+      leftCuff.position.set(0.0, 0.28, 0.46)

+      leftCuff.rotation.y = Math.PI / 2

+      group.add(leftCuff)

+

+      const rightCuff = new THREE.Mesh(cuffGeom, hoodInnerMat)

+      rightCuff.position.set(0.0, 0.28, -0.46)

+      rightCuff.rotation.y = Math.PI / 2

+      group.add(rightCuff)

+

+      return group

+    }

+  },

+

+  // Donny outfits - full costumes

+  donny_tuxedo: {

+    id: 'donny_tuxedo',

+    name: 'Tuxedo',

+    character: CHARACTERS.DONNY,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    price: 90,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const blackMat = new THREE.MeshToonMaterial({ color: 0x1a1a1a, gradientMap })

+      const whiteMat = new THREE.MeshToonMaterial({ color: 0xffffff, gradientMap })

+      const bowMat = new THREE.MeshToonMaterial({ color: 0x1a1a1a, gradientMap })

+

+      // White shirt front

+      const shirtGeom = new THREE.CylinderGeometry(0.32, 0.36, 0.5, 10, 1, false, -Math.PI * 0.3, Math.PI * 0.6)

+      const shirt = new THREE.Mesh(shirtGeom, whiteMat)

+      shirt.position.set(0, 0.2, 0.15)

+      shirt.rotation.x = Math.PI / 2

+      group.add(shirt)

+

+      // Tuxedo jacket body

+      const jacketGeom = new THREE.CylinderGeometry(0.38, 0.44, 0.65, 10)

+      const jacket = new THREE.Mesh(jacketGeom, blackMat)

+      jacket.position.set(0, 0.15, 0)

+      jacket.rotation.x = Math.PI / 2

+      group.add(jacket)

+

+      // Jacket lapels (satin)

+      const lapelGeom = new THREE.BoxGeometry(0.35, 0.04, 0.12)

+      const leftLapel = new THREE.Mesh(lapelGeom, blackMat)

+      leftLapel.position.set(0.08, 0.4, 0.2)

+      leftLapel.rotation.z = 0.3

+      leftLapel.rotation.y = 0.2

+      group.add(leftLapel)

+

+      const rightLapel = new THREE.Mesh(lapelGeom, blackMat)

+      rightLapel.position.set(0.08, 0.4, -0.2)

+      rightLapel.rotation.z = 0.3

+      rightLapel.rotation.y = -0.2

+      group.add(rightLapel)

+

+      // Bow tie

+      const bowWingGeom = new THREE.BoxGeometry(0.08, 0.04, 0.03)

+      const bowL = new THREE.Mesh(bowWingGeom, bowMat)

+      bowL.position.set(0.05, 0.52, 0.06)

+      bowL.rotation.z = 0.2

+      group.add(bowL)

+

+      const bowR = new THREE.Mesh(bowWingGeom, bowMat)

+      bowR.position.set(0.05, 0.52, -0.06)

+      bowR.rotation.z = -0.2

+      group.add(bowR)

+

+      const bowKnotGeom = new THREE.SphereGeometry(0.025, 6, 4)

+      const bowKnot = new THREE.Mesh(bowKnotGeom, bowMat)

+      bowKnot.position.set(0.05, 0.52, 0)

+      group.add(bowKnot)

+

+      // Jacket tails (back)

+      const tailGeom = new THREE.BoxGeometry(0.3, 0.06, 0.15)

+      const leftTail = new THREE.Mesh(tailGeom, blackMat)

+      leftTail.position.set(-0.25, -0.05, 0.12)

+      leftTail.rotation.x = -0.3

+      group.add(leftTail)

+

+      const rightTail = new THREE.Mesh(tailGeom, blackMat)

+      rightTail.position.set(-0.25, -0.05, -0.12)

+      rightTail.rotation.x = 0.3

+      group.add(rightTail)

+

+      // Shirt buttons

+      const buttonGeom = new THREE.SphereGeometry(0.015, 6, 4)

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

+        const btn = new THREE.Mesh(buttonGeom, blackMat)

+        btn.position.set(0.08, 0.35 - i * 0.1, 0.28)

+        group.add(btn)

+      }

+

+      return group

+    }

+  },

+

+  donny_captain: {

+    id: 'donny_captain',

+    name: 'Sea Captain',

+    character: CHARACTERS.DONNY,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    conflictsWith: [OUTFIT_TYPES.ACCESSORY_HEAD],

+    price: 110,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const navyMat = new THREE.MeshToonMaterial({ color: 0x1a1a3a, gradientMap })

+      const goldMat = new THREE.MeshToonMaterial({ color: 0xffd700, gradientMap })

+      const whiteMat = new THREE.MeshToonMaterial({ color: 0xffffff, gradientMap })

+      const blackMat = new THREE.MeshToonMaterial({ color: 0x1a1a1a, gradientMap })

+

+      // Captain's coat

+      const coatGeom = new THREE.CylinderGeometry(0.4, 0.46, 0.7, 10)

+      const coat = new THREE.Mesh(coatGeom, navyMat)

+      coat.position.set(0, 0.12, 0)

+      coat.rotation.x = Math.PI / 2

+      group.add(coat)

+

+      // High collar

+      const collarGeom = new THREE.CylinderGeometry(0.36, 0.34, 0.1, 10, 1, true)

+      const collar = new THREE.Mesh(collarGeom, navyMat)

+      collar.position.set(0, 0.5, 0)

+      collar.rotation.x = Math.PI / 2

+      group.add(collar)

+

+      // Gold collar trim

+      const trimGeom = new THREE.TorusGeometry(0.35, 0.015, 4, 12)

+      const trim = new THREE.Mesh(trimGeom, goldMat)

+      trim.position.set(0, 0.55, 0)

+      trim.rotation.x = Math.PI / 2

+      group.add(trim)

+

+      // Epaulettes

+      const epGeom = new THREE.BoxGeometry(0.12, 0.03, 0.1)

+      const epL = new THREE.Mesh(epGeom, goldMat)

+      epL.position.set(0, 0.45, 0.38)

+      group.add(epL)

+

+      const epR = new THREE.Mesh(epGeom, goldMat)

+      epR.position.set(0, 0.45, -0.38)

+      group.add(epR)

+

+      // Gold fringe on epaulettes

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

+        const fringeGeom = new THREE.CylinderGeometry(0.008, 0.005, 0.06, 4)

+        const fringeL = new THREE.Mesh(fringeGeom, goldMat)

+        fringeL.position.set(-0.02, 0.42, 0.35 + i * 0.03)

+        group.add(fringeL)

+

+        const fringeR = new THREE.Mesh(fringeGeom, goldMat)

+        fringeR.position.set(-0.02, 0.42, -0.35 - i * 0.03)

+        group.add(fringeR)

+      }

+

+      // Gold buttons

+      const buttonGeom = new THREE.SphereGeometry(0.02, 6, 4)

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

+        const btn = new THREE.Mesh(buttonGeom, goldMat)

+        btn.position.set(0.08, 0.35 - i * 0.1, 0.15)

+        group.add(btn)

+      }

+

+      // Captain's peaked cap

+      const capBrimGeom = new THREE.CylinderGeometry(0.22, 0.22, 0.03, 12)

+      const capBrim = new THREE.Mesh(capBrimGeom, blackMat)

+      capBrim.position.set(0.2, 0.7, 0)

+      capBrim.rotation.z = -0.2

+      group.add(capBrim)

+

+      // Cap crown

+      const capCrownGeom = new THREE.CylinderGeometry(0.18, 0.2, 0.12, 12)

+      const capCrown = new THREE.Mesh(capCrownGeom, navyMat)

+      capCrown.position.set(0.18, 0.78, 0)

+      capCrown.rotation.z = -0.2

+      group.add(capCrown)

+

+      // Cap badge

+      const badgeGeom = new THREE.CircleGeometry(0.06, 8)

+      const badge = new THREE.Mesh(badgeGeom, goldMat)

+      badge.position.set(0.32, 0.78, 0)

+      badge.rotation.y = Math.PI / 2

+      badge.rotation.z = -0.2

+      group.add(badge)

+

+      // Anchor on badge

+      const anchorGeom = new THREE.TorusGeometry(0.025, 0.006, 4, 8, Math.PI)

+      const anchor = new THREE.Mesh(anchorGeom, whiteMat)

+      anchor.position.set(0.34, 0.78, 0)

+      anchor.rotation.y = Math.PI / 2

+      anchor.rotation.x = Math.PI

+      group.add(anchor)

+

+      return group

+    }

+  },

+

+  donny_magician: {

+    id: 'donny_magician',

+    name: 'Magician',

+    character: CHARACTERS.DONNY,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    conflictsWith: [OUTFIT_TYPES.ACCESSORY_HEAD],

+    price: 95,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const capeMat = new THREE.MeshToonMaterial({ color: 0x2d0a4e, gradientMap, side: THREE.DoubleSide })

+      const capeInnerMat = new THREE.MeshToonMaterial({ color: 0xffd700, gradientMap, side: THREE.DoubleSide })

+      const hatMat = new THREE.MeshToonMaterial({ color: 0x1a1a1a, gradientMap })

+      const starMat = new THREE.MeshToonMaterial({ color: 0xffd700, gradientMap })

+      const vestMat = new THREE.MeshToonMaterial({ color: 0x4a0080, gradientMap })

+

+      // Vest underneath

+      const vestGeom = new THREE.CylinderGeometry(0.36, 0.4, 0.5, 10)

+      const vest = new THREE.Mesh(vestGeom, vestMat)

+      vest.position.set(0, 0.18, 0)

+      vest.rotation.x = Math.PI / 2

+      group.add(vest)

+

+      // Cape (draped around shoulders)

+      const capeShape = new THREE.Shape()

+      capeShape.moveTo(-0.4, 0)

+      capeShape.lineTo(-0.45, -0.55)

+      capeShape.quadraticCurveTo(0, -0.65, 0.45, -0.55)

+      capeShape.lineTo(0.4, 0)

+      capeShape.quadraticCurveTo(0, 0.05, -0.4, 0)

+

+      const capeGeom = new THREE.ShapeGeometry(capeShape)

+      const cape = new THREE.Mesh(capeGeom, capeMat)

+      cape.position.set(-0.15, 0.35, 0)

+      cape.rotation.y = Math.PI / 2

+      group.add(cape)

+

+      // Cape inner (gold lining)

+      const capeInner = new THREE.Mesh(capeGeom, capeInnerMat)

+      capeInner.position.set(-0.17, 0.35, 0)

+      capeInner.rotation.y = Math.PI / 2

+      group.add(capeInner)

+

+      // Stars on cape

+      const starPositions = [

+        { x: -0.2, y: 0.25, z: 0.2 },

+        { x: -0.25, y: 0.1, z: -0.15 },

+        { x: -0.22, y: 0.0, z: 0.25 }

+      ]

+      for (const pos of starPositions) {

+        const starGeom = new THREE.CircleGeometry(0.03, 5)

+        const star = new THREE.Mesh(starGeom, starMat)

+        star.position.set(pos.x, pos.y, pos.z)

+        star.rotation.y = Math.PI / 2

+        star.rotation.z = Math.PI / 10

+        group.add(star)

+      }

+

+      // Cape clasp (gem)

+      const claspGeom = new THREE.OctahedronGeometry(0.04)

+      const claspMat = new THREE.MeshToonMaterial({ color: 0xff0066, gradientMap })

+      const clasp = new THREE.Mesh(claspGeom, claspMat)

+      clasp.position.set(0.08, 0.5, 0)

+      group.add(clasp)

+

+      // Top hat

+      const hatBrimGeom = new THREE.CylinderGeometry(0.22, 0.22, 0.03, 12)

+      const hatBrim = new THREE.Mesh(hatBrimGeom, hatMat)

+      hatBrim.position.set(0.15, 0.68, 0)

+      hatBrim.rotation.z = -0.15

+      group.add(hatBrim)

+

+      // Hat crown (tall)

+      const hatCrownGeom = new THREE.CylinderGeometry(0.14, 0.14, 0.25, 12)

+      const hatCrown = new THREE.Mesh(hatCrownGeom, hatMat)

+      hatCrown.position.set(0.13, 0.82, 0)

+      hatCrown.rotation.z = -0.15

+      group.add(hatCrown)

+

+      // Hat band

+      const bandGeom = new THREE.TorusGeometry(0.14, 0.015, 4, 12)

+      const band = new THREE.Mesh(bandGeom, starMat)

+      band.position.set(0.14, 0.72, 0)

+      band.rotation.x = Math.PI / 2

+      band.rotation.y = 0.15

+      group.add(band)

+

+      // Star on hat

+      const hatStarGeom = new THREE.CircleGeometry(0.035, 5)

+      const hatStar = new THREE.Mesh(hatStarGeom, starMat)

+      hatStar.position.set(0.27, 0.82, 0)

+      hatStar.rotation.y = Math.PI / 2

+      hatStar.rotation.z = Math.PI / 10

+      group.add(hatStar)

+

+      return group

+    }

+  },

+

+      return group

+    }

+  },

+

+  // Ollie outfits - full costumes

+  ollie_scientist: {

+    id: 'ollie_scientist',

+    name: 'Mad Scientist',

+    character: CHARACTERS.OLLIE,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    conflictsWith: [OUTFIT_TYPES.ACCESSORY_FACE],

+    price: 85,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const labCoatMat = new THREE.MeshToonMaterial({ color: 0xf5f5f5, gradientMap })

+      const goggleMat = new THREE.MeshToonMaterial({ color: 0x8b4513, gradientMap })

+      const lensMat = new THREE.MeshBasicMaterial({ color: 0x66ffff, transparent: true, opacity: 0.7 })

+      const flaskMat = new THREE.MeshBasicMaterial({ color: 0x88ff88, transparent: true, opacity: 0.6 })

+      const glassMat = new THREE.MeshBasicMaterial({ color: 0xccffcc, transparent: true, opacity: 0.4 })

+

+      // Lab coat body

+      const coatGeom = new THREE.SphereGeometry(0.46, 10, 8)

+      coatGeom.scale(1, 0.85, 1)

+      const coat = new THREE.Mesh(coatGeom, labCoatMat)

+      coat.position.set(0, 0.35, 0)

+      group.add(coat)

+

+      // Coat collar

+      const collarGeom = new THREE.TorusGeometry(0.28, 0.04, 4, 12, Math.PI)

+      const collar = new THREE.Mesh(collarGeom, labCoatMat)

+      collar.position.set(0, 0.62, 0.15)

+      collar.rotation.x = Math.PI / 2 + 0.3

+      group.add(collar)

+

+      // Coat lapels

+      const lapelGeom = new THREE.BoxGeometry(0.08, 0.2, 0.06)

+      const lapelL = new THREE.Mesh(lapelGeom, labCoatMat)

+      lapelL.position.set(0.38, 0.5, 0.12)

+      lapelL.rotation.z = -0.2

+      group.add(lapelL)

+

+      const lapelR = new THREE.Mesh(lapelGeom, labCoatMat)

+      lapelR.position.set(0.38, 0.5, -0.12)

+      lapelR.rotation.z = -0.2

+      group.add(lapelR)

+

+      // Pocket with pens

+      const pocketGeom = new THREE.BoxGeometry(0.02, 0.1, 0.08)

+      const pocket = new THREE.Mesh(pocketGeom, labCoatMat)

+      pocket.position.set(0.45, 0.45, 0.15)

+      group.add(pocket)

+

+      // Pens in pocket

+      const penMat = new THREE.MeshToonMaterial({ color: 0x1a1a1a, gradientMap })

+      const penGeom = new THREE.CylinderGeometry(0.008, 0.008, 0.08, 4)

+      const pen1 = new THREE.Mesh(penGeom, penMat)

+      pen1.position.set(0.46, 0.52, 0.13)

+      group.add(pen1)

+

+      const pen2Mat = new THREE.MeshToonMaterial({ color: 0x0000aa, gradientMap })

+      const pen2 = new THREE.Mesh(penGeom, pen2Mat)

+      pen2.position.set(0.46, 0.51, 0.17)

+      pen2.rotation.z = 0.1

+      group.add(pen2)

+

+      // Wild goggles (multiple lenses!)

+      const goggleStrapGeom = new THREE.TorusGeometry(0.22, 0.025, 6, 16)

+      const goggleStrap = new THREE.Mesh(goggleStrapGeom, goggleMat)

+      goggleStrap.position.set(0.15, 0.7, 0)

+      goggleStrap.rotation.y = Math.PI / 2

+      group.add(goggleStrap)

+

+      // Main lens (large center)

+      const mainLensGeom = new THREE.CylinderGeometry(0.08, 0.08, 0.04, 12)

+      const mainLensFrame = new THREE.Mesh(mainLensGeom, goggleMat)

+      mainLensFrame.position.set(0.35, 0.7, 0)

+      mainLensFrame.rotation.z = Math.PI / 2

+      group.add(mainLensFrame)

+

+      const mainLens = new THREE.Mesh(new THREE.CircleGeometry(0.07, 12), lensMat)

+      mainLens.position.set(0.38, 0.7, 0)

+      mainLens.rotation.y = Math.PI / 2

+      group.add(mainLens)

+

+      // Extra lens (smaller, offset)

+      const extraLensGeom = new THREE.CylinderGeometry(0.04, 0.04, 0.03, 10)

+      const extraLensFrame = new THREE.Mesh(extraLensGeom, goggleMat)

+      extraLensFrame.position.set(0.38, 0.78, 0.08)

+      extraLensFrame.rotation.z = Math.PI / 2

+      group.add(extraLensFrame)

+

+      const extraLens = new THREE.Mesh(new THREE.CircleGeometry(0.035, 10), lensMat)

+      extraLens.position.set(0.40, 0.78, 0.08)

+      extraLens.rotation.y = Math.PI / 2

+      group.add(extraLens)

+

+      // Bubbling flask (held by tentacle)

+      const flaskGeom = new THREE.CylinderGeometry(0.02, 0.06, 0.15, 8)

+      const flask = new THREE.Mesh(flaskGeom, glassMat)

+      flask.position.set(0.25, 0.1, 0.35)

+      group.add(flask)

+

+      // Flask neck

+      const neckGeom = new THREE.CylinderGeometry(0.02, 0.02, 0.05, 6)

+      const neck = new THREE.Mesh(neckGeom, glassMat)

+      neck.position.set(0.25, 0.2, 0.35)

+      group.add(neck)

+

+      // Bubbling liquid

+      const liquidGeom = new THREE.SphereGeometry(0.045, 8, 6)

+      const liquid = new THREE.Mesh(liquidGeom, flaskMat)

+      liquid.position.set(0.25, 0.08, 0.35)

+      group.add(liquid)

+

+      // Bubbles

+      const bubbleGeom = new THREE.SphereGeometry(0.012, 6, 4)

+      const bubbleMat = new THREE.MeshBasicMaterial({ color: 0xaaffaa, transparent: true, opacity: 0.5 })

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

+        const bubble = new THREE.Mesh(bubbleGeom, bubbleMat)

+        bubble.position.set(0.25 + (Math.random() - 0.5) * 0.03, 0.12 + i * 0.03, 0.35)

+        group.add(bubble)

+      }

+

+      return group

+    }

+  },

+

+  ollie_explorer: {

+    id: 'ollie_explorer',

+    name: 'Explorer',

+    character: CHARACTERS.OLLIE,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    conflictsWith: [OUTFIT_TYPES.ACCESSORY_HEAD],

+    price: 75,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const vestMat = new THREE.MeshToonMaterial({ color: 0xc4a574, gradientMap })

+      const pocketMat = new THREE.MeshToonMaterial({ color: 0xa08050, gradientMap })

+      const helmetMat = new THREE.MeshToonMaterial({ color: 0xf5f5dc, gradientMap })

+      const bandMat = new THREE.MeshToonMaterial({ color: 0x4a3728, gradientMap })

+      const buttonMat = new THREE.MeshToonMaterial({ color: 0x8b4513, gradientMap })

+

+      // Safari vest body

+      const vestGeom = new THREE.SphereGeometry(0.44, 10, 8)

+      vestGeom.scale(1, 0.82, 1)

+      const vest = new THREE.Mesh(vestGeom, vestMat)

+      vest.position.set(0, 0.35, 0)

+      group.add(vest)

+

+      // Multiple pockets (it's a safari vest!)

+      const pocketGeom = new THREE.BoxGeometry(0.03, 0.1, 0.1)

+

+      // Front pockets

+      const pocket1 = new THREE.Mesh(pocketGeom, pocketMat)

+      pocket1.position.set(0.44, 0.3, 0.15)

+      group.add(pocket1)

+

+      const pocket2 = new THREE.Mesh(pocketGeom, pocketMat)

+      pocket2.position.set(0.44, 0.3, -0.15)

+      group.add(pocket2)

+

+      const pocket3 = new THREE.Mesh(pocketGeom, pocketMat)

+      pocket3.position.set(0.44, 0.45, 0.1)

+      pocket3.scale.set(1, 0.7, 0.8)

+      group.add(pocket3)

+

+      // Pocket flaps

+      const flapGeom = new THREE.BoxGeometry(0.02, 0.02, 0.1)

+      const flap1 = new THREE.Mesh(flapGeom, pocketMat)

+      flap1.position.set(0.45, 0.36, 0.15)

+      group.add(flap1)

+

+      const flap2 = new THREE.Mesh(flapGeom, pocketMat)

+      flap2.position.set(0.45, 0.36, -0.15)

+      group.add(flap2)

+

+      // Buttons on pockets

+      const buttonGeom = new THREE.SphereGeometry(0.012, 6, 4)

+      const btn1 = new THREE.Mesh(buttonGeom, buttonMat)

+      btn1.position.set(0.46, 0.36, 0.15)

+      group.add(btn1)

+

+      const btn2 = new THREE.Mesh(buttonGeom, buttonMat)

+      btn2.position.set(0.46, 0.36, -0.15)

+      group.add(btn2)

+

+      // Vest collar

+      const collarGeom = new THREE.TorusGeometry(0.2, 0.03, 4, 10, Math.PI)

+      const collar = new THREE.Mesh(collarGeom, vestMat)

+      collar.position.set(0.1, 0.6, 0.1)

+      collar.rotation.x = Math.PI / 2 + 0.3

+      collar.rotation.z = 0.2

+      group.add(collar)

+

+      // Pith helmet

+      const helmetDomeGeom = new THREE.SphereGeometry(0.2, 12, 8, 0, Math.PI * 2, 0, Math.PI * 0.6)

+      const helmetDome = new THREE.Mesh(helmetDomeGeom, helmetMat)

+      helmetDome.position.set(0.12, 0.72, 0)

+      group.add(helmetDome)

+

+      // Helmet brim

+      const brimGeom = new THREE.TorusGeometry(0.2, 0.04, 4, 16)

+      const brim = new THREE.Mesh(brimGeom, helmetMat)

+      brim.position.set(0.12, 0.68, 0)

+      brim.rotation.x = Math.PI / 2

+      group.add(brim)

+

+      // Helmet band

+      const helmetBandGeom = new THREE.TorusGeometry(0.17, 0.02, 4, 16)

+      const helmetBand = new THREE.Mesh(helmetBandGeom, bandMat)

+      helmetBand.position.set(0.12, 0.72, 0)

+      helmetBand.rotation.x = Math.PI / 2

+      group.add(helmetBand)

+

+      // Helmet top button

+      const topButtonGeom = new THREE.SphereGeometry(0.025, 6, 4)

+      const topButton = new THREE.Mesh(topButtonGeom, bandMat)

+      topButton.position.set(0.12, 0.88, 0)

+      group.add(topButton)

+

+      return group

+    }

+  },

+

+  ollie_artist: {

+    id: 'ollie_artist',

+    name: 'Artist',

+    character: CHARACTERS.OLLIE,

+    type: OUTFIT_TYPES.CLOTHING_BODY,

+    conflictsWith: [OUTFIT_TYPES.ACCESSORY_HEAD],

+    price: 70,

+    meshFactory: (gradientMap) => {

+      const group = new THREE.Group()

+      const smockMat = new THREE.MeshToonMaterial({ color: 0x4a4a6a, gradientMap })

+      const beretMat = new THREE.MeshToonMaterial({ color: 0x8b0000, gradientMap })

+      const paletteMat = new THREE.MeshToonMaterial({ color: 0xdeb887, gradientMap })

+

+      // Paint splatter colors

+      const paintColors = [0xff4444, 0x44ff44, 0x4444ff, 0xffff44, 0xff44ff]

+

+      // Smock body

+      const smockGeom = new THREE.SphereGeometry(0.46, 10, 8)

+      smockGeom.scale(1, 0.85, 1)

+      const smock = new THREE.Mesh(smockGeom, smockMat)

+      smock.position.set(0, 0.35, 0)

+      group.add(smock)

+

+      // Paint splatters on smock

+      const splatPositions = [

+        { x: 0.4, y: 0.4, z: 0.2 },

+        { x: 0.42, y: 0.25, z: -0.15 },

+        { x: 0.38, y: 0.45, z: -0.1 },

+        { x: 0.35, y: 0.3, z: 0.25 },

+        { x: 0.4, y: 0.2, z: 0.1 }

+      ]

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

+        const splatGeom = new THREE.SphereGeometry(0.03 + Math.random() * 0.02, 6, 4)

+        splatGeom.scale(1, 0.3, 1)

+        const splatMat = new THREE.MeshToonMaterial({ color: paintColors[i], gradientMap })

+        const splat = new THREE.Mesh(splatGeom, splatMat)

+        splat.position.set(splatPositions[i].x, splatPositions[i].y, splatPositions[i].z)

+        splat.rotation.y = Math.random() * Math.PI

+        group.add(splat)

+      }

+

+      // Smock collar/neckline

+      const collarGeom = new THREE.TorusGeometry(0.22, 0.03, 4, 12)

+      const collar = new THREE.Mesh(collarGeom, smockMat)

+      collar.position.set(0.05, 0.6, 0)

+      collar.rotation.x = Math.PI / 2

+      collar.rotation.y = 0.2

+      group.add(collar)

+

+      // Beret

+      const beretGeom = new THREE.SphereGeometry(0.18, 10, 8)

+      beretGeom.scale(1.3, 0.5, 1.3)

+      const beret = new THREE.Mesh(beretGeom, beretMat)

+      beret.position.set(0.15, 0.78, 0.05)

+      beret.rotation.z = -0.3

+      group.add(beret)

+

+      // Beret stem/tip

+      const stemGeom = new THREE.SphereGeometry(0.03, 6, 4)

+      const stem = new THREE.Mesh(stemGeom, beretMat)

+      stem.position.set(0.15, 0.85, 0.05)

+      group.add(stem)

+

+      // Beret band

+      const bandGeom = new THREE.TorusGeometry(0.15, 0.015, 4, 12)

+      const band = new THREE.Mesh(bandGeom, beretMat)

+      band.position.set(0.13, 0.72, 0)

+      band.rotation.x = Math.PI / 2

+      band.rotation.y = 0.3

+      group.add(band)

+

+      // Painter's palette (held by tentacle)

+      const paletteShape = new THREE.Shape()

+      paletteShape.moveTo(0, 0)

+      paletteShape.quadraticCurveTo(0.1, 0.05, 0.12, 0)

+      paletteShape.quadraticCurveTo(0.14, -0.06, 0.08, -0.1)

+      paletteShape.quadraticCurveTo(0, -0.12, -0.08, -0.1)

+      paletteShape.quadraticCurveTo(-0.12, -0.04, -0.1, 0.02)

+      paletteShape.quadraticCurveTo(-0.06, 0.06, 0, 0)

+

+      const paletteGeom = new THREE.ExtrudeGeometry(paletteShape, {

+        steps: 1, depth: 0.015, bevelEnabled: false

+      })

+      const palette = new THREE.Mesh(paletteGeom, paletteMat)

+      palette.position.set(0.2, 0.15, 0.35)

+      palette.rotation.x = -0.5

+      palette.rotation.y = 0.3

+      group.add(palette)

+

+      // Thumb hole

+      const holeGeom = new THREE.TorusGeometry(0.02, 0.008, 4, 8)

+      const holeMat = new THREE.MeshToonMaterial({ color: 0x000000, gradientMap })

+      const hole = new THREE.Mesh(holeGeom, holeMat)

+      hole.position.set(0.12, 0.15, 0.35)

+      hole.rotation.x = -0.5 + Math.PI / 2

+      hole.rotation.z = 0.3

+      group.add(hole)

+

+      // Paint blobs on palette

+      const blobPositions = [

+        { x: 0.22, y: 0.18, z: 0.32 },

+        { x: 0.18, y: 0.17, z: 0.38 },

+        { x: 0.25, y: 0.16, z: 0.36 },

+        { x: 0.2, y: 0.19, z: 0.34 }

+      ]

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

+        const blobGeom = new THREE.SphereGeometry(0.015, 6, 4)

+        blobGeom.scale(1, 0.4, 1)

+        const blobMat = new THREE.MeshToonMaterial({ color: paintColors[i], gradientMap })

+        const blob = new THREE.Mesh(blobGeom, blobMat)

+        blob.position.set(blobPositions[i].x, blobPositions[i].y, blobPositions[i].z)

+        group.add(blob)

+      }

+

+      // Paintbrush (tiny, held)

+      const brushHandleGeom = new THREE.CylinderGeometry(0.008, 0.01, 0.12, 4)

+      const brushHandleMat = new THREE.MeshToonMaterial({ color: 0x8b4513, gradientMap })

+      const brushHandle = new THREE.Mesh(brushHandleGeom, brushHandleMat)

+      brushHandle.position.set(0.15, 0.08, 0.4)

+      brushHandle.rotation.z = 0.8

+      brushHandle.rotation.x = 0.3

+      group.add(brushHandle)

+

+      // Brush bristles

+      const bristleGeom = new THREE.ConeGeometry(0.015, 0.03, 6)

+      const bristleMat = new THREE.MeshToonMaterial({ color: 0x4444ff, gradientMap })

+      const bristles = new THREE.Mesh(bristleGeom, bristleMat)

+      bristles.position.set(0.1, 0.12, 0.42)

+      bristles.rotation.z = 0.8 + Math.PI

+      bristles.rotation.x = 0.3

+      group.add(bristles)

+