===================================================================
--- original.js
+++ change.js
@@ -1,224 +1,1866 @@
 /**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
 * Classes
 ****/ 
-var SpawnableCreature = Container.expand(function (assetId) {
+// Animal/Object class
+var ParadeItem = Container.expand(function () {
 	var self = Container.call(this);
-	// Attach the specific asset for this creature
-	var creatureGraphics = self.attachAsset(assetId, {
+	// Attach the asset for this item
+	var asset = self.attachAsset(self.assetId, {
 		anchorX: 0.5,
-		anchorY: 1.0 // Anchor at bottom center for ground placement
+		anchorY: 1.0 // bottom center, so it "stands" on the ground
 	});
-	// Movement properties
-	self.speed = Math.random() * 2 + 0.5; // Random speed between 0.5 and 2.5
-	self.direction = Math.random() < 0.5 ? -1 : 1; // Random left or right
-	self.bounceTimer = 0;
-	self.lastX = 0;
-	// Ground area bounds (bottom 400px of screen)
-	self.groundTop = 2732 - 400;
-	self.groundBottom = 2732 - 50;
-	// Initialize position in ground area
-	self.x = Math.random() * 2048;
-	self.y = self.groundTop + Math.random() * (self.groundBottom - self.groundTop);
-	self.lastX = self.x;
+	// Movement pattern: set by type
+	self.moveType = self.moveType || "walk";
+	self.speed = self.speed || 2 + Math.random() * 2;
+	self.direction = self.direction || (Math.random() < 0.5 ? 1 : -1); // 1: right, -1: left
+	// For "hop" and "fly" types
+	self.hopTimer = 0;
+	self.flyPhase = Math.random() * Math.PI * 2;
+	// For "roll" types
+	self.spin = 0;
+	// For "wiggle" types
+	self.wigglePhase = Math.random() * Math.PI * 2;
+	// For "slide" types
+	self.slideTimer = 0;
+	// For "bounce" types
+	self.bouncePhase = Math.random() * Math.PI * 2;
+	// For "float" types
+	self.floatPhase = Math.random() * Math.PI * 2;
+	// For "crawl" types
+	self.crawlPhase = Math.random() * Math.PI * 2;
+	// For "zoom" types
+	self.zoomTimer = 0;
+	// For "spin" types
+	self.spinSpeed = 0.01 + Math.random() * 0.02;
+	// For "sway" types
+	self.swayPhase = Math.random() * Math.PI * 2;
+	// For "peek" types
+	self.peekTimer = 0;
+	self.isPeeking = false;
+	// For "pop" types
+	self.popTimer = 0;
+	self.isPopped = false;
+	// For "appear" types
+	self.appearTimer = 0;
+	self.hasAppeared = false;
+	// For "jump" types
+	self.jumpPhase = Math.random() * Math.PI * 2;
+	// For "dash" types
+	self.dashTimer = 0;
+	// For "circle" types
+	self.circlePhase = Math.random() * Math.PI * 2;
+	// For "zigzag" types
+	self.zigzagPhase = Math.random() * Math.PI * 2;
+	// For "wave" types
+	self.wavePhase = Math.random() * Math.PI * 2;
+	// For "random" types
+	self.randomTimer = 0;
+	// For "pause" types
+	self.pauseTimer = 0;
+	self.isPaused = false;
+	// For "hide" types
+	self.hideTimer = 0;
+	self.isHidden = false;
+	// For "flip" types
+	self.flipTimer = 0;
+	self.isFlipped = false;
+	// For "twirl" types
+	self.twirlPhase = Math.random() * Math.PI * 2;
+	// For "drift" types
+	self.driftPhase = Math.random() * Math.PI * 2;
+	// For "shake" types
+	self.shakePhase = Math.random() * Math.PI * 2;
+	// For "slideup" types
+	self.slideupTimer = 0;
+	// For "sprint" types
+	self.sprintTimer = 0;
+	// For "hover" types
+	self.hoverPhase = Math.random() * Math.PI * 2;
+	// For "bob" types
+	self.bobPhase = Math.random() * Math.PI * 2;
+	// For "sneak" types
+	self.sneakPhase = Math.random() * Math.PI * 2;
+	// For "stomp" types
+	self.stompPhase = Math.random() * Math.PI * 2;
+	// For "march" types
+	self.marchPhase = Math.random() * Math.PI * 2;
+	// For "slideleft" types
+	self.slideleftTimer = 0;
+	// For "slither" types
+	self.slitherPhase = Math.random() * Math.PI * 2;
+	// For "hopright" types
+	self.hoprightTimer = 0;
+	// For "hopleft" types
+	self.hopleftTimer = 0;
+	// For "jumpup" types
+	self.jumpupPhase = Math.random() * Math.PI * 2;
+	// For "jumpdown" types
+	self.jumpdownPhase = Math.random() * Math.PI * 2;
+	// For "rollright" types
+	self.rollrightSpin = 0;
+	// For "rollleft" types
+	self.rollleftSpin = 0;
+	// For "zoomright" types
+	self.zoomrightTimer = 0;
+	// For "zoomleft" types
+	self.zoomleftTimer = 0;
+	// For "bounceup" types
+	self.bounceupPhase = Math.random() * Math.PI * 2;
+	// For "bouncedown" types
+	self.bouncedownPhase = Math.random() * Math.PI * 2;
+	// For "floatup" types
+	self.floatupPhase = Math.random() * Math.PI * 2;
+	// For "floatdown" types
+	self.floatdownPhase = Math.random() * Math.PI * 2;
+	// For "peekright" types
+	self.peekrightTimer = 0;
+	// For "peekleft" types
+	self.peekleftTimer = 0;
+	// For "popright" types
+	self.poprightTimer = 0;
+	// For "popleft" types
+	self.popleftTimer = 0;
+	// For "appearleft" types
+	self.appearleftTimer = 0;
+	// For "appearright" types
+	self.appearrightTimer = 0;
+	// For "jumpright" types
+	self.jumprightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleft" types
+	self.jumpleftPhase = Math.random() * Math.PI * 2;
+	// For "dashright" types
+	self.dashrightTimer = 0;
+	// For "dashleft" types
+	self.dashleftTimer = 0;
+	// For "circleright" types
+	self.circlerightPhase = Math.random() * Math.PI * 2;
+	// For "circleleft" types
+	self.circleleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagright" types
+	self.zigzagrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleft" types
+	self.zigzagleftPhase = Math.random() * Math.PI * 2;
+	// For "waveright" types
+	self.waverightPhase = Math.random() * Math.PI * 2;
+	// For "waveleft" types
+	self.waveleftPhase = Math.random() * Math.PI * 2;
+	// For "randomright" types
+	self.randomrightTimer = 0;
+	// For "randomleft" types
+	self.randomleftTimer = 0;
+	// For "pauseright" types
+	self.pauserightTimer = 0;
+	self.isPausedRight = false;
+	// For "pauseleft" types
+	self.pauseleftTimer = 0;
+	self.isPausedLeft = false;
+	// For "hideright" types
+	self.hiderightTimer = 0;
+	self.isHiddenRight = false;
+	// For "hideleft" types
+	self.hideleftTimer = 0;
+	self.isHiddenLeft = false;
+	// For "flipright" types
+	self.fliprightTimer = 0;
+	self.isFlippedRight = false;
+	// For "flipleft" types
+	self.flipleftTimer = 0;
+	self.isFlippedLeft = false;
+	// For "twirlright" types
+	self.twirlrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleft" types
+	self.twirlleftPhase = Math.random() * Math.PI * 2;
+	// For "driftright" types
+	self.driftrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleft" types
+	self.driftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakeright" types
+	self.shakerightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleft" types
+	self.shakeleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupright" types
+	self.slideuprightTimer = 0;
+	// For "slideupleft" types
+	self.slideupleftTimer = 0;
+	// For "sprintright" types
+	self.sprintrightTimer = 0;
+	// For "sprintleft" types
+	self.sprintleftTimer = 0;
+	// For "hoverright" types
+	self.hoverrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleft" types
+	self.hoverleftPhase = Math.random() * Math.PI * 2;
+	// For "bobright" types
+	self.bobrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleft" types
+	self.bobleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakright" types
+	self.sneakrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleft" types
+	self.sneakleftPhase = Math.random() * Math.PI * 2;
+	// For "stompright" types
+	self.stomprightPhase = Math.random() * Math.PI * 2;
+	// For "stompleft" types
+	self.stompleftPhase = Math.random() * Math.PI * 2;
+	// For "marchright" types
+	self.marchrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleft" types
+	self.marchleftPhase = Math.random() * Math.PI * 2;
+	// For "slideleftright" types
+	self.slideleftrightTimer = 0;
+	// For "slitherleftright" types
+	self.slitherleftrightPhase = Math.random() * Math.PI * 2;
+	// For "hoprightright" types
+	self.hoprightrightTimer = 0;
+	// For "hopleftleft" types
+	self.hopleftleftTimer = 0;
+	// For "jumpupright" types
+	self.jumpuprightPhase = Math.random() * Math.PI * 2;
+	// For "jumpupleft" types
+	self.jumpupleftPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownright" types
+	self.jumpdownrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownleft" types
+	self.jumpdownleftPhase = Math.random() * Math.PI * 2;
+	// For "rollrightright" types
+	self.rollrightrightSpin = 0;
+	// For "rollleftleft" types
+	self.rollleftleftSpin = 0;
+	// For "zoomrightright" types
+	self.zoomrightrightTimer = 0;
+	// For "zoomleftleft" types
+	self.zoomleftleftTimer = 0;
+	// For "bounceupright" types
+	self.bounceuprightPhase = Math.random() * Math.PI * 2;
+	// For "bounceupleft" types
+	self.bounceupleftPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownright" types
+	self.bouncedownrightPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownleft" types
+	self.bouncedownleftPhase = Math.random() * Math.PI * 2;
+	// For "floatupright" types
+	self.floatuprightPhase = Math.random() * Math.PI * 2;
+	// For "floatupleft" types
+	self.floatupleftPhase = Math.random() * Math.PI * 2;
+	// For "floatdownright" types
+	self.floatdownrightPhase = Math.random() * Math.PI * 2;
+	// For "floatdownleft" types
+	self.floatdownleftPhase = Math.random() * Math.PI * 2;
+	// For "peekrightright" types
+	self.peekrightrightTimer = 0;
+	// For "peekleftleft" types
+	self.peekleftleftTimer = 0;
+	// For "poprightright" types
+	self.poprightrightTimer = 0;
+	// For "popleftleft" types
+	self.popleftleftTimer = 0;
+	// For "appearleftright" types
+	self.appearleftrightTimer = 0;
+	// For "appearrightleft" types
+	self.appearrightleftTimer = 0;
+	// For "jumprightright" types
+	self.jumprightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleftleft" types
+	self.jumpleftleftPhase = Math.random() * Math.PI * 2;
+	// For "dashrightright" types
+	self.dashrightrightTimer = 0;
+	// For "dashleftleft" types
+	self.dashleftleftTimer = 0;
+	// For "circlerightright" types
+	self.circlerightrightPhase = Math.random() * Math.PI * 2;
+	// For "circleleftleft" types
+	self.circleleftleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagrightright" types
+	self.zigzagrightrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleftleft" types
+	self.zigzagleftleftPhase = Math.random() * Math.PI * 2;
+	// For "waverightright" types
+	self.waverightrightPhase = Math.random() * Math.PI * 2;
+	// For "waveleftleft" types
+	self.waveleftleftPhase = Math.random() * Math.PI * 2;
+	// For "randomrightright" types
+	self.randomrightrightTimer = 0;
+	// For "randomleftleft" types
+	self.randomleftleftTimer = 0;
+	// For "pauserightright" types
+	self.pauserightrightTimer = 0;
+	self.isPausedRightRight = false;
+	// For "pauseleftleft" types
+	self.pauseleftleftTimer = 0;
+	self.isPausedLeftLeft = false;
+	// For "hiderightright" types
+	self.hiderightrightTimer = 0;
+	self.isHiddenRightRight = false;
+	// For "hideleftleft" types
+	self.hideleftleftTimer = 0;
+	self.isHiddenLeftLeft = false;
+	// For "fliprightright" types
+	self.fliprightrightTimer = 0;
+	self.isFlippedRightRight = false;
+	// For "flipleftleft" types
+	self.flipleftleftTimer = 0;
+	self.isFlippedLeftLeft = false;
+	// For "twirlrightright" types
+	self.twirlrightrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleftleft" types
+	self.twirlleftleftPhase = Math.random() * Math.PI * 2;
+	// For "driftrightright" types
+	self.driftrightrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleftleft" types
+	self.driftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakerightright" types
+	self.shakerightrightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleftleft" types
+	self.shakeleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupleftright" types
+	self.slideupleftrightTimer = 0;
+	// For "slideuprightleft" types
+	self.slideuprightleftTimer = 0;
+	// For "sprintrightright" types
+	self.sprintrightrightTimer = 0;
+	// For "sprintleftleft" types
+	self.sprintleftleftTimer = 0;
+	// For "hoverrightright" types
+	self.hoverrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleftleft" types
+	self.hoverleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bobrightright" types
+	self.bobrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleftleft" types
+	self.bobleftleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakrightright" types
+	self.sneakrightrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleftleft" types
+	self.sneakleftleftPhase = Math.random() * Math.PI * 2;
+	// For "stomprightright" types
+	self.stomprightrightPhase = Math.random() * Math.PI * 2;
+	// For "stompleftleft" types
+	self.stompleftleftPhase = Math.random() * Math.PI * 2;
+	// For "marchrightright" types
+	self.marchrightrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleftleft" types
+	self.marchleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideleftrightright" types
+	self.slideleftrightrightTimer = 0;
+	// For "slitherleftrightright" types
+	self.slitherleftrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoprightrightright" types
+	self.hoprightrightrightTimer = 0;
+	// For "hopleftleftleft" types
+	self.hopleftleftleftTimer = 0;
+	// For "jumpuprightright" types
+	self.jumpuprightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpupleftleft" types
+	self.jumpupleftleftPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownrightright" types
+	self.jumpdownrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownleftleft" types
+	self.jumpdownleftleftPhase = Math.random() * Math.PI * 2;
+	// For "rollrightrightright" types
+	self.rollrightrightrightSpin = 0;
+	// For "rollleftleftleft" types
+	self.rollleftleftleftSpin = 0;
+	// For "zoomrightrightright" types
+	self.zoomrightrightrightTimer = 0;
+	// For "zoomleftleftleft" types
+	self.zoomleftleftleftTimer = 0;
+	// For "bounceuprightright" types
+	self.bounceuprightrightPhase = Math.random() * Math.PI * 2;
+	// For "bounceupleftleft" types
+	self.bounceupleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownrightright" types
+	self.bouncedownrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownleftleft" types
+	self.bouncedownleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatuprightright" types
+	self.floatuprightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatupleftleft" types
+	self.floatupleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatdownrightright" types
+	self.floatdownrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatdownleftleft" types
+	self.floatdownleftleftPhase = Math.random() * Math.PI * 2;
+	// For "peekrightrightright" types
+	self.peekrightrightrightTimer = 0;
+	// For "peekleftleftleft" types
+	self.peekleftleftleftTimer = 0;
+	// For "poprightrightright" types
+	self.poprightrightrightTimer = 0;
+	// For "popleftleftleft" types
+	self.popleftleftleftTimer = 0;
+	// For "appearleftrightright" types
+	self.appearleftrightrightTimer = 0;
+	// For "appearrightleftleft" types
+	self.appearrightleftleftTimer = 0;
+	// For "jumprightrightright" types
+	self.jumprightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleftleftleft" types
+	self.jumpleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "dashrightrightright" types
+	self.dashrightrightrightTimer = 0;
+	// For "dashleftleftleft" types
+	self.dashleftleftleftTimer = 0;
+	// For "circlerightrightright" types
+	self.circlerightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "circleleftleftleft" types
+	self.circleleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagrightrightright" types
+	self.zigzagrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleftleftleft" types
+	self.zigzagleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "waverightrightright" types
+	self.waverightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "waveleftleftleft" types
+	self.waveleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "randomrightrightright" types
+	self.randomrightrightrightTimer = 0;
+	// For "randomleftleftleft" types
+	self.randomleftleftleftTimer = 0;
+	// For "pauserightrightright" types
+	self.pauserightrightrightTimer = 0;
+	self.isPausedRightRightRight = false;
+	// For "pauseleftleftleft" types
+	self.pauseleftleftleftTimer = 0;
+	self.isPausedLeftLeftLeft = false;
+	// For "hiderightrightright" types
+	self.hiderightrightrightTimer = 0;
+	self.isHiddenRightRightRight = false;
+	// For "hideleftleftleft" types
+	self.hideleftleftleftTimer = 0;
+	self.isHiddenLeftLeftLeft = false;
+	// For "fliprightrightright" types
+	self.fliprightrightrightTimer = 0;
+	self.isFlippedRightRightRight = false;
+	// For "flipleftleftleft" types
+	self.flipleftleftleftTimer = 0;
+	self.isFlippedLeftLeftLeft = false;
+	// For "twirlrightrightright" types
+	self.twirlrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleftleftleft" types
+	self.twirlleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "driftrightrightright" types
+	self.driftrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleftleftleft" types
+	self.driftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakerightrightright" types
+	self.shakerightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleftleftleft" types
+	self.shakeleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupleftrightright" types
+	self.slideupleftrightrightTimer = 0;
+	// For "slideuprightleftleft" types
+	self.slideuprightleftleftTimer = 0;
+	// For "sprintrightrightright" types
+	self.sprintrightrightrightTimer = 0;
+	// For "sprintleftleftleft" types
+	self.sprintleftleftleftTimer = 0;
+	// For "hoverrightrightright" types
+	self.hoverrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleftleftleft" types
+	self.hoverleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bobrightrightright" types
+	self.bobrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleftleftleft" types
+	self.bobleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakrightrightright" types
+	self.sneakrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleftleftleft" types
+	self.sneakleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "stomprightrightright" types
+	self.stomprightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "stompleftleftleft" types
+	self.stompleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "marchrightrightright" types
+	self.marchrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleftleftleft" types
+	self.marchleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideleftrightrightright" types
+	self.slideleftrightrightrightTimer = 0;
+	// For "slitherleftrightrightright" types
+	self.slitherleftrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoprightrightrightright" types
+	self.hoprightrightrightrightTimer = 0;
+	// For "hopleftleftleftleft" types
+	self.hopleftleftleftleftTimer = 0;
+	// For "jumpuprightrightright" types
+	self.jumpuprightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpupleftleftleft" types
+	self.jumpupleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownrightrightright" types
+	self.jumpdownrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownleftleftleft" types
+	self.jumpdownleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "rollrightrightrightright" types
+	self.rollrightrightrightrightSpin = 0;
+	// For "rollleftleftleftleft" types
+	self.rollleftleftleftleftSpin = 0;
+	// For "zoomrightrightrightright" types
+	self.zoomrightrightrightrightTimer = 0;
+	// For "zoomleftleftleftleft" types
+	self.zoomleftleftleftleftTimer = 0;
+	// For "bounceuprightrightright" types
+	self.bounceuprightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bounceupleftleftleft" types
+	self.bounceupleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownrightrightright" types
+	self.bouncedownrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownleftleftleft" types
+	self.bouncedownleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatuprightrightright" types
+	self.floatuprightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatupleftleftleft" types
+	self.floatupleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatdownrightrightright" types
+	self.floatdownrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatdownleftleftleft" types
+	self.floatdownleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "peekrightrightrightright" types
+	self.peekrightrightrightrightTimer = 0;
+	// For "peekleftleftleftleft" types
+	self.peekleftleftleftleftTimer = 0;
+	// For "poprightrightrightright" types
+	self.poprightrightrightrightTimer = 0;
+	// For "popleftleftleftleft" types
+	self.popleftleftleftleftTimer = 0;
+	// For "appearleftrightrightright" types
+	self.appearleftrightrightrightTimer = 0;
+	// For "appearrightleftleftleft" types
+	self.appearrightleftleftleftTimer = 0;
+	// For "jumprightrightrightright" types
+	self.jumprightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleftleftleftleft" types
+	self.jumpleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "dashrightrightrightright" types
+	self.dashrightrightrightrightTimer = 0;
+	// For "dashleftleftleftleft" types
+	self.dashleftleftleftleftTimer = 0;
+	// For "circlerightrightrightright" types
+	self.circlerightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "circleleftleftleftleft" types
+	self.circleleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagrightrightrightright" types
+	self.zigzagrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleftleftleftleft" types
+	self.zigzagleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "waverightrightrightright" types
+	self.waverightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "waveleftleftleftleft" types
+	self.waveleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "randomrightrightrightright" types
+	self.randomrightrightrightrightTimer = 0;
+	// For "randomleftleftleftleft" types
+	self.randomleftleftleftleftTimer = 0;
+	// For "pauserightrightrightright" types
+	self.pauserightrightrightrightTimer = 0;
+	self.isPausedRightRightRightRight = false;
+	// For "pauseleftleftleftleft" types
+	self.pauseleftleftleftleftTimer = 0;
+	self.isPausedLeftLeftLeftLeft = false;
+	// For "hiderightrightrightright" types
+	self.hiderightrightrightrightTimer = 0;
+	self.isHiddenRightRightRightRight = false;
+	// For "hideleftleftleftleft" types
+	self.hideleftleftleftleftTimer = 0;
+	self.isHiddenLeftLeftLeftLeft = false;
+	// For "fliprightrightrightright" types
+	self.fliprightrightrightrightTimer = 0;
+	self.isFlippedRightRightRightRight = false;
+	// For "flipleftleftleftleft" types
+	self.flipleftleftleftleftTimer = 0;
+	self.isFlippedLeftLeftLeftLeft = false;
+	// For "twirlrightrightrightright" types
+	self.twirlrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleftleftleftleft" types
+	self.twirlleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "driftrightrightrightright" types
+	self.driftrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleftleftleftleft" types
+	self.driftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakerightrightrightright" types
+	self.shakerightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleftleftleftleft" types
+	self.shakeleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupleftrightrightright" types
+	self.slideupleftrightrightrightTimer = 0;
+	// For "slideuprightleftleftleft" types
+	self.slideuprightleftleftleftTimer = 0;
+	// For "sprintrightrightrightright" types
+	self.sprintrightrightrightrightTimer = 0;
+	// For "sprintleftleftleftleft" types
+	self.sprintleftleftleftleftTimer = 0;
+	// For "hoverrightrightrightright" types
+	self.hoverrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleftleftleftleft" types
+	self.hoverleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bobrightrightrightright" types
+	self.bobrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleftleftleftleft" types
+	self.bobleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakrightrightrightright" types
+	self.sneakrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleftleftleftleft" types
+	self.sneakleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "stomprightrightrightright" types
+	self.stomprightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "stompleftleftleftleft" types
+	self.stompleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "marchrightrightrightright" types
+	self.marchrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleftleftleftleft" types
+	self.marchleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideleftrightrightrightright" types
+	self.slideleftrightrightrightrightTimer = 0;
+	// For "slitherleftrightrightrightright" types
+	self.slitherleftrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoprightrightrightrightright" types
+	self.hoprightrightrightrightrightTimer = 0;
+	// For "hopleftleftleftleftleft" types
+	self.hopleftleftleftleftleftTimer = 0;
+	// For "jumpuprightrightrightright" types
+	self.jumpuprightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpupleftleftleftleft" types
+	self.jumpupleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownrightrightrightright" types
+	self.jumpdownrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownleftleftleftleft" types
+	self.jumpdownleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "rollrightrightrightrightright" types
+	self.rollrightrightrightrightrightSpin = 0;
+	// For "rollleftleftleftleftleft" types
+	self.rollleftleftleftleftleftSpin = 0;
+	// For "zoomrightrightrightrightright" types
+	self.zoomrightrightrightrightrightTimer = 0;
+	// For "zoomleftleftleftleftleft" types
+	self.zoomleftleftleftleftleftTimer = 0;
+	// For "bounceuprightrightrightright" types
+	self.bounceuprightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bounceupleftleftleftleft" types
+	self.bounceupleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownrightrightrightright" types
+	self.bouncedownrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownleftleftleftleft" types
+	self.bouncedownleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatuprightrightrightright" types
+	self.floatuprightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatupleftleftleftleft" types
+	self.floatupleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatdownrightrightrightright" types
+	self.floatdownrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatdownleftleftleftleft" types
+	self.floatdownleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "peekrightrightrightrightright" types
+	self.peekrightrightrightrightrightTimer = 0;
+	// For "peekleftleftleftleftleft" types
+	self.peekleftleftleftleftleftTimer = 0;
+	// For "poprightrightrightrightright" types
+	self.poprightrightrightrightrightTimer = 0;
+	// For "popleftleftleftleftleft" types
+	self.popleftleftleftleftleftTimer = 0;
+	// For "appearleftrightrightrightright" types
+	self.appearleftrightrightrightrightTimer = 0;
+	// For "appearrightleftleftleftleft" types
+	self.appearrightleftleftleftleftTimer = 0;
+	// For "jumprightrightrightrightright" types
+	self.jumprightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleftleftleftleftleft" types
+	self.jumpleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "dashrightrightrightrightright" types
+	self.dashrightrightrightrightrightTimer = 0;
+	// For "dashleftleftleftleftleft" types
+	self.dashleftleftleftleftleftTimer = 0;
+	// For "circlerightrightrightrightright" types
+	self.circlerightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "circleleftleftleftleftleft" types
+	self.circleleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagrightrightrightrightright" types
+	self.zigzagrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleftleftleftleftleft" types
+	self.zigzagleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "waverightrightrightrightright" types
+	self.waverightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "waveleftleftleftleftleft" types
+	self.waveleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "randomrightrightrightrightright" types
+	self.randomrightrightrightrightrightTimer = 0;
+	// For "randomleftleftleftleftleft" types
+	self.randomleftleftleftleftleftTimer = 0;
+	// For "pauserightrightrightrightright" types
+	self.pauserightrightrightrightrightTimer = 0;
+	self.isPausedRightRightRightRightRight = false;
+	// For "pauseleftleftleftleftleft" types
+	self.pauseleftleftleftleftleftTimer = 0;
+	self.isPausedLeftLeftLeftLeftLeft = false;
+	// For "hiderightrightrightrightright" types
+	self.hiderightrightrightrightrightTimer = 0;
+	self.isHiddenRightRightRightRightRight = false;
+	// For "hideleftleftleftleftleft" types
+	self.hideleftleftleftleftleftTimer = 0;
+	self.isHiddenLeftLeftLeftLeftLeft = false;
+	// For "fliprightrightrightrightright" types
+	self.fliprightrightrightrightrightTimer = 0;
+	self.isFlippedRightRightRightRightRight = false;
+	// For "flipleftleftleftleftleft" types
+	self.flipleftleftleftleftleftTimer = 0;
+	self.isFlippedLeftLeftLeftLeftLeft = false;
+	// For "twirlrightrightrightrightright" types
+	self.twirlrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleftleftleftleftleft" types
+	self.twirlleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "driftrightrightrightrightright" types
+	self.driftrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleftleftleftleftleft" types
+	self.driftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakerightrightrightrightright" types
+	self.shakerightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleftleftleftleftleft" types
+	self.shakeleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupleftrightrightrightright" types
+	self.slideupleftrightrightrightrightTimer = 0;
+	// For "slideuprightleftleftleftleft" types
+	self.slideuprightleftleftleftleftTimer = 0;
+	// For "sprintrightrightrightrightright" types
+	self.sprintrightrightrightrightrightTimer = 0;
+	// For "sprintleftleftleftleftleft" types
+	self.sprintleftleftleftleftleftTimer = 0;
+	// For "hoverrightrightrightrightright" types
+	self.hoverrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleftleftleftleftleft" types
+	self.hoverleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bobrightrightrightrightright" types
+	self.bobrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleftleftleftleftleft" types
+	self.bobleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakrightrightrightrightright" types
+	self.sneakrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleftleftleftleftleft" types
+	self.sneakleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "stomprightrightrightrightright" types
+	self.stomprightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "stompleftleftleftleftleft" types
+	self.stompleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "marchrightrightrightrightright" types
+	self.marchrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleftleftleftleftleft" types
+	self.marchleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideleftrightrightrightrightright" types
+	self.slideleftrightrightrightrightrightTimer = 0;
+	// For "slitherleftrightrightrightrightright" types
+	self.slitherleftrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoprightrightrightrightrightright" types
+	self.hoprightrightrightrightrightrightTimer = 0;
+	// For "hopleftleftleftleftleftleft" types
+	self.hopleftleftleftleftleftleftTimer = 0;
+	// For "jumpuprightrightrightrightright" types
+	self.jumpuprightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpupleftleftleftleftleft" types
+	self.jumpupleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownrightrightrightrightright" types
+	self.jumpdownrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownleftleftleftleftleft" types
+	self.jumpdownleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "rollrightrightrightrightrightright" types
+	self.rollrightrightrightrightrightrightSpin = 0;
+	// For "rollleftleftleftleftleftleft" types
+	self.rollleftleftleftleftleftleftSpin = 0;
+	// For "zoomrightrightrightrightrightright" types
+	self.zoomrightrightrightrightrightrightTimer = 0;
+	// For "zoomleftleftleftleftleftleft" types
+	self.zoomleftleftleftleftleftleftTimer = 0;
+	// For "bounceuprightrightrightrightright" types
+	self.bounceuprightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bounceupleftleftleftleftleft" types
+	self.bounceupleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownrightrightrightrightright" types
+	self.bouncedownrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownleftleftleftleftleft" types
+	self.bouncedownleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatuprightrightrightrightright" types
+	self.floatuprightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatupleftleftleftleftleft" types
+	self.floatupleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatdownrightrightrightrightright" types
+	self.floatdownrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatdownleftleftleftleftleft" types
+	self.floatdownleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "peekrightrightrightrightrightright" types
+	self.peekrightrightrightrightrightrightTimer = 0;
+	// For "peekleftleftleftleftleftleft" types
+	self.peekleftleftleftleftleftleftTimer = 0;
+	// For "poprightrightrightrightrightright" types
+	self.poprightrightrightrightrightrightTimer = 0;
+	// For "popleftleftleftleftleftleft" types
+	self.popleftleftleftleftleftleftTimer = 0;
+	// For "appearleftrightrightrightrightright" types
+	self.appearleftrightrightrightrightrightTimer = 0;
+	// For "appearrightleftleftleftleftleft" types
+	self.appearrightleftleftleftleftleftTimer = 0;
+	// For "jumprightrightrightrightrightright" types
+	self.jumprightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleftleftleftleftleftleft" types
+	self.jumpleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "dashrightrightrightrightrightright" types
+	self.dashrightrightrightrightrightrightTimer = 0;
+	// For "dashleftleftleftleftleftleft" types
+	self.dashleftleftleftleftleftleftTimer = 0;
+	// For "circlerightrightrightrightrightright" types
+	self.circlerightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "circleleftleftleftleftleftleft" types
+	self.circleleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagrightrightrightrightrightright" types
+	self.zigzagrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleftleftleftleftleftleft" types
+	self.zigzagleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "waverightrightrightrightrightright" types
+	self.waverightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "waveleftleftleftleftleftleft" types
+	self.waveleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "randomrightrightrightrightrightright" types
+	self.randomrightrightrightrightrightrightTimer = 0;
+	// For "randomleftleftleftleftleftleft" types
+	self.randomleftleftleftleftleftleftTimer = 0;
+	// For "pauserightrightrightrightrightright" types
+	self.pauserightrightrightrightrightrightTimer = 0;
+	self.isPausedRightRightRightRightRightRight = false;
+	// For "pauseleftleftleftleftleftleft" types
+	self.pauseleftleftleftleftleftleftTimer = 0;
+	self.isPausedLeftLeftLeftLeftLeftLeft = false;
+	// For "hiderightrightrightrightrightright" types
+	self.hiderightrightrightrightrightrightTimer = 0;
+	self.isHiddenRightRightRightRightRightRight = false;
+	// For "hideleftleftleftleftleftleft" types
+	self.hideleftleftleftleftleftleftTimer = 0;
+	self.isHiddenLeftLeftLeftLeftLeftLeft = false;
+	// For "fliprightrightrightrightrightright" types
+	self.fliprightrightrightrightrightrightTimer = 0;
+	self.isFlippedRightRightRightRightRightRight = false;
+	// For "flipleftleftleftleftleftleft" types
+	self.flipleftleftleftleftleftleftTimer = 0;
+	self.isFlippedLeftLeftLeftLeftLeftLeft = false;
+	// For "twirlrightrightrightrightrightright" types
+	self.twirlrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleftleftleftleftleftleft" types
+	self.twirlleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "driftrightrightrightrightrightright" types
+	self.driftrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleftleftleftleftleftleft" types
+	self.driftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakerightrightrightrightrightright" types
+	self.shakerightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleftleftleftleftleftleft" types
+	self.shakeleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupleftrightrightrightrightright" types
+	self.slideupleftrightrightrightrightrightTimer = 0;
+	// For "slideuprightleftleftleftleftleft" types
+	self.slideuprightleftleftleftleftleftTimer = 0;
+	// For "sprintrightrightrightrightrightright" types
+	self.sprintrightrightrightrightrightrightTimer = 0;
+	// For "sprintleftleftleftleftleftleft" types
+	self.sprintleftleftleftleftleftleftTimer = 0;
+	// For "hoverrightrightrightrightrightright" types
+	self.hoverrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleftleftleftleftleftleft" types
+	self.hoverleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bobrightrightrightrightrightright" types
+	self.bobrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleftleftleftleftleftleft" types
+	self.bobleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakrightrightrightrightrightright" types
+	self.sneakrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleftleftleftleftleftleft" types
+	self.sneakleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "stomprightrightrightrightrightright" types
+	self.stomprightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "stompleftleftleftleftleftleft" types
+	self.stompleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "marchrightrightrightrightrightright" types
+	self.marchrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleftleftleftleftleftleft" types
+	self.marchleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideleftrightrightrightrightrightright" types
+	self.slideleftrightrightrightrightrightrightTimer = 0;
+	// For "slitherleftrightrightrightrightrightright" types
+	self.slitherleftrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoprightrightrightrightrightrightright" types
+	self.hoprightrightrightrightrightrightrightTimer = 0;
+	// For "hopleftleftleftleftleftleftleft" types
+	self.hopleftleftleftleftleftleftleftTimer = 0;
+	// For "jumpuprightrightrightrightrightright" types
+	self.jumpuprightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpupleftleftleftleftleftleft" types
+	self.jumpupleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownrightrightrightrightrightright" types
+	self.jumpdownrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownleftleftleftleftleftleft" types
+	self.jumpdownleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "rollrightrightrightrightrightrightright" types
+	self.rollrightrightrightrightrightrightrightSpin = 0;
+	// For "rollleftleftleftleftleftleftleft" types
+	self.rollleftleftleftleftleftleftleftSpin = 0;
+	// For "zoomrightrightrightrightrightrightright" types
+	self.zoomrightrightrightrightrightrightrightTimer = 0;
+	// For "zoomleftleftleftleftleftleftleft" types
+	self.zoomleftleftleftleftleftleftleftTimer = 0;
+	// For "bounceuprightrightrightrightrightright" types
+	self.bounceuprightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bounceupleftleftleftleftleftleft" types
+	self.bounceupleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownrightrightrightrightrightright" types
+	self.bouncedownrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownleftleftleftleftleftleft" types
+	self.bouncedownleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatuprightrightrightrightrightright" types
+	self.floatuprightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatupleftleftleftleftleftleft" types
+	self.floatupleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatdownrightrightrightrightrightright" types
+	self.floatdownrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatdownleftleftleftleftleftleft" types
+	self.floatdownleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "peekrightrightrightrightrightrightright" types
+	self.peekrightrightrightrightrightrightrightTimer = 0;
+	// For "peekleftleftleftleftleftleftleft" types
+	self.peekleftleftleftleftleftleftleftTimer = 0;
+	// For "poprightrightrightrightrightrightright" types
+	self.poprightrightrightrightrightrightrightTimer = 0;
+	// For "popleftleftleftleftleftleftleft" types
+	self.popleftleftleftleftleftleftleftTimer = 0;
+	// For "appearleftrightrightrightrightrightright" types
+	self.appearleftrightrightrightrightrightrightTimer = 0;
+	// For "appearrightleftleftleftleftleftleft" types
+	self.appearrightleftleftleftleftleftleftTimer = 0;
+	// For "jumprightrightrightrightrightrightright" types
+	self.jumprightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleftleftleftleftleftleftleft" types
+	self.jumpleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "dashrightrightrightrightrightrightright" types
+	self.dashrightrightrightrightrightrightrightTimer = 0;
+	// For "dashleftleftleftleftleftleftleft" types
+	self.dashleftleftleftleftleftleftleftTimer = 0;
+	// For "circlerightrightrightrightrightrightright" types
+	self.circlerightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "circleleftleftleftleftleftleftleft" types
+	self.circleleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagrightrightrightrightrightrightright" types
+	self.zigzagrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleftleftleftleftleftleftleft" types
+	self.zigzagleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "waverightrightrightrightrightrightright" types
+	self.waverightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "waveleftleftleftleftleftleftleft" types
+	self.waveleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "randomrightrightrightrightrightrightright" types
+	self.randomrightrightrightrightrightrightrightTimer = 0;
+	// For "randomleftleftleftleftleftleftleft" types
+	self.randomleftleftleftleftleftleftleftTimer = 0;
+	// For "pauserightrightrightrightrightrightright" types
+	self.pauserightrightrightrightrightrightrightTimer = 0;
+	self.isPausedRightRightRightRightRightRightRight = false;
+	// For "pauseleftleftleftleftleftleftleft" types
+	self.pauseleftleftleftleftleftleftleftTimer = 0;
+	self.isPausedLeftLeftLeftLeftLeftLeftLeft = false;
+	// For "hiderightrightrightrightrightrightright" types
+	self.hiderightrightrightrightrightrightrightTimer = 0;
+	self.isHiddenRightRightRightRightRightRightRight = false;
+	// For "hideleftleftleftleftleftleftleft" types
+	self.hideleftleftleftleftleftleftleftTimer = 0;
+	self.isHiddenLeftLeftLeftLeftLeftLeftLeft = false;
+	// For "fliprightrightrightrightrightrightright" types
+	self.fliprightrightrightrightrightrightrightTimer = 0;
+	self.isFlippedRightRightRightRightRightRightRight = false;
+	// For "flipleftleftleftleftleftleftleft" types
+	self.flipleftleftleftleftleftleftleftTimer = 0;
+	self.isFlippedLeftLeftLeftLeftLeftLeftLeft = false;
+	// For "twirlrightrightrightrightrightrightright" types
+	self.twirlrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleftleftleftleftleftleftleft" types
+	self.twirlleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "driftrightrightrightrightrightrightright" types
+	self.driftrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleftleftleftleftleftleftleft" types
+	self.driftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakerightrightrightrightrightrightright" types
+	self.shakerightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleftleftleftleftleftleftleft" types
+	self.shakeleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupleftrightrightrightrightrightright" types
+	self.slideupleftrightrightrightrightrightrightTimer = 0;
+	// For "slideuprightleftleftleftleftleftleft" types
+	self.slideuprightleftleftleftleftleftleftTimer = 0;
+	// For "sprintrightrightrightrightrightrightright" types
+	self.sprintrightrightrightrightrightrightrightTimer = 0;
+	// For "sprintleftleftleftleftleftleftleft" types
+	self.sprintleftleftleftleftleftleftleftTimer = 0;
+	// For "hoverrightrightrightrightrightrightright" types
+	self.hoverrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleftleftleftleftleftleftleft" types
+	self.hoverleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bobrightrightrightrightrightrightright" types
+	self.bobrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleftleftleftleftleftleftleft" types
+	self.bobleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakrightrightrightrightrightrightright" types
+	self.sneakrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleftleftleftleftleftleftleft" types
+	self.sneakleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "stomprightrightrightrightrightrightright" types
+	self.stomprightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "stompleftleftleftleftleftleftleft" types
+	self.stompleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "marchrightrightrightrightrightrightright" types
+	self.marchrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleftleftleftleftleftleftleft" types
+	self.marchleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideleftrightrightrightrightrightrightright" types
+	self.slideleftrightrightrightrightrightrightrightTimer = 0;
+	// For "slitherleftrightrightrightrightrightrightright" types
+	self.slitherleftrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoprightrightrightrightrightrightrightright" types
+	self.hoprightrightrightrightrightrightrightrightTimer = 0;
+	// For "hopleftleftleftleftleftleftleftleft" types
+	self.hopleftleftleftleftleftleftleftleftTimer = 0;
+	// For "jumpuprightrightrightrightrightrightright" types
+	self.jumpuprightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpupleftleftleftleftleftleftleft" types
+	self.jumpupleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownrightrightrightrightrightrightright" types
+	self.jumpdownrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpdownleftleftleftleftleftleftleft" types
+	self.jumpdownleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "rollrightrightrightrightrightrightrightright" types
+	self.rollrightrightrightrightrightrightrightrightSpin = 0;
+	// For "rollleftleftleftleftleftleftleftleft" types
+	self.rollleftleftleftleftleftleftleftleftSpin = 0;
+	// For "zoomrightrightrightrightrightrightrightright" types
+	self.zoomrightrightrightrightrightrightrightrightTimer = 0;
+	// For "zoomleftleftleftleftleftleftleftleft" types
+	self.zoomleftleftleftleftleftleftleftleftTimer = 0;
+	// For "bounceuprightrightrightrightrightrightright" types
+	self.bounceuprightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bounceupleftleftleftleftleftleftleft" types
+	self.bounceupleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownrightrightrightrightrightrightright" types
+	self.bouncedownrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bouncedownleftleftleftleftleftleftleft" types
+	self.bouncedownleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatuprightrightrightrightrightrightright" types
+	self.floatuprightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatupleftleftleftleftleftleftleft" types
+	self.floatupleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "floatdownrightrightrightrightrightrightright" types
+	self.floatdownrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "floatdownleftleftleftleftleftleftleft" types
+	self.floatdownleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "peekrightrightrightrightrightrightrightright" types
+	self.peekrightrightrightrightrightrightrightrightTimer = 0;
+	// For "peekleftleftleftleftleftleftleftleft" types
+	self.peekleftleftleftleftleftleftleftleftTimer = 0;
+	// For "poprightrightrightrightrightrightrightright" types
+	self.poprightrightrightrightrightrightrightrightTimer = 0;
+	// For "popleftleftleftleftleftleftleftleft" types
+	self.popleftleftleftleftleftleftleftleftTimer = 0;
+	// For "appearleftrightrightrightrightrightright" types
+	self.appearleftrightrightrightrightrightrightrightTimer = 0;
+	// For "appearrightleftleftleftleftleftleftleft" types
+	self.appearrightleftleftleftleftleftleftleftTimer = 0;
+	// For "jumprightrightrightrightrightrightrightright" types
+	self.jumprightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "jumpleftleftleftleftleftleftleftleft" types
+	self.jumpleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "dashrightrightrightrightrightrightrightright" types
+	self.dashrightrightrightrightrightrightrightrightTimer = 0;
+	// For "dashleftleftleftleftleftleftleftleft" types
+	self.dashleftleftleftleftleftleftleftleftTimer = 0;
+	// For "circlerightrightrightrightrightrightrightright" types
+	self.circlerightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "circleleftleftleftleftleftleftleftleft" types
+	self.circleleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "zigzagrightrightrightrightrightrightrightright" types
+	self.zigzagrightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "zigzagleftleftleftleftleftleftleftleft" types
+	self.zigzagleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "waverightrightrightrightrightrightrightright" types
+	self.waverightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "waveleftleftleftleftleftleftleftleft" types
+	self.waveleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "randomrightrightrightrightrightrightrightright" types
+	self.randomrightrightrightrightrightrightrightrightTimer = 0;
+	// For "randomleftleftleftleftleftleftleftleft" types
+	self.randomleftleftleftleftleftleftleftleftTimer = 0;
+	// For "pauserightrightrightrightrightrightrightright" types
+	self.pauserightrightrightrightrightrightrightrightTimer = 0;
+	self.isPausedRightRightRightRightRightRightRightRight = false;
+	// For "pauseleftleftleftleftleftleftleftleft" types
+	self.pauseleftleftleftleftleftleftleftleftTimer = 0;
+	self.isPausedLeftLeftLeftLeftLeftLeftLeftLeft = false;
+	// For "hiderightrightrightrightrightrightrightright" types
+	self.hiderightrightrightrightrightrightrightrightTimer = 0;
+	self.isHiddenRightRightRightRightRightRightRightRight = false;
+	// For "hideleftleftleftleftleftleftleftleft" types
+	self.hideleftleftleftleftleftleftleftleftTimer = 0;
+	self.isHiddenLeftLeftLeftLeftLeftLeftLeftLeft = false;
+	// For "fliprightrightrightrightrightrightrightright" types
+	self.fliprightrightrightrightrightrightrightrightTimer = 0;
+	self.isFlippedRightRightRightRightRightRightRightRight = false;
+	// For "flipleftleftleftleftleftleftleftleft" types
+	self.flipleftleftleftleftleftleftleftleftTimer = 0;
+	self.isFlippedLeftLeftLeftLeftLeftLeftLeftLeft = false;
+	// For "twirlrightrightrightrightrightrightrightright" types
+	self.twirlrightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "twirlleftleftleftleftleftleftleftleft" types
+	self.twirlleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "driftrightrightrightrightrightrightrightright" types
+	self.driftrightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "driftleftleftleftleftleftleftleftleft" types
+	self.driftleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "shakerightrightrightrightrightrightrightright" types
+	self.shakerightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "shakeleftleftleftleftleftleftleftleft" types
+	self.shakeleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "slideupleftrightrightrightrightrightrightright" types
+	self.slideupleftrightrightrightrightrightrightrightTimer = 0;
+	// For "slideuprightleftleftleftleftleftleftleft" types
+	self.slideuprightleftleftleftleftleftleftleftTimer = 0;
+	// For "sprintrightrightrightrightrightrightrightright" types
+	self.sprintrightrightrightrightrightrightrightrightTimer = 0;
+	// For "sprintleftleftleftleftleftleftleftleft" types
+	self.sprintleftleftleftleftleftleftleftleftTimer = 0;
+	// For "hoverrightrightrightrightrightrightrightright" types
+	self.hoverrightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "hoverleftleftleftleftleftleftleftleft" types
+	self.hoverleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "bobrightrightrightrightrightrightrightright" types
+	self.bobrightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "bobleftleftleftleftleftleftleftleft" types
+	self.bobleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "sneakrightrightrightrightrightrightrightright" types
+	self.sneakrightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "sneakleftleftleftleftleftleftleftleft" types
+	self.sneakleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "stomprightrightrightrightrightrightrightright" types
+	self.stomprightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "stompleftleftleftleftleftleftleftleft" types
+	self.stompleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// For "marchrightrightrightrightrightrightrightright" types
+	self.marchrightrightrightrightrightrightrightrightPhase = Math.random() * Math.PI * 2;
+	// For "marchleftleftleftleftleftleftleftleft" types
+	self.marchleftleftleftleftleftleftleftleftPhase = Math.random() * Math.PI * 2;
+	// Movement update
 	self.update = function () {
-		// Move horizontally
-		self.x += self.direction * self.speed;
-		// Bounce off screen edges
-		if (self.lastX >= 0 && self.x < 0) {
-			self.direction = 1;
-			self.x = 0;
+		// Only move if not paused/hidden
+		if (self.isHidden) return;
+		// Movement patterns
+		var t = LK.ticks;
+		var baseY = self.baseY || self.y;
+		var baseX = self.baseX || self.x;
+		if (self.moveType === "walk") {
+			self.x += self.speed * self.direction;
+			// Bounce off edges
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "hop") {
+			self.x += self.speed * self.direction;
+			self.hopTimer += 1;
+			self.y = baseY - Math.abs(Math.sin(self.hopTimer * 0.1)) * 60;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "fly") {
+			self.x += self.speed * self.direction;
+			self.y = baseY - Math.sin(t * 0.05 + self.flyPhase) * 80;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "roll") {
+			self.x += self.speed * self.direction;
+			asset.rotation += 0.1 * self.direction;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "wiggle") {
+			self.x += self.speed * self.direction;
+			asset.y = Math.sin(t * 0.2 + self.wigglePhase) * 10;
+			asset.rotation = Math.sin(t * 0.1 + self.wigglePhase) * 0.2;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "slide") {
+			self.slideTimer += 1;
+			self.x += self.speed * self.direction * (Math.abs(Math.sin(self.slideTimer * 0.05)) + 0.5);
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "bounce") {
+			self.x += self.speed * self.direction;
+			self.y = baseY - Math.abs(Math.sin(t * 0.15 + self.bouncePhase)) * 40;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "float") {
+			self.x += self.speed * self.direction * 0.5;
+			self.y = baseY - Math.sin(t * 0.07 + self.floatPhase) * 30;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "crawl") {
+			self.x += self.speed * self.direction * 0.7;
+			asset.y = Math.sin(t * 0.25 + self.crawlPhase) * 5;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "zoom") {
+			self.zoomTimer += 1;
+			self.x += self.speed * self.direction * (1 + Math.abs(Math.sin(self.zoomTimer * 0.2)));
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "spin") {
+			self.x += self.speed * self.direction * 0.8;
+			asset.rotation += self.spinSpeed * self.direction;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "sway") {
+			self.x += self.speed * self.direction * 0.6;
+			asset.x = Math.sin(t * 0.15 + self.swayPhase) * 20;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "wave") {
+			self.x += self.speed * self.direction * 0.7;
+			self.y = baseY - Math.sin(t * 0.12 + self.wavePhase) * 25;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else if (self.moveType === "zigzag") {
+			self.x += self.speed * self.direction;
+			self.y = baseY + Math.sin(t * 0.18 + self.zigzagPhase) * 40;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
+		} else {
+			// Default: walk
+			self.x += self.speed * self.direction;
+			if (self.x < self.width / 2) {
+				self.x = self.width / 2;
+				self.direction = 1;
+			}
+			if (self.x > 2048 - self.width / 2) {
+				self.x = 2048 - self.width / 2;
+				self.direction = -1;
+			}
 		}
-		if (self.lastX <= 2048 && self.x > 2048) {
-			self.direction = -1;
-			self.x = 2048;
-		}
-		// Random direction changes
-		self.bounceTimer++;
-		if (self.bounceTimer > 120 + Math.random() * 240) {
-			// Every 2-6 seconds
-			self.direction *= -1;
-			self.bounceTimer = 0;
-		}
-		// Update last position
-		self.lastX = self.x;
 	};
 	return self;
 });
 
 /**** 
 * Initialize Game
 ****/ 
-// List of all 30 spawnable words
 var game = new LK.Game({
-	backgroundColor: 0x87CEEB // Sky blue background
+	backgroundColor: 0x8fd97b // Grassy green
 });
 
 /**** 
 * Game Code
 ****/ 
-// List of all 30 spawnable words
-// Initialize 30 spawnable animals and objects
-// Background and UI assets
-var spawnableWords = ['cow', 'pig', 'sheep', 'horse', 'chicken', 'dog', 'cat', 'rabbit', 'duck', 'goat', 'turkey', 'donkey', 'llama', 'peacock', 'owl', 'butterfly', 'bee', 'frog', 'snail', 'mushroom', 'flower', 'tree', 'rock', 'apple', 'carrot', 'pumpkin', 'corn', 'sunflower', 'berry', 'acorn'];
-// Game state
-var spawnedCreatures = [];
-var discoveredWords = [];
-var currentInput = '';
-// Create grass field background
-var grassField = LK.getAsset('grass_field', {
+// List of 30 spawnable items: word, assetId, movement type, color, shape, size
+var PARADE_ITEMS = [{
+	word: "cat",
+	assetId: "cat",
+	moveType: "walk",
+	color: 0xcccccc,
+	shape: "ellipse",
+	width: 120,
+	height: 80
+}, {
+	word: "dog",
+	assetId: "dog",
+	moveType: "walk",
+	color: 0x996633,
+	shape: "ellipse",
+	width: 140,
+	height: 90
+}, {
+	word: "rabbit",
+	assetId: "rabbit",
+	moveType: "hop",
+	color: 0xffffff,
+	shape: "ellipse",
+	width: 100,
+	height: 70
+}, {
+	word: "duck",
+	assetId: "duck",
+	moveType: "waddle",
+	color: 0xffee44,
+	shape: "ellipse",
+	width: 110,
+	height: 80
+}, {
+	word: "sheep",
+	assetId: "sheep",
+	moveType: "walk",
+	color: 0xf0f0f0,
+	shape: "ellipse",
+	width: 130,
+	height: 90
+}, {
+	word: "pig",
+	assetId: "pig",
+	moveType: "wiggle",
+	color: 0xffb6c1,
+	shape: "ellipse",
+	width: 120,
+	height: 80
+}, {
+	word: "cow",
+	assetId: "cow",
+	moveType: "walk",
+	color: 0xffffff,
+	shape: "ellipse",
+	width: 160,
+	height: 100
+}, {
+	word: "horse",
+	assetId: "horse",
+	moveType: "gallop",
+	color: 0x8b5a2b,
+	shape: "ellipse",
+	width: 170,
+	height: 100
+}, {
+	word: "chicken",
+	assetId: "chicken",
+	moveType: "peck",
+	color: 0xfff8dc,
+	shape: "ellipse",
+	width: 90,
+	height: 60
+}, {
+	word: "goat",
+	assetId: "goat",
+	moveType: "walk",
+	color: 0xe0e0e0,
+	shape: "ellipse",
+	width: 120,
+	height: 80
+}, {
+	word: "frog",
+	assetId: "frog",
+	moveType: "hop",
+	color: 0x44cc44,
+	shape: "ellipse",
+	width: 80,
+	height: 60
+}, {
+	word: "mouse",
+	assetId: "mouse",
+	moveType: "scurry",
+	color: 0xaaaaaa,
+	shape: "ellipse",
+	width: 70,
+	height: 40
+}, {
+	word: "fox",
+	assetId: "fox",
+	moveType: "sneak",
+	color: 0xff6600,
+	shape: "ellipse",
+	width: 110,
+	height: 70
+}, {
+	word: "owl",
+	assetId: "owl",
+	moveType: "fly",
+	color: 0x888888,
+	shape: "ellipse",
+	width: 100,
+	height: 80
+}, {
+	word: "bee",
+	assetId: "bee",
+	moveType: "zigzag",
+	color: 0xffee00,
+	shape: "ellipse",
+	width: 60,
+	height: 40
+}, {
+	word: "butterfly",
+	assetId: "butterfly",
+	moveType: "wave",
+	color: 0xff99ff,
+	shape: "ellipse",
+	width: 80,
+	height: 60
+}, {
+	word: "snail",
+	assetId: "snail",
+	moveType: "crawl",
+	color: 0xcccc99,
+	shape: "ellipse",
+	width: 70,
+	height: 50
+}, {
+	word: "turtle",
+	assetId: "turtle",
+	moveType: "crawl",
+	color: 0x228b22,
+	shape: "ellipse",
+	width: 100,
+	height: 70
+}, {
+	word: "fish",
+	assetId: "fish",
+	moveType: "swim",
+	color: 0x3399ff,
+	shape: "ellipse",
+	width: 90,
+	height: 50
+}, {
+	word: "bird",
+	assetId: "bird",
+	moveType: "fly",
+	color: 0x87ceeb,
+	shape: "ellipse",
+	width: 90,
+	height: 60
+}, {
+	word: "car",
+	assetId: "car",
+	moveType: "roll",
+	color: 0x3366cc,
+	shape: "box",
+	width: 140,
+	height: 60
+}, {
+	word: "bus",
+	assetId: "bus",
+	moveType: "roll",
+	color: 0xffcc00,
+	shape: "box",
+	width: 200,
+	height: 80
+}, {
+	word: "train",
+	assetId: "train",
+	moveType: "roll",
+	color: 0x888888,
+	shape: "box",
+	width: 220,
+	height: 70
+}, {
+	word: "ball",
+	assetId: "ball",
+	moveType: "bounce",
+	color: 0xff3333,
+	shape: "ellipse",
+	width: 80,
+	height: 80
+}, {
+	word: "robot",
+	assetId: "robot",
+	moveType: "slide",
+	color: 0xcccccc,
+	shape: "box",
+	width: 100,
+	height: 100
+}, {
+	word: "apple",
+	assetId: "apple",
+	moveType: "wiggle",
+	color: 0xff2222,
+	shape: "ellipse",
+	width: 60,
+	height: 60
+}, {
+	word: "banana",
+	assetId: "banana",
+	moveType: "wiggle",
+	color: 0xffee00,
+	shape: "ellipse",
+	width: 80,
+	height: 40
+}, {
+	word: "star",
+	assetId: "star",
+	moveType: "float",
+	color: 0xffff00,
+	shape: "ellipse",
+	width: 70,
+	height: 70
+}, {
+	word: "cloud",
+	assetId: "cloud",
+	moveType: "float",
+	color: 0xffffff,
+	shape: "ellipse",
+	width: 180,
+	height: 90
+}, {
+	word: "moon",
+	assetId: "moon",
+	moveType: "float",
+	color: 0xffffcc,
+	shape: "ellipse",
+	width: 100,
+	height: 100
+}];
+// Map for quick lookup
+var PARADE_WORDS = {};
+for (var i = 0; i < PARADE_ITEMS.length; i++) {
+	PARADE_WORDS[PARADE_ITEMS[i].word] = PARADE_ITEMS[i];
+}
+// Track which items have been discovered
+var discovered = {};
+// Track all parade items on screen
+var paradeItems = [];
+// Initialize assets (shapes) for all items
+for (var i = 0; i < PARADE_ITEMS.length; i++) {
+	var item = PARADE_ITEMS[i];
+}
+// Draw the "ground" as a green rectangle at the bottom
+var ground = LK.getAsset('ground', {
+	width: 2048,
+	height: 220,
+	color: 0x5cb85c,
+	shape: "box",
 	anchorX: 0,
-	anchorY: 0,
+	anchorY: 1,
 	x: 0,
-	y: 0
+	y: 2732
 });
-game.addChild(grassField);
-// Create input display box
-var inputBox = LK.getAsset('input_box', {
+game.addChild(ground);
+// Title text
+var titleTxt = new Text2("Type & Spawn: Animal Parade", {
+	size: 90,
+	fill: 0xFFFFFF
+});
+titleTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(titleTxt);
+// Discovered counter
+var discoveredTxt = new Text2("Discovered: 0/30", {
+	size: 60,
+	fill: 0xFFFFFF
+});
+discoveredTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(discoveredTxt);
+// Instructions
+var instrTxt = new Text2("Type a word and press 'Spawn'!", {
+	size: 60,
+	fill: 0xFFFFFF
+});
+instrTxt.anchor.set(0.5, 0);
+LK.gui.bottom.addChild(instrTxt);
+// Input field (simulated with a Text2 and a "Spawn" button)
+var inputWord = "";
+var inputTxt = new Text2("", {
+	size: 80,
+	fill: 0x222222
+});
+inputTxt.anchor.set(0.5, 0.5);
+inputTxt.x = 2048 / 2;
+inputTxt.y = 2732 - 350;
+game.addChild(inputTxt);
+// "Spawn" button
+var spawnBtn = LK.getAsset('spawnBtn', {
+	width: 320,
+	height: 120,
+	color: 0x4a90e2,
+	shape: "box",
 	anchorX: 0.5,
 	anchorY: 0.5,
-	x: 1024,
-	y: 150
+	x: 2048 / 2,
+	y: 2732 - 200
 });
-game.addChild(inputBox);
-// Create input text display
-var inputText = new Text2('Type an animal or object...', {
-	size: 40,
-	fill: 0x333333
+game.addChild(spawnBtn);
+var spawnBtnTxt = new Text2("Spawn", {
+	size: 70,
+	fill: 0xFFFFFF
 });
-inputText.anchor.set(0.5, 0.5);
-inputText.x = 1024;
-inputText.y = 150;
-game.addChild(inputText);
-// Create discovered counter
-var discoveredText = new Text2('Discovered: 0/30', {
+spawnBtnTxt.anchor.set(0.5, 0.5);
+spawnBtnTxt.x = spawnBtn.x;
+spawnBtnTxt.y = spawnBtn.y;
+game.addChild(spawnBtnTxt);
+// On-screen keyboard (letters A-Z, backspace, space)
+var keyboardLetters = ["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM"];
+var keyboardKeys = [];
+var keySize = 120;
+var keyMargin = 18;
+var kbStartY = 2732 - 650;
+for (var row = 0; row < keyboardLetters.length; row++) {
+	var letters = keyboardLetters[row];
+	var y = kbStartY + row * (keySize + keyMargin);
+	var rowWidth = letters.length * (keySize + keyMargin) - keyMargin;
+	var x0 = (2048 - rowWidth) / 2 + keySize / 2;
+	for (var col = 0; col < letters.length; col++) {
+		var ch = letters[col];
+		var key = LK.getAsset("key_" + ch, {
+			width: keySize,
+			height: keySize,
+			color: 0xffffff,
+			shape: "box",
+			anchorX: 0.5,
+			anchorY: 0.5,
+			x: x0 + col * (keySize + keyMargin),
+			y: y
+		});
+		game.addChild(key);
+		var keyTxt = new Text2(ch, {
+			size: 60,
+			fill: 0x222222
+		});
+		keyTxt.anchor.set(0.5, 0.5);
+		keyTxt.x = key.x;
+		keyTxt.y = key.y;
+		game.addChild(keyTxt);
+		keyboardKeys.push({
+			key: key,
+			letter: ch
+		});
+	}
+}
+// Spacebar
+var spaceKey = LK.getAsset('key_space', {
+	width: keySize * 4 + keyMargin * 3,
+	height: keySize,
+	color: 0xffffff,
+	shape: "box",
+	anchorX: 0.5,
+	anchorY: 0.5,
+	x: 2048 / 2,
+	y: kbStartY + 3 * (keySize + keyMargin)
+});
+game.addChild(spaceKey);
+var spaceTxt = new Text2("SPACE", {
 	size: 50,
-	fill: 0xFFFFFF
+	fill: 0x222222
 });
-discoveredText.anchor.set(0.5, 0);
-LK.gui.top.addChild(discoveredText);
-discoveredText.y = 50;
-// Create instruction text
-var instructionText = new Text2('Type words to spawn creatures!', {
-	size: 35,
-	fill: 0xFFFFFF
+spaceTxt.anchor.set(0.5, 0.5);
+spaceTxt.x = spaceKey.x;
+spaceTxt.y = spaceKey.y;
+game.addChild(spaceTxt);
+// Backspace
+var backKey = LK.getAsset('key_back', {
+	width: keySize * 2 + keyMargin,
+	height: keySize,
+	color: 0xffffff,
+	shape: "box",
+	anchorX: 0.5,
+	anchorY: 0.5,
+	x: 2048 / 2 + 350,
+	y: kbStartY + 3 * (keySize + keyMargin)
 });
-instructionText.anchor.set(0.5, 0);
-instructionText.x = 1024;
-instructionText.y = 200;
-game.addChild(instructionText);
-// Handle keyboard input simulation through touch
-var keyboardActive = false;
-function spawnCreature(word) {
-	if (spawnableWords.indexOf(word) !== -1) {
-		// Check if already discovered
-		if (discoveredWords.indexOf(word) === -1) {
-			discoveredWords.push(word);
-			discoveredText.setText('Discovered: ' + discoveredWords.length + '/30');
-		}
-		// Create new creature
-		var newCreature = new SpawnableCreature(word);
-		spawnedCreatures.push(newCreature);
-		game.addChild(newCreature);
-		// Success feedback
-		LK.effects.flashObject(inputBox, 0x00ff00, 500);
-		return true;
+game.addChild(backKey);
+var backTxt = new Text2("⌫", {
+	size: 60,
+	fill: 0x222222
+});
+backTxt.anchor.set(0.5, 0.5);
+backTxt.x = backKey.x;
+backTxt.y = backKey.y;
+game.addChild(backTxt);
+// Keyboard input handling
+function handleKeyPress(ch) {
+	if (inputWord.length < 16) {
+		inputWord += ch;
+		inputTxt.setText(inputWord);
 	}
-	return false;
 }
-function processInput() {
-	var word = currentInput.toLowerCase().trim();
-	if (word.length > 0) {
-		var spawned = spawnCreature(word);
-		if (!spawned) {
-			// Invalid word feedback
-			LK.effects.flashObject(inputBox, 0xff0000, 500);
-		}
+function handleBackspace() {
+	inputWord = inputWord.slice(0, -1);
+	inputTxt.setText(inputWord);
+}
+function handleSpace() {
+	if (inputWord.length < 16) {
+		inputWord += " ";
+		inputTxt.setText(inputWord);
 	}
-	currentInput = '';
-	updateInputDisplay();
 }
-function updateInputDisplay() {
-	if (currentInput.length === 0) {
-		inputText.setText('Type an animal or object...');
-		inputText.style.fill = "#888888";
+function handleSpawn() {
+	var word = inputWord.trim().toLowerCase();
+	if (PARADE_WORDS[word]) {
+		spawnParadeItem(word);
+		inputWord = "";
+		inputTxt.setText("");
 	} else {
-		inputText.setText(currentInput);
-		inputText.style.fill = "#333333";
+		// Flash input red for 500ms
+		tween(inputTxt, {
+			tint: 0xff3333
+		}, {
+			duration: 100,
+			onFinish: function onFinish() {
+				tween(inputTxt, {
+					tint: 0x222222
+				}, {
+					duration: 400
+				});
+			}
+		});
 	}
 }
-// Simple touch-based letter input system
-var alphabet = 'abcdefghijklmnopqrstuvwxyz';
-var letterButtons = [];
-// Create virtual keyboard
-for (var i = 0; i < alphabet.length; i++) {
-	var letter = alphabet[i];
-	var buttonY = 2500 + Math.floor(i / 9) * 80;
-	var buttonX = 200 + i % 9 * 180;
-	var letterButton = new Text2(letter.toUpperCase(), {
-		size: 50,
-		fill: 0xFFFFFF
-	});
-	letterButton.anchor.set(0.5, 0.5);
-	letterButton.x = buttonX;
-	letterButton.y = buttonY;
-	letterButton.letter = letter;
-	letterButton.down = function (x, y, obj) {
-		currentInput += this.letter;
-		updateInputDisplay();
-		LK.effects.flashObject(this, 0xffff00, 200);
-	};
-	game.addChild(letterButton);
-	letterButtons.push(letterButton);
+// Attach event listeners to keys
+for (var i = 0; i < keyboardKeys.length; i++) {
+	(function (keyObj) {
+		keyObj.key.down = function (x, y, obj) {
+			handleKeyPress(keyObj.letter);
+		};
+	})(keyboardKeys[i]);
 }
-// Add space and enter buttons
-var spaceButton = new Text2('SPACE', {
-	size: 40,
-	fill: 0xFFFFFF
-});
-spaceButton.anchor.set(0.5, 0.5);
-spaceButton.x = 400;
-spaceButton.y = 2740;
-spaceButton.down = function () {
-	currentInput += ' ';
-	updateInputDisplay();
+spaceKey.down = function (x, y, obj) {
+	handleSpace();
 };
-game.addChild(spaceButton);
-var enterButton = new Text2('ENTER', {
-	size: 40,
-	fill: 0x00FF00
-});
-enterButton.anchor.set(0.5, 0.5);
-enterButton.x = 600;
-enterButton.y = 2740;
-enterButton.down = function () {
-	processInput();
+backKey.down = function (x, y, obj) {
+	handleBackspace();
 };
-game.addChild(enterButton);
-var backButton = new Text2('BACK', {
-	size: 40,
-	fill: 0xFF6666
-});
-backButton.anchor.set(0.5, 0.5);
-backButton.x = 800;
-backButton.y = 2740;
-backButton.down = function () {
-	if (currentInput.length > 0) {
-		currentInput = currentInput.slice(0, -1);
-		updateInputDisplay();
-	}
+spawnBtn.down = function (x, y, obj) {
+	handleSpawn();
 };
-game.addChild(backButton);
-// Initialize input display
-updateInputDisplay();
-// Main game update loop
+inputTxt.down = function (x, y, obj) {
+	// No-op, but could focus input if we had a real input field
+};
+// Spawn a parade item
+function spawnParadeItem(word) {
+	var item = PARADE_WORDS[word];
+	// Mark as discovered
+	if (!discovered[word]) {
+		discovered[word] = true;
+		updateDiscoveredTxt();
+		// Flash discovered text green
+		tween(discoveredTxt, {
+			tint: 0x44ff44
+		}, {
+			duration: 200,
+			onFinish: function onFinish() {
+				tween(discoveredTxt, {
+					tint: 0xffffff
+				}, {
+					duration: 400
+				});
+			}
+		});
+	}
+	// Create ParadeItem
+	var parade = new ParadeItem();
+	parade.assetId = item.assetId;
+	parade.moveType = getMoveType(item.moveType);
+	parade.width = item.width;
+	parade.height = item.height;
+	// Place at random x along the ground, y at ground level
+	parade.x = Math.random() * (2048 - parade.width) + parade.width / 2;
+	parade.y = 2732 - 220 + 10; // Just above ground
+	parade.baseY = parade.y;
+	parade.baseX = parade.x;
+	paradeItems.push(parade);
+	game.addChild(parade);
+	// Animate in (pop up)
+	parade.scaleX = parade.scaleY = 0.1;
+	tween(parade, {
+		scaleX: 1,
+		scaleY: 1
+	}, {
+		duration: 300,
+		easing: tween.bounceOut
+	});
+}
+// Update discovered text
+function updateDiscoveredTxt() {
+	var count = 0;
+	for (var k in discovered) if (discovered[k]) count++;
+	discoveredTxt.setText("Discovered: " + count + "/30");
+}
+// Map movement type string to ParadeItem moveType
+function getMoveType(type) {
+	// Map some fun types to our implemented types
+	if (type === "waddle" || type === "gallop" || type === "scurry" || type === "peck" || type === "sneak" || type === "swim") return "walk";
+	return type;
+}
+// Parade item update
 game.update = function () {
-	// Update all spawned creatures
-	for (var i = spawnedCreatures.length - 1; i >= 0; i--) {
-		var creature = spawnedCreatures[i];
-		creature.update();
+	for (var i = 0; i < paradeItems.length; i++) {
+		paradeItems[i].update();
 	}
-	// Check win condition
-	if (discoveredWords.length >= 30) {
-		LK.showYouWin();
-	}
+};
+// Show all discovered items on game over
+game.gameOver = function () {
+	// Not needed, handled by LK
+};
+// Show all discovered items on win
+game.youWin = function () {
+	// Not needed, handled by LK
 };
\ No newline at end of file