`0c90bc9`

new outfits

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 0c90bc97058a3c904deaae12673c78833d41efe1
Parents: 2b9ade3
Tree: 1a71527

2 changed files

Status	File	+	-
M	`src/renderers/three/shop/inventory.js`	18	7
M	`src/renderers/three/shop/items.js`	909	0

src/renderers/three/shop/inventory.jsmodified

    },
    // Equip an outfit to a character
 -  // Automatically unequips any other outfit of the same type
 +  // Automatically unequips any other outfit of the same type or conflicting types
    equip(character, itemId) {
      if (!this.equipped[character]) {
        this.equipped[character] = []
      const newItem = getItem(itemId)
      if (!newItem) return
 -    // Find and unequip any item of the same type
 -    const sameTypeItems = this.equipped[character].filter(equippedId => {
 +    // 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 => {
        const equippedItem = getItem(equippedId)
 -      return equippedItem && equippedItem.type === newItem.type
 +      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 items of the same type
 -    for (const oldId of sameTypeItems) {
 +    // Remove conflicting items
 +    for (const oldId of conflictingItems) {
        this.equipped[character] = this.equipped[character].filter(id => id !== oldId)
+     }
      this.save()
      // Return the unequipped items so the caller can update visuals
 -    return sameTypeItems
 +    return conflictingItems
    },
    // Unequip an outfit from a character

src/renderers/three/shop/items.jsmodified

+     }
    },
 +  // 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 - starter tier
    donny_seafoam: {
      id: 'donny_seafoam',
+     }
    },
 +  // 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
 +    }
 +  },
++
    // Ollie outfits
    ollie_coral: {
      id: 'ollie_coral',
        button2.position.set(0.44, 0.35, -0.15)
        group.add(button2)
 +      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)
++
        return group
+     }
+   }