/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// Game objects in global scope
function ownKeys(e, r) {
	var t = Object.keys(e);
	if (Object.getOwnPropertySymbols) {
		var o = Object.getOwnPropertySymbols(e);
		r && (o = o.filter(function (r) {
			return Object.getOwnPropertyDescriptor(e, r).enumerable;
		})), t.push.apply(t, o);
	}
	return t;
}
// Check if localStorage is accessible
function isLocalStorageAccessible() {
	try {
		localStorage.setItem('test', 'test');
		localStorage.removeItem('test');
		return true;
	} catch (e) {
		return false;
	}
}
function _objectSpread(e) {
	for (var r = 1; r < arguments.length; r++) {
		var t = null != arguments[r] ? arguments[r] : {};
		r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
			_defineProperty(e, r, t[r]);
		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
		});
	}
	return e;
}
function _defineProperty(e, r, t) {
	return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
		value: t,
		enumerable: !0,
		configurable: !0,
		writable: !0
	}) : e[r] = t, e;
}
function _callSuper(t, o, e) {
	return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
}
function _possibleConstructorReturn(t, e) {
	if (e && ("object" == _typeof(e) || "function" == typeof e)) {
		return e;
	}
	if (void 0 !== e) {
		throw new TypeError("Derived constructors may only return object or undefined");
	}
	return _assertThisInitialized(t);
}
function _assertThisInitialized(e) {
	if (void 0 === e) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	}
	return e;
}
function _isNativeReflectConstruct() {
	try {
		var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
	} catch (t) {}
	return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
		return !!t;
	})();
}
function _getPrototypeOf(t) {
	return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
		return t.__proto__ || Object.getPrototypeOf(t);
	}, _getPrototypeOf(t);
}
function _inherits(t, e) {
	if ("function" != typeof e && null !== e) {
		throw new TypeError("Super expression must either be null or a function");
	}
	t.prototype = Object.create(e && e.prototype, {
		constructor: {
			value: t,
			writable: !0,
			configurable: !0
		}
	}), Object.defineProperty(t, "prototype", {
		writable: !1
	}), e && _setPrototypeOf(t, e);
}
function _setPrototypeOf(t, e) {
	return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
		return t.__proto__ = e, t;
	}, _setPrototypeOf(t, e);
}
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		if (isLocalStorageAccessible()) {
			return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
		} else {
			return typeof o;
		}
	} : function (o) {
		if (isLocalStorageAccessible()) {
			return typeof o;
		} else {
			return typeof o;
		}
	}, _typeof(o);
}
function _classCallCheck(a, n) {
	if (!(a instanceof n)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
function _defineProperties(e, r) {
	for (var t = 0; t < r.length; t++) {
		var o = r[t];
		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
	}
}
function _createClass(e, r, t) {
	return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
		writable: !1
	}), e;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
var cats = [];
var kittens = [];
var birds = [];
var ufos = [];
var sparkles = [];
var tree;
var sparkleDust = 0;
// Game parameters
var GAME_CONFIG = {
	catCost: 10,
	kittenCost: 50,
	ufoCost: 200,
	catCharmPower: 1,
	kittenCharmPower: 3,
	catCharmInterval: 5000,
	kittenCharmInterval: 3000,
	ufoCollectSpeed: 150,
	ufoCollectRange: 100,
	birdSpawnInterval: 3000,
	maxBirds: 10
};
var Cat = /*#__PURE__*/function () {
	function Cat(x, y) {
		_classCallCheck(this, Cat);
		this.sprite = LK.getAsset('cat', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		this.sprite.x = x;
		this.sprite.y = y;
		this.charmingCooldown = false;
	}
	return _createClass(Cat, [{
		key: "getCharmRadius",
		value: function getCharmRadius() {
			return 100;
		}
	}, {
		key: "tryCharmBird",
		value: function tryCharmBird() {
			if (this.charmingCooldown) {
				return;
			}
			for (var _i = 0, _birds = birds; _i < _birds.length; _i++) {
				var bird = _birds[_i];
				if (bird.charmed) {
					continue;
				}
				var dx = bird.sprite.x - this.sprite.x;
				var dy = bird.sprite.y - this.sprite.y;
				var distSq = dx * dx + dy * dy;
				if (distSq <= this.getCharmRadius() * this.getCharmRadius()) {
					var sparkleValue = bird.handleCharmed();
					this.handleCharmCooldown();
					// Create visual feedback for successful charm
					var charm = LK.getAsset('sparkle', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					charm.x = bird.sprite.x;
					charm.y = bird.sprite.y;
					charm.alpha = 0.7;
					// Animate and remove the charm effect
					setTimeout(function () {
						charm.alpha = 0;
						setTimeout(function () {
							return LK.remove(charm);
						}, 500);
					}, 500);
					return sparkleValue;
				}
			}
			return 0;
		}
	}, {
		key: "handleCharmCooldown",
		value: function handleCharmCooldown() {
			var _this = this;
			this.charmingCooldown = true;
			setTimeout(function () {
				_this.charmingCooldown = false;
			}, GAME_CONFIG.catCharmInterval);
		}
	}, {
		key: "update",
		value: function update() {
			var sparkleValue = this.tryCharmBird();
			if (sparkleValue > 0) {
				Game.instance.createSparkle(this.sprite.x, this.sprite.y, sparkleValue);
			}
		}
	}]);
}();
var Kitten = /*#__PURE__*/function (_Cat) {
	function Kitten(x, y) {
		var _this2;
		_classCallCheck(this, Kitten);
		_this2 = _callSuper(this, Kitten, [x, y]);
		_this2.sprite = LK.getAsset('kitten', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		return _this2;
	}
	_inherits(Kitten, _Cat);
	return _createClass(Kitten);
}(Cat);
var Bird = /*#__PURE__*/function () {
	function Bird() {
		_classCallCheck(this, Bird);
		this.sprite = LK.getAsset('bird', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		this.charmed = false;
		this.setRandomPosition();
	}
	return _createClass(Bird, [{
		key: "setRandomPosition",
		value: function setRandomPosition() {
			// Start from either side of screen
			this.sprite.x = Math.random() < 0.5 ? -50 : LK.width + 50;
			this.sprite.y = Math.random() * (LK.height * 0.6);
			// Target position near tree with more varied positions
			this.targetX = tree.x + (Math.random() * 400 - 200);
			this.targetY = tree.y - (Math.random() * 400 + 50);
			// Set random movement speed
			this.moveSpeed = 0.01 + Math.random() * 0.02;
			// Set random wobble for natural movement
			this.wobbleOffset = Math.random() * Math.PI * 2;
			this.wobbleSpeed = 1 + Math.random();
		}
	}, {
		key: "update",
		value: function update() {
			if (this.charmed) {
				// Charmed birds slowly float upward with spiral motion
				this.sprite.y -= 0.5;
				this.sprite.x += Math.sin(Date.now() / 500) * 0.5;
				this.sprite.rotation += 0.02;
				this.sprite.alpha = Math.max(0.2, this.sprite.alpha - 0.001);
				// Remove bird when it's nearly invisible
				if (this.sprite.alpha <= 0.2) {
					var index = birds.indexOf(this);
					if (index > -1) {
						birds.splice(index, 1);
						LK.remove(this.sprite);
					}
				}
				return;
			}
			// Move towards target with wobble
			var dx = this.targetX - this.sprite.x;
			var dy = this.targetY - this.sprite.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 1) {
				// Add wobble to movement
				var wobble = Math.sin(this.wobbleOffset + Date.now() / 1000) * 5 * this.wobbleSpeed;
				this.sprite.x += dx * this.moveSpeed;
				this.sprite.y += dy * this.moveSpeed + wobble * 0.1;
				// Rotate bird based on movement direction
				var angle = Math.atan2(dy, dx);
				this.sprite.rotation = angle + Math.PI / 2;
				// Check if bird is too far from tree and remove it
				var distFromTree = Math.sqrt(Math.pow(this.sprite.x - tree.x, 2) + Math.pow(this.sprite.y - tree.y, 2));
				if (distFromTree > LK.canvas.width) {
					var index = birds.indexOf(this);
					if (index > -1) {
						birds.splice(index, 1);
						LK.remove(this.sprite);
					}
				}
			}
		}
	}, {
		key: "handleCharmed",
		value: function handleCharmed() {
			var _this3 = this;
			if (this.charmed) {
				return 0;
			}
			this.charmed = true;
			// Visual feedback for charmed state
			this.sprite.tint = 0xFFAAFF;
			this.sprite.alpha = 0.8;
			// Remove bird after floating away
			setTimeout(function () {
				var index = birds.indexOf(_this3);
				if (index > -1) {
					birds.splice(index, 1);
				}
			}, 3000);
			return GAME_CONFIG.catCharmPower;
		}
	}]);
}();
var UFO = /*#__PURE__*/function () {
	function UFO(x, y) {
		_classCallCheck(this, UFO);
		this.sprite = LK.getAsset('ufo', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		this.sprite.x = x;
		this.sprite.y = y;
		this.targetSparkle = null;
	}
	return _createClass(UFO, [{
		key: "findNearestSparkle",
		value: function findNearestSparkle() {
			var nearest = null;
			var minDist = Infinity;
			for (var _i2 = 0, _sparkles = sparkles; _i2 < _sparkles.length; _i2++) {
				var sparkle = _sparkles[_i2];
				if (sparkle.targetedByUFO) {
					continue;
				}
				var dx = sparkle.sprite.x - this.sprite.x;
				var dy = sparkle.sprite.y - this.sprite.y;
				var distSq = dx * dx + dy * dy;
				if (distSq < minDist) {
					minDist = distSq;
					nearest = sparkle;
				}
			}
			return nearest;
		}
	}, {
		key: "moveToSparkle",
		value: function moveToSparkle() {
			if (!this.targetSparkle) {
				return;
			}
			var dx = this.targetSparkle.sprite.x - this.sprite.x;
			var dy = this.targetSparkle.sprite.y - this.sprite.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > GAME_CONFIG.ufoCollectRange) {
				this.sprite.x += dx / dist * GAME_CONFIG.ufoCollectSpeed * 0.016;
				this.sprite.y += dy / dist * GAME_CONFIG.ufoCollectSpeed * 0.016;
				// Rotate UFO based on movement direction
				this.sprite.rotation = Math.atan2(dy, dx) + Math.PI / 2;
				// Add collection beam effect when close
				if (dist < GAME_CONFIG.ufoCollectRange * 2) {
					var beam = LK.getAsset('beam', {
						anchorX: 0.5
					});
					beam.x = this.sprite.x;
					beam.y = this.sprite.y;
					beam.alpha = 0.3;
					beam.rotation = this.sprite.rotation;
					setTimeout(function () {
						LK.remove(beam);
					}, 100);
				}
			} else {
				this.collectSparkle();
			}
		}
	}, {
		key: "collectSparkle",
		value: function collectSparkle() {
			if (!this.targetSparkle) {
				return;
			}
			sparkleDust += this.targetSparkle.value;
			var index = sparkles.indexOf(this.targetSparkle);
			if (index > -1) {
				sparkles.splice(index, 1);
			}
			this.targetSparkle = null;
		}
	}, {
		key: "update",
		value: function update() {
			if (!this.targetSparkle) {
				this.targetSparkle = this.findNearestSparkle();
				if (this.targetSparkle) {
					this.targetSparkle.targetedByUFO = this;
				}
			}
			this.moveToSparkle();
		}
	}]);
}();
var Sparkle = /*#__PURE__*/function () {
	function Sparkle(x, y, value) {
		_classCallCheck(this, Sparkle);
		this.sprite = LK.getAsset('sparkle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		this.sprite.x = x;
		this.sprite.y = y;
		this.value = value;
		this.targetedByUFO = null;
		this.floatOffset = Math.random() * Math.PI * 2;
		this.floatSpeed = 1 + Math.random();
		this.collected = false;
	}
	return _createClass(Sparkle, [{
		key: "update",
		value: function update() {
			if (this.collected) {
				// Fade out collected sparkles
				this.sprite.alpha = Math.max(0, this.sprite.alpha - 0.05);
				if (this.sprite.alpha <= 0) {
					var index = sparkles.indexOf(this);
					if (index > -1) {
						sparkles.splice(index, 1);
						LK.remove(this.sprite);
					}
				}
				return;
			}
			// Floating animation
			this.sprite.y += Math.sin(this.floatOffset + Date.now() / 1000) * 0.5 * this.floatSpeed;
			// Gentle sparkle rotation
			this.sprite.rotation += 0.01 * this.floatSpeed;
			// Pulsing effect
			this.sprite.alpha = 0.7 + Math.sin(Date.now() / 500) * 0.3;
		}
	}, {
		key: "handleCollection",
		value: function handleCollection() {
			if (this.collected) {
				return false;
			}
			this.collected = true;
			return true;
		}
	}]);
}();
var Game = /*#__PURE__*/function () {
	function Game() {
		_classCallCheck(this, Game);
	}
	return _createClass(Game, [{
		key: "initialize",
		value: function initialize() {
			Game.instance = this;
			LK.backgroundColor = 0x87CEFA; // Set background color through LK
			// Ensure LK is initialized before accessing canvas
			if (!LK || !LK.canvas) {
				console.error('LK engine not properly initialized');
				return;
			}
			// Ensure all shapes are initialized
			if (!LK.getAsset('beam', {}) || !LK.getAsset('bird', {}) || !LK.getAsset('cat', {}) || !LK.getAsset('kitten', {}) || !LK.getAsset('sparkle', {}) || !LK.getAsset('tree', {}) || !LK.getAsset('ufo', {})) {
				console.error('One or more shapes are not properly initialized');
				return;
			}
			// Reset all game arrays
			cats = [];
			kittens = [];
			birds = [];
			ufos = [];
			sparkles = [];
			this.setupTree();
			this.setupInitialState();
			this.setupEventListeners();
			this.startBirdSpawner();
		}
	}, {
		key: "startBirdSpawner",
		value: function startBirdSpawner() {
			setInterval(function () {
				if (birds.length < GAME_CONFIG.maxBirds) {
					birds.push(new Bird());
				}
			}, GAME_CONFIG.birdSpawnInterval);
		}
	}, {
		key: "createSparkle",
		value: function createSparkle(x, y, value) {
			var sparkle = new Sparkle(x, y, value);
			sparkles.push(sparkle);
		}
	}, {
		key: "setupTree",
		value: function setupTree() {
			var _this4 = this;
			if (!LK || !LK.canvas) {
				return;
			}
			tree = LK.getAsset('tree', {
				anchorX: 0.5,
				anchorY: 1
			});
			tree.x = LK.canvas.width / 2;
			tree.y = LK.canvas.height - 10;
			// Make tree interactive for sparkle generation
			tree.interactive = true;
			tree.on('pointerdown', function (obj) {
				var pos = scope.toLocal(obj.global);
				_this4.createSparkle(pos.x, pos.y, 1);
			});
		}
	}, {
		key: "setupInitialState",
		value: function setupInitialState() {
			sparkleDust = 50;
			this.addCat();
			this.addUFO();
		}
	}, {
		key: "setupEventListeners",
		value: function setupEventListeners() {
			var _this5 = this;
			// Create UI buttons using LK
			var buttonStyle = {
				backgroundColor: 0x4CAF50,
				textColor: 0xFFFFFF
			};
			var buttonYStart = 50;
			var buttonYSpacing = 50;
			var catButton = LK.CreateButton(_objectSpread(_objectSpread({
				text: "Buy Cat (".concat(GAME_CONFIG.catCost, ")"),
				x: 10,
				y: buttonYStart,
				width: 120,
				height: 30
			}, buttonStyle), {}, {
				pointerup: function pointerup() {
					return _this5.addCat();
				},
				scope: this
			}));
			var kittenButton = LK.CreateButton(_objectSpread(_objectSpread({
				text: "Buy Kitten (".concat(GAME_CONFIG.kittenCost, ")"),
				x: 10,
				y: buttonYStart + buttonYSpacing,
				width: 120,
				height: 30
			}, buttonStyle), {}, {
				pointerup: function pointerup() {
					return _this5.addKitten();
				},
				scope: this
			}));
			var ufoButton = LK.CreateButton(_objectSpread(_objectSpread({
				text: "Buy UFO (".concat(GAME_CONFIG.ufoCost, ")"),
				x: 10,
				y: buttonYStart + buttonYSpacing * 2,
				width: 120,
				height: 30
			}, buttonStyle), {}, {
				pointerup: function pointerup() {
					return _this5.addUFO();
				},
				scope: this
			}));
			// Create sparkle dust counter
			this.sparkleDustText = LK.CreateText({
				text: "Sparkle Dust: ".concat(sparkleDust),
				x: 10,
				y: 10,
				style: {
					fill: 0xFFFFFF,
					fontSize: 16
				}
			});
		}
	}, {
		key: "update",
		value: function update() {
			cats.forEach(function (cat) {
				return cat.update();
			});
			kittens.forEach(function (kitten) {
				return kitten.update();
			});
			birds.forEach(function (bird) {
				return bird.update();
			});
			ufos.forEach(function (ufo) {
				return ufo.update();
			});
			sparkles.forEach(function (sparkle) {
				return sparkle.update();
			});
			this.updateUI();
		}
	}, {
		key: "addCat",
		value: function addCat() {
			if (sparkleDust >= GAME_CONFIG.catCost) {
				var cat = new Cat(tree.x + Math.random() * 100 - 50, tree.y - Math.random() * 100);
				cats.push(cat);
				sparkleDust -= GAME_CONFIG.catCost;
				this.updateUI();
			}
		}
	}, {
		key: "addKitten",
		value: function addKitten() {
			if (sparkleDust >= GAME_CONFIG.kittenCost) {
				var kitten = new Kitten(tree.x + Math.random() * 100 - 50, tree.y - Math.random() * 100);
				kittens.push(kitten);
				sparkleDust -= GAME_CONFIG.kittenCost;
				this.updateUI();
			}
		}
	}, {
		key: "addUFO",
		value: function addUFO() {
			if (sparkleDust >= GAME_CONFIG.ufoCost) {
				var ufo = new UFO(tree.x + Math.random() * 200 - 100, tree.y - Math.random() * 200);
				ufos.push(ufo);
				sparkleDust -= GAME_CONFIG.ufoCost;
				this.updateUI();
			}
		}
	}, {
		key: "updateUI",
		value: function updateUI() {
			if (this.sparkleDustText) {
				this.sparkleDustText.text = "Sparkle Dust: ".concat(Math.floor(sparkleDust));
			}
		}
	}]);
	//addition methods
}();
_defineProperty(Game, "instance", null);
var Beam = /*#__PURE__*/function () {
	function Beam(x, y) {
		_classCallCheck(this, Beam);
		this.sprite = LK.getAsset('beam', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		this.sprite.x = x;
		this.sprite.y = y;
	}
	return _createClass(Beam);
}();
var Tree = /*#__PURE__*/function () {
	function Tree(x, y) {
		_classCallCheck(this, Tree);
		this.sprite = LK.getAsset('tree', {
			anchorX: 0.5,
			anchorY: 1
		});
		this.sprite.x = x;
		this.sprite.y = y;
	}
	return _createClass(Tree);
}();
var Sparkle = /*#__PURE__*/function () {
	function Sparkle(x, y, value) {
		_classCallCheck(this, Sparkle);
		this.sprite = LK.getAsset('sparkle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		this.sprite.x = x;
		this.sprite.y = y;
		this.value = value;
		this.targetedByUFO = null;
		this.floatOffset = Math.random() * Math.PI * 2;
		this.floatSpeed = 1 + Math.random();
		this.collected = false;
	}
	return _createClass(Sparkle, [{
		key: "update",
		value: function update() {
			if (this.collected) {
				this.sprite.alpha = Math.max(0, this.sprite.alpha - 0.05);
				if (this.sprite.alpha <= 0) {
					var index = sparkles.indexOf(this);
					if (index > -1) {
						sparkles.splice(index, 1);
						LK.remove(this.sprite);
					}
				}
				return;
			}
			this.sprite.y += Math.sin(this.floatOffset + Date.now() / 1000) * 0.5 * this.floatSpeed;
			this.sprite.rotation += 0.01 * this.floatSpeed;
			this.sprite.alpha = 0.7 + Math.sin(Date.now() / 500) * 0.3;
		}
	}, {
		key: "handleCollection",
		value: function handleCollection() {
			if (this.collected) {
				return false;
			}
			this.collected = true;
			return true;
		}
	}]);
}();
var Bird = /*#__PURE__*/function () {
	function Bird() {
		_classCallCheck(this, Bird);
		this.sprite = LK.getAsset('bird', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		this.charmed = false;
		this.setRandomPosition();
	}
	return _createClass(Bird, [{
		key: "setRandomPosition",
		value: function setRandomPosition() {
			this.sprite.x = Math.random() < 0.5 ? -50 : LK.width + 50;
			this.sprite.y = Math.random() * (LK.height * 0.6);
			this.targetX = tree.x + (Math.random() * 400 - 200);
			this.targetY = tree.y - (Math.random() * 400 + 50);
			this.moveSpeed = 0.01 + Math.random() * 0.02;
			this.wobbleOffset = Math.random() * Math.PI * 2;
			this.wobbleSpeed = 1 + Math.random();
		}
	}, {
		key: "update",
		value: function update() {
			if (this.charmed) {
				this.sprite.y -= 0.5;
				this.sprite.x += Math.sin(Date.now() / 500) * 0.5;
				this.sprite.rotation += 0.02;
				this.sprite.alpha = Math.max(0.2, this.sprite.alpha - 0.001);
				if (this.sprite.alpha <= 0.2) {
					var index = birds.indexOf(this);
					if (index > -1) {
						birds.splice(index, 1);
						LK.remove(this.sprite);
					}
				}
				return;
			}
			var dx = this.targetX - this.sprite.x;
			var dy = this.targetY - this.sprite.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 1) {
				var wobble = Math.sin(this.wobbleOffset + Date.now() / 1000) * 5 * this.wobbleSpeed;
				this.sprite.x += dx * this.moveSpeed;
				this.sprite.y += dy * this.moveSpeed + wobble * 0.1;
				var angle = Math.atan2(dy, dx);
				this.sprite.rotation = angle + Math.PI / 2;
				var distFromTree = Math.sqrt(Math.pow(this.sprite.x - tree.x, 2) + Math.pow(this.sprite.y - tree.y, 2));
				if (distFromTree > LK.canvas.width) {
					var index = birds.indexOf(this);
					if (index > -1) {
						birds.splice(index, 1);
						LK.remove(this.sprite);
					}
				}
			}
		}
	}, {
		key: "handleCharmed",
		value: function handleCharmed() {
			var _this3 = this;
			if (this.charmed) {
				return 0;
			}
			this.charmed = true;
			this.sprite.tint = 0xFFAAFF;
			this.sprite.alpha = 0.8;
			setTimeout(function () {
				var index = birds.indexOf(_this3);
				if (index > -1) {
					birds.splice(index, 1);
				}
			}, 3000);
			return GAME_CONFIG.catCharmPower;
		}
	}]);
}();

===================================================================
--- original.js
+++ change.js
@@ -669,5 +669,150 @@
 		}
 	}]);
 	//addition methods
 }();
-_defineProperty(Game, "instance", null);
\ No newline at end of file
+_defineProperty(Game, "instance", null);
+var Beam = /*#__PURE__*/function () {
+	function Beam(x, y) {
+		_classCallCheck(this, Beam);
+		this.sprite = LK.getAsset('beam', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		this.sprite.x = x;
+		this.sprite.y = y;
+	}
+	return _createClass(Beam);
+}();
+var Tree = /*#__PURE__*/function () {
+	function Tree(x, y) {
+		_classCallCheck(this, Tree);
+		this.sprite = LK.getAsset('tree', {
+			anchorX: 0.5,
+			anchorY: 1
+		});
+		this.sprite.x = x;
+		this.sprite.y = y;
+	}
+	return _createClass(Tree);
+}();
+var Sparkle = /*#__PURE__*/function () {
+	function Sparkle(x, y, value) {
+		_classCallCheck(this, Sparkle);
+		this.sprite = LK.getAsset('sparkle', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		this.sprite.x = x;
+		this.sprite.y = y;
+		this.value = value;
+		this.targetedByUFO = null;
+		this.floatOffset = Math.random() * Math.PI * 2;
+		this.floatSpeed = 1 + Math.random();
+		this.collected = false;
+	}
+	return _createClass(Sparkle, [{
+		key: "update",
+		value: function update() {
+			if (this.collected) {
+				this.sprite.alpha = Math.max(0, this.sprite.alpha - 0.05);
+				if (this.sprite.alpha <= 0) {
+					var index = sparkles.indexOf(this);
+					if (index > -1) {
+						sparkles.splice(index, 1);
+						LK.remove(this.sprite);
+					}
+				}
+				return;
+			}
+			this.sprite.y += Math.sin(this.floatOffset + Date.now() / 1000) * 0.5 * this.floatSpeed;
+			this.sprite.rotation += 0.01 * this.floatSpeed;
+			this.sprite.alpha = 0.7 + Math.sin(Date.now() / 500) * 0.3;
+		}
+	}, {
+		key: "handleCollection",
+		value: function handleCollection() {
+			if (this.collected) {
+				return false;
+			}
+			this.collected = true;
+			return true;
+		}
+	}]);
+}();
+var Bird = /*#__PURE__*/function () {
+	function Bird() {
+		_classCallCheck(this, Bird);
+		this.sprite = LK.getAsset('bird', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		this.charmed = false;
+		this.setRandomPosition();
+	}
+	return _createClass(Bird, [{
+		key: "setRandomPosition",
+		value: function setRandomPosition() {
+			this.sprite.x = Math.random() < 0.5 ? -50 : LK.width + 50;
+			this.sprite.y = Math.random() * (LK.height * 0.6);
+			this.targetX = tree.x + (Math.random() * 400 - 200);
+			this.targetY = tree.y - (Math.random() * 400 + 50);
+			this.moveSpeed = 0.01 + Math.random() * 0.02;
+			this.wobbleOffset = Math.random() * Math.PI * 2;
+			this.wobbleSpeed = 1 + Math.random();
+		}
+	}, {
+		key: "update",
+		value: function update() {
+			if (this.charmed) {
+				this.sprite.y -= 0.5;
+				this.sprite.x += Math.sin(Date.now() / 500) * 0.5;
+				this.sprite.rotation += 0.02;
+				this.sprite.alpha = Math.max(0.2, this.sprite.alpha - 0.001);
+				if (this.sprite.alpha <= 0.2) {
+					var index = birds.indexOf(this);
+					if (index > -1) {
+						birds.splice(index, 1);
+						LK.remove(this.sprite);
+					}
+				}
+				return;
+			}
+			var dx = this.targetX - this.sprite.x;
+			var dy = this.targetY - this.sprite.y;
+			var dist = Math.sqrt(dx * dx + dy * dy);
+			if (dist > 1) {
+				var wobble = Math.sin(this.wobbleOffset + Date.now() / 1000) * 5 * this.wobbleSpeed;
+				this.sprite.x += dx * this.moveSpeed;
+				this.sprite.y += dy * this.moveSpeed + wobble * 0.1;
+				var angle = Math.atan2(dy, dx);
+				this.sprite.rotation = angle + Math.PI / 2;
+				var distFromTree = Math.sqrt(Math.pow(this.sprite.x - tree.x, 2) + Math.pow(this.sprite.y - tree.y, 2));
+				if (distFromTree > LK.canvas.width) {
+					var index = birds.indexOf(this);
+					if (index > -1) {
+						birds.splice(index, 1);
+						LK.remove(this.sprite);
+					}
+				}
+			}
+		}
+	}, {
+		key: "handleCharmed",
+		value: function handleCharmed() {
+			var _this3 = this;
+			if (this.charmed) {
+				return 0;
+			}
+			this.charmed = true;
+			this.sprite.tint = 0xFFAAFF;
+			this.sprite.alpha = 0.8;
+			setTimeout(function () {
+				var index = birds.indexOf(_this3);
+				if (index > -1) {
+					birds.splice(index, 1);
+				}
+			}, 3000);
+			return GAME_CONFIG.catCharmPower;
+		}
+	}]);
+}();
\ No newline at end of file