/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var FeedbackIndicator = Container.expand(function (type) {
	var self = Container.call(this);
	var indicator = self.attachAsset(type + 'Indicator', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.show = function () {
		indicator.alpha = 1;
		indicator.scaleX = 0.5;
		indicator.scaleY = 0.5;
		tween(indicator, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 600,
			easing: tween.easeOut
		});
	};
	return self;
});
/**** 
* Title Screen
****/ 
var Fish = Container.expand(function (type, value, speed, lane, isHoldFish) {
	var self = Container.call(this);
	var assetName = type + 'Fish';
	var fishGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = type;
	self.value = value;
	self.speed = speed;
	self.lane = lane; // Index of the lane (0, 1, or 2)
	self.isHoldFish = isHoldFish || false;
	self.caught = false;
	self.isSpecial = type === 'rare'; // For shimmer effect
	self.shimmerTime = 0;
	// Hold fish specific properties
	if (self.isHoldFish) {
		fishGraphics.tint = 0xFFD700; // Golden tint for hold fish
		self.holdStarted = false; // True if player successfully holds long enough (visual cue potential)
		self.requiredHoldTime = 800; // 800ms hold required to "prime" the catch for a hold fish
	}
	self.update = function () {
		if (!self.caught) {
			self.x += self.speed;
			if (self.isSpecial) {
				// Shimmer effect for rare fish
				self.shimmerTime += 0.1;
				fishGraphics.alpha = 0.8 + Math.sin(self.shimmerTime) * 0.2;
			} else if (!self.isHoldFish) {
				// Reset alpha if not special and not hold (hold has tint)
				fishGraphics.alpha = 1.0;
			}
		}
	};
	self.catchFish = function () {
		self.caught = true;
		// Animation to boat
		tween(self, {
			y: GAME_CONFIG.BOAT_Y,
			// Target Y: boat position
			x: GAME_CONFIG.SCREEN_CENTER_X,
			//{r} // Target X: center of screen (boat position)
			scaleX: 0.5,
			scaleY: 0.5,
			alpha: 0
		}, {
			duration: 600,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// If game.up already exists, integrate the 'fishing' case. Otherwise, this defines game.up.
/**** 
* Pattern Generation System
****/ 
var PatternGenerator = {
	lastLane: -1,
	lastSpawnX: -1000,
	minDistanceBetweenFish: 300,
	// Minimum X distance between fish
	getNextLane: function getNextLane() {
		if (this.lastLane === -1) {
			// First fish, start in middle lane
			this.lastLane = 1;
			return 1;
		}
		// Prefer staying in same lane or moving to adjacent lane
		var possibleLanes = [this.lastLane];
		// Add adjacent lanes
		if (this.lastLane > 0) possibleLanes.push(this.lastLane - 1);
		if (this.lastLane < 2) possibleLanes.push(this.lastLane + 1);
		// 70% chance to stay in same/adjacent lane
		if (Math.random() < 0.7) {
			this.lastLane = possibleLanes[Math.floor(Math.random() * possibleLanes.length)];
		} else {
			// 30% chance for any lane
			this.lastLane = Math.floor(Math.random() * 3);
		}
		return this.lastLane;
	},
	canSpawnFish: function canSpawnFish(fishX) {
		// Check if enough distance from last spawn
		var distance = Math.abs(fishX - this.lastSpawnX);
		return distance >= this.minDistanceBetweenFish;
	},
	registerSpawn: function registerSpawn(fishX) {
		this.lastSpawnX = fishX;
	},
	reset: function reset() {
		this.lastLane = -1;
		this.lastSpawnX = -1000;
	}
};
/**** 
* Game Configuration
****/ 
game.up = function (x, y, obj) {
	// Note: We don't play buttonClick sound on 'up' typically, only on 'down'.
	switch (GameState.currentScreen) {
		case 'title':
			// title screen up actions (if any)
			break;
		case 'levelSelect':
			// level select screen up actions (if any, usually 'down' is enough for buttons)
			break;
		case 'fishing':
			handleFishingInput(x, y, false); // false for isUp
			break;
		case 'results':
			// results screen up actions (if any)
			break;
	}
};
var GAME_CONFIG = {
	SCREEN_CENTER_X: 1024,
	SCREEN_CENTER_Y: 900,
	// Adjusted, though less critical with lanes
	BOAT_Y: 573,
	// Original 300 + 273 (maintains original offset from water surface)
	WATER_SURFACE_Y: 623,
	// Original 350 + 273 (273 is 10% of 2732 screen height, rounded down)
	// 3 Lane System
	// Vertically spread so that the second lowest hook (lane 1) is at the center of the screen
	LANES: [{
		y: 723,
		// Top lane: center - 600
		name: "shallow"
	}, {
		y: 1366,
		// Middle lane: center of screen (1366)
		name: "medium"
	}, {
		y: 2009,
		// Bottom lane: center + 643
		name: "deep"
	}],
	// Timing windows
	PERFECT_WINDOW: 40,
	GOOD_WINDOW: 80,
	MISS_WINDOW: 120,
	// Depth levels - much lower money values! (Upgrade costs and song costs might need re-balancing with new mechanics)
	DEPTHS: [{
		level: 1,
		name: "Shallow Waters",
		fishSpeed: 6,
		fishValue: 1,
		upgradeCost: 0,
		// Starting depth
		songs: [{
			name: "Gentle Waves",
			bpm: 100,
			duration: 60000,
			pattern: "simple",
			cost: 0
		}, {
			name: "Morning Tide",
			bpm: 110,
			duration: 75000,
			pattern: "simple",
			cost: 50
		}]
	}, {
		level: 2,
		name: "Mid Waters",
		fishSpeed: 7,
		fishValue: 3,
		upgradeCost: 100,
		songs: [{
			name: "Ocean Current",
			bpm: 120,
			duration: 90000,
			pattern: "medium",
			cost: 0
		}, {
			name: "Deep Flow",
			bpm: 125,
			duration: 100000,
			pattern: "medium",
			cost: 150
		}]
	}, {
		level: 3,
		name: "Deep Waters",
		fishSpeed: 8,
		fishValue: 6,
		upgradeCost: 400,
		songs: [{
			name: "Storm Surge",
			bpm: 140,
			duration: 120000,
			pattern: "complex",
			cost: 0
		}, {
			name: "Whirlpool",
			bpm: 150,
			duration: 135000,
			pattern: "complex",
			cost: 300
		}]
	}, {
		level: 4,
		name: "Abyss",
		fishSpeed: 9,
		fishValue: 12,
		upgradeCost: 1000,
		songs: [{
			name: "Leviathan",
			bpm: 160,
			duration: 150000,
			pattern: "expert",
			cost: 0
		}, {
			name: "Deep Trench",
			bpm: 170,
			duration: 180000,
			pattern: "expert",
			cost: 600
		}]
	}],
	// Updated patterns with hold fish - reduced frequency for playability
	PATTERNS: {
		simple: {
			beatsPerFish: 2,
			// Increased from 1 - fish every 2 beats
			doubleSpawnChance: 0,
			// No double spawns in simple
			rareSpawnChance: 0.02,
			holdFishChance: 0.05 // Reduced from 0.1
		},
		medium: {
			beatsPerFish: 1.5,
			// Increased from 0.75
			doubleSpawnChance: 0,
			// No double spawns
			rareSpawnChance: 0.05,
			holdFishChance: 0.1 // Reduced from 0.2
		},
		complex: {
			beatsPerFish: 1,
			// Increased from 0.5
			doubleSpawnChance: 0,
			// No double spawns
			rareSpawnChance: 0.08,
			holdFishChance: 0.15 // Reduced from 0.3
		},
		expert: {
			beatsPerFish: 0.75,
			// Increased from 0.25
			doubleSpawnChance: 0,
			// No double spawns
			rareSpawnChance: 0.12,
			holdFishChance: 0.2 // Reduced from 0.4
		}
	}
};
/**** 
* Game State Management
****/ 
var GameState = {
	// Game flow
	currentScreen: 'title',
	// 'title', 'levelSelect', 'fishing', 'results'
	// Player progression
	currentDepth: 0,
	money: 0,
	totalFishCaught: 0,
	ownedSongs: [],
	// Array of {depth, songIndex} objects
	// Level selection
	selectedDepth: 0,
	selectedSong: 0,
	// Current session
	sessionScore: 0,
	sessionFishCaught: 0,
	sessionFishSpawned: 0,
	combo: 0,
	maxCombo: 0,
	// Game state
	gameActive: false,
	songStartTime: 0,
	lastBeatTime: 0,
	beatCount: 0,
	// Initialize owned songs (first song of each unlocked depth is free)
	initOwnedSongs: function initOwnedSongs() {
		this.ownedSongs = [];
		for (var i = 0; i <= this.currentDepth; i++) {
			this.ownedSongs.push({
				depth: i,
				songIndex: 0
			});
		}
	},
	hasSong: function hasSong(depth, songIndex) {
		return this.ownedSongs.some(function (song) {
			return song.depth === depth && song.songIndex === songIndex;
		});
	},
	buySong: function buySong(depth, songIndex) {
		var song = GAME_CONFIG.DEPTHS[depth].songs[songIndex];
		if (this.money >= song.cost && !this.hasSong(depth, songIndex)) {
			this.money -= song.cost;
			this.ownedSongs.push({
				depth: depth,
				songIndex: songIndex
			});
			return true;
		}
		return false;
	},
	getCurrentDepthConfig: function getCurrentDepthConfig() {
		return GAME_CONFIG.DEPTHS[this.selectedDepth];
	},
	getCurrentSongConfig: function getCurrentSongConfig() {
		return GAME_CONFIG.DEPTHS[this.selectedDepth].songs[this.selectedSong];
	},
	canUpgrade: function canUpgrade() {
		var nextDepth = GAME_CONFIG.DEPTHS[this.currentDepth + 1];
		return nextDepth && this.money >= nextDepth.upgradeCost;
	},
	upgrade: function upgrade() {
		if (this.canUpgrade()) {
			var nextDepth = GAME_CONFIG.DEPTHS[this.currentDepth + 1];
			this.money -= nextDepth.upgradeCost;
			this.currentDepth++;
			// Give free first song of new depth
			this.ownedSongs.push({
				depth: this.currentDepth,
				songIndex: 0
			});
			return true;
		}
		return false;
	}
};
var titleScreen = game.addChild(new Container());
var levelSelectScreen = game.addChild(new Container());
var fishingScreen = game.addChild(new Container());
var resultsScreen = game.addChild(new Container());
// Initialize
GameState.initOwnedSongs();
/**** 
* Title Screen
****/ 
function createTitleScreen() {
	var titleBg = titleScreen.addChild(LK.getAsset('screenBackground', {
		x: 0,
		y: 0,
		alpha: 0.3
	}));
	// Logo
	var logo = new Text2('BEAT FISHER', {
		size: 150,
		fill: 0xFFFFFF
	});
	logo.anchor.set(0.5, 0.5);
	logo.x = GAME_CONFIG.SCREEN_CENTER_X;
	logo.y = 600;
	titleScreen.addChild(logo);
	var subtitle = new Text2('Rhythm Fishing Adventure', {
		size: 60,
		fill: 0x4FC3F7
	});
	subtitle.anchor.set(0.5, 0.5);
	subtitle.x = GAME_CONFIG.SCREEN_CENTER_X;
	subtitle.y = 700;
	titleScreen.addChild(subtitle);
	// Start button
	var startButton = titleScreen.addChild(LK.getAsset('bigButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: GAME_CONFIG.SCREEN_CENTER_X,
		y: 1000
	}));
	var startText = new Text2('START', {
		size: 50,
		fill: 0xFFFFFF
	});
	startText.anchor.set(0.5, 0.5);
	startText.x = GAME_CONFIG.SCREEN_CENTER_X;
	startText.y = 1000;
	titleScreen.addChild(startText);
	// Tutorial button
	var tutorialButton = titleScreen.addChild(LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: GAME_CONFIG.SCREEN_CENTER_X,
		y: 1150,
		tint: 0x757575
	}));
	var tutorialText = new Text2('TUTORIAL', {
		size: 40,
		fill: 0xFFFFFF
	});
	tutorialText.anchor.set(0.5, 0.5);
	tutorialText.x = GAME_CONFIG.SCREEN_CENTER_X;
	tutorialText.y = 1150;
	titleScreen.addChild(tutorialText);
	return {
		startButton: startButton,
		tutorialButton: tutorialButton
	};
}
/**** 
* Level Select Screen
****/ 
function createLevelSelectScreen() {
	var selectBg = levelSelectScreen.addChild(LK.getAsset('screenBackground', {
		x: 0,
		y: 0,
		alpha: 0.8
	}));
	// Title
	var title = new Text2('SELECT FISHING SPOT', {
		size: 80,
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0.5);
	title.x = GAME_CONFIG.SCREEN_CENTER_X;
	title.y = 200;
	levelSelectScreen.addChild(title);
	// Money display
	var moneyDisplay = new Text2('Money: $0', {
		size: 60,
		fill: 0xFFD700
	});
	moneyDisplay.anchor.set(1, 0);
	moneyDisplay.x = 1900;
	moneyDisplay.y = 100;
	levelSelectScreen.addChild(moneyDisplay);
	// Depth tabs (will be created dynamically)
	var depthTabs = [];
	// Song display area
	var songCard = levelSelectScreen.addChild(LK.getAsset('songCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: GAME_CONFIG.SCREEN_CENTER_X,
		y: 700
	}));
	// Song navigation arrows
	var leftArrow = levelSelectScreen.addChild(LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 400,
		y: 700,
		tint: 0x666666
	}));
	var leftArrowText = new Text2('<', {
		size: 60,
		fill: 0xFFFFFF
	});
	leftArrowText.anchor.set(0.5, 0.5);
	leftArrowText.x = 400;
	leftArrowText.y = 700;
	levelSelectScreen.addChild(leftArrowText);
	var rightArrow = levelSelectScreen.addChild(LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1648,
		y: 700,
		tint: 0x666666
	}));
	var rightArrowText = new Text2('>', {
		size: 60,
		fill: 0xFFFFFF
	});
	rightArrowText.anchor.set(0.5, 0.5);
	rightArrowText.x = 1648;
	rightArrowText.y = 700;
	levelSelectScreen.addChild(rightArrowText);
	// Song info (will be updated dynamically)
	var songTitle = new Text2('Song Title', {
		size: 50,
		fill: 0xFFFFFF
	});
	songTitle.anchor.set(0.5, 0.5);
	songTitle.x = GAME_CONFIG.SCREEN_CENTER_X;
	songTitle.y = 650;
	levelSelectScreen.addChild(songTitle);
	var songInfo = new Text2('BPM: 120 | Duration: 2:00', {
		size: 30,
		fill: 0xCCCCCC
	});
	songInfo.anchor.set(0.5, 0.5);
	songInfo.x = GAME_CONFIG.SCREEN_CENTER_X;
	songInfo.y = 700;
	levelSelectScreen.addChild(songInfo);
	var songEarnings = new Text2('Potential Earnings: $50-100', {
		size: 30,
		fill: 0x4CAF50
	});
	songEarnings.anchor.set(0.5, 0.5);
	songEarnings.x = GAME_CONFIG.SCREEN_CENTER_X;
	songEarnings.y = 730;
	levelSelectScreen.addChild(songEarnings);
	// Play/Buy button
	var playButton = levelSelectScreen.addChild(LK.getAsset('bigButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: GAME_CONFIG.SCREEN_CENTER_X,
		y: 900
	}));
	var playButtonText = new Text2('PLAY', {
		size: 50,
		fill: 0xFFFFFF
	});
	playButtonText.anchor.set(0.5, 0.5);
	playButtonText.x = GAME_CONFIG.SCREEN_CENTER_X;
	playButtonText.y = 900;
	levelSelectScreen.addChild(playButtonText);
	// Shop button
	var shopButton = levelSelectScreen.addChild(LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: GAME_CONFIG.SCREEN_CENTER_X,
		y: 1100,
		tint: 0x2e7d32
	}));
	var shopButtonText = new Text2('UPGRADE ROD', {
		size: 40,
		fill: 0xFFFFFF
	});
	shopButtonText.anchor.set(0.5, 0.5);
	shopButtonText.x = GAME_CONFIG.SCREEN_CENTER_X;
	shopButtonText.y = 1100;
	levelSelectScreen.addChild(shopButtonText);
	// Back button
	var backButton = levelSelectScreen.addChild(LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 200,
		y: 200,
		tint: 0x757575
	}));
	var backButtonText = new Text2('BACK', {
		size: 40,
		fill: 0xFFFFFF
	});
	backButtonText.anchor.set(0.5, 0.5);
	backButtonText.x = 200;
	backButtonText.y = 200;
	levelSelectScreen.addChild(backButtonText);
	return {
		moneyDisplay: moneyDisplay,
		depthTabs: depthTabs,
		leftArrow: leftArrow,
		rightArrow: rightArrow,
		songTitle: songTitle,
		songInfo: songInfo,
		songEarnings: songEarnings,
		playButton: playButton,
		playButtonText: playButtonText,
		shopButton: shopButton,
		shopButtonText: shopButtonText,
		backButton: backButton
	};
}
/**** 
* Fishing Screen
****/ 
function createFishingScreen() {
	// Water background
	var water = fishingScreen.addChild(LK.getAsset('water', {
		x: 0,
		y: GAME_CONFIG.WATER_SURFACE_Y,
		//{3l} // Adjusted to new config if different
		width: 2048,
		// Ensure it covers screen width
		height: 2732 - GAME_CONFIG.WATER_SURFACE_Y,
		// Ensure it covers below surface
		alpha: 0.7
	}));
	// Water surface
	var waterSurface = fishingScreen.addChild(LK.getAsset('waterSurface', {
		x: 0,
		y: GAME_CONFIG.WATER_SURFACE_Y,
		width: 2048,
		alpha: 0.8
	}));
	// Boat
	var boat = fishingScreen.addChild(LK.getAsset('boat', {
		anchorX: 0.5,
		anchorY: 1,
		// Anchor at bottom-middle of boat asset
		x: GAME_CONFIG.SCREEN_CENTER_X,
		y: GAME_CONFIG.WATER_SURFACE_Y // Boat sits on water surface
	}));
	// Calculate X positions for the 3 hooks, spaced along the boat's width
	// Using boat.width / 3 as the offset from the center for the side hooks
	var boatWidth = boat.width; // Actual width of the boat asset
	var hookXPositions = [GAME_CONFIG.SCREEN_CENTER_X - boatWidth / 3, GAME_CONFIG.SCREEN_CENTER_X, GAME_CONFIG.SCREEN_CENTER_X + boatWidth / 3];
	// Create 3 fishing lines and hooks
	var hooks = [];
	var lines = [];
	for (var i = 0; i < 3; i++) {
		var lane = GAME_CONFIG.LANES[i];
		var currentHookX = hookXPositions[i];
		// Fishing line
		var line = fishingScreen.addChild(LK.getAsset('fishingLine', {
			anchorX: 0.5,
			anchorY: 0,
			// Anchor at top-middle of line asset
			x: currentHookX,
			// Set X position for this specific line
			y: GAME_CONFIG.WATER_SURFACE_Y,
			height: lane.y - GAME_CONFIG.WATER_SURFACE_Y // Line extends to hook depth (varying length)
		}));
		lines.push(line);
		// Hook
		var hook = fishingScreen.addChild(LK.getAsset('hook', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: currentHookX,
			// Set X position for this specific hook
			y: lane.y // Hook Y is at the specific lane's depth
		}));
		hook.originalY = lane.y; // Store original Y for animation
		hook.lane = i; // Store lane index on hook
		hooks.push(hook);
	}
	// Lane indicators (simple text for now)
	var laneLabels = [];
	var laneNames = ['SHALLOW', 'MEDIUM', 'DEEP']; // Example names
	for (var i = 0; i < 3; i++) {
		var label = new Text2(laneNames[i], {
			size: 30,
			fill: 0xFFFFFF,
			alpha: 0.7
		});
		label.anchor.set(0, 0.5); // Anchor left-middle
		label.x = 50; // Position on the left side
		label.y = GAME_CONFIG.LANES[i].y; // Align with lane Y (now matches new vertical spread)
		fishingScreen.addChild(label);
		laneLabels.push(label);
	}
	// UI elements
	var scoreText = new Text2('Score: 0', {
		size: 50,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(0, 0);
	scoreText.x = 50;
	scoreText.y = 50;
	fishingScreen.addChild(scoreText);
	var fishText = new Text2('Fish: 0/0', {
		size: 40,
		fill: 0xFFFFFF
	});
	fishText.anchor.set(0, 0);
	fishText.x = 50;
	fishText.y = 120;
	fishingScreen.addChild(fishText);
	var comboText = new Text2('Combo: 0', {
		size: 40,
		fill: 0xFF9800
	});
	comboText.anchor.set(0, 0);
	comboText.x = 50;
	comboText.y = 180; // Corrected typo from y: 180
	fishingScreen.addChild(comboText);
	// Song progress - Re-added as it's used by updateFishingUI
	var progressText = new Text2('0:00 / 0:00', {
		size: 40,
		fill: 0x4FC3F7
	});
	progressText.anchor.set(1, 0); // Anchor top-right
	progressText.x = 2048 - 50; // Position on the top-right side
	progressText.y = 50;
	fishingScreen.addChild(progressText);
	// Hold instruction Text
	var holdText = new Text2('TAP: Normal Fish  |  HOLD: Golden Fish', {
		size: 35,
		fill: 0xFFD700,
		// Golden color for emphasis
		alpha: 0.8
	});
	holdText.anchor.set(0.5, 0); // Anchor top-center
	holdText.x = GAME_CONFIG.SCREEN_CENTER_X;
	holdText.y = GAME_CONFIG.LANES[GAME_CONFIG.LANES.length - 1].y + 100; // Below the last lane (now matches new vertical spread)
	fishingScreen.addChild(holdText);
	return {
		boat: boat,
		hooks: hooks,
		// Array of 3 hooks
		lines: lines,
		// Array of 3 lines
		laneLabels: laneLabels,
		scoreText: scoreText,
		fishText: fishText,
		comboText: comboText,
		progressText: progressText // Ensure progressText is returned
	};
}
/**** 
* Initialize Screen Elements
****/ 
var titleElements = createTitleScreen();
var levelSelectElements = createLevelSelectScreen();
var fishingElements = createFishingScreen();
// Feedback indicators are now created on-demand by the showFeedback function.
// The global feedbackIndicators object is no longer needed.
// Game variables
var fishArray = [];
/**** 
* Input State and Helpers for Fishing
****/ 
var inputState = {
	touching: false,
	// Is the screen currently being touched?
	touchLane: -1,
	// Which lane was the touch initiated in? (0, 1, 2)
	touchStartTime: 0,
	// Timestamp of when the touch started (LK.ticks based)
	holdFish: null // Reference to a fish if a hold action is being performed on it
};
// Determines which lane a Y coordinate falls into
function getTouchLane(y) {
	// Use new lane boundaries based on updated vertical spread
	var lane0Max = (GAME_CONFIG.LANES[0].y + GAME_CONFIG.LANES[1].y) / 2; // halfway between lane 0 and 1
	var lane1Max = (GAME_CONFIG.LANES[1].y + GAME_CONFIG.LANES[2].y) / 2; // halfway between lane 1 and 2
	if (y < lane0Max) return 0;else if (y < lane1Max) return 1;else return 2;
}
// Shows feedback (perfect, good, miss) at the specified lane
function showFeedback(type, laneIndex) {
	var feedbackY = GAME_CONFIG.LANES[laneIndex].y;
	var indicator = new FeedbackIndicator(type); // Creates a new indicator e.g. FeedbackIndicator('perfect')
	// Position feedback at the X coordinate of the hook in the specified lane
	indicator.x = fishingElements.hooks[laneIndex].x;
	indicator.y = feedbackY; // Feedback appears at the lane's Y
	fishingScreen.addChild(indicator);
	indicator.show(); // Triggers the animation and self-destruction
}
// Animates the hook in a specific lane after a catch attempt
function animateHookCatch(laneIndex) {
	if (laneIndex < 0 || laneIndex >= fishingElements.hooks.length) return; // Safety check
	var hook = fishingElements.hooks[laneIndex];
	var originalY = hook.originalY;
	// Quick bobbing animation for the hook in the specified lane
	tween(hook, {
		y: originalY - 30
	}, {
		duration: 150,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(hook, {
				y: originalY
			}, {
				duration: 150,
				easing: tween.easeIn
			});
		}
	});
}
// Handles input specifically for the fishing screen (down and up events)
function handleFishingInput(x, y, isDown) {
	if (!GameState.gameActive) return;
	var touchLane = getTouchLane(y); // Determine which lane the interaction is in
	var currentTime = LK.ticks * (1000 / 60); // Current time in ms
	if (isDown) {
		// Touch started
		inputState.touching = true;
		inputState.touchLane = touchLane;
		inputState.touchStartTime = currentTime;
		inputState.holdFish = null; // Reset any previous hold target
		// Check if this touch might be starting a hold on a holdable fish in this lane
		for (var i = 0; i < fishArray.length; i++) {
			var fish = fishArray[i];
			if (fish.lane === touchLane && fish.isHoldFish && !fish.caught) {
				// Use the X position of the hook in the current touchLane for distance calculation
				var hookXForLane = fishingElements.hooks[touchLane].x;
				var distanceToHook = Math.abs(fish.x - hookXForLane);
				// Check if the fish is close enough to the hook to be considered for a hold
				if (distanceToHook < GAME_CONFIG.MISS_WINDOW + 20) {
					// Slightly larger window for initiating hold
					inputState.holdFish = fish; // Mark this fish as the potential target of a hold
					// Visual cue for starting hold could be added here (e.g., hook wiggles)
					break;
				}
			}
		}
	} else {
		// Touch ended
		if (inputState.touching && inputState.touchLane === touchLane) {
			// Ensure this 'up' corresponds to an active 'down' in the same lane
			var holdDuration = currentTime - inputState.touchStartTime;
			// Determine if it was a tap or a hold based on duration
			// Minimum duration for a gesture to be considered a "hold" attempt
			var isHoldAttempt = holdDuration > 200;
			checkCatch(touchLane, isHoldAttempt, holdDuration);
		}
		inputState.touching = false; // Reset touching state
		inputState.holdFish = null; // Reset hold target
	}
}
/**** 
* Screen Management
****/ 
function showScreen(screenName) {
	titleScreen.visible = false;
	levelSelectScreen.visible = false;
	fishingScreen.visible = false;
	resultsScreen.visible = false;
	GameState.currentScreen = screenName;
	switch (screenName) {
		case 'title':
			titleScreen.visible = true;
			break;
		case 'levelSelect':
			levelSelectScreen.visible = true;
			updateLevelSelectScreen();
			break;
		case 'fishing':
			fishingScreen.visible = true;
			startFishingSession();
			break;
		case 'results':
			resultsScreen.visible = true;
			break;
	}
}
/**** 
* Level Select Logic
****/ 
function updateLevelSelectScreen() {
	var elements = levelSelectElements;
	// Update money display
	elements.moneyDisplay.setText('Money: $' + GameState.money);
	// Create depth tabs
	createDepthTabs();
	// Update song display
	updateSongDisplay();
	// Update shop button
	updateShopButton();
}
function createDepthTabs() {
	// Clear existing tabs
	levelSelectElements.depthTabs.forEach(function (tab) {
		if (tab.container) tab.container.destroy();
	});
	levelSelectElements.depthTabs = [];
	// Create tabs for unlocked depths
	for (var i = 0; i <= GameState.currentDepth; i++) {
		var depth = GAME_CONFIG.DEPTHS[i];
		var isSelected = i === GameState.selectedDepth;
		var tabContainer = levelSelectScreen.addChild(new Container());
		var tab = tabContainer.addChild(LK.getAsset('depthTab', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 300 + i * 220,
			y: 400,
			tint: isSelected ? 0x1976d2 : 0x455a64
		}));
		var tabText = new Text2(depth.name.split(' ')[0], {
			size: 30,
			fill: 0xFFFFFF
		});
		tabText.anchor.set(0.5, 0.5);
		tabText.x = 300 + i * 220;
		tabText.y = 400;
		tabContainer.addChild(tabText);
		levelSelectElements.depthTabs.push({
			container: tabContainer,
			tab: tab,
			depthIndex: i
		});
	}
}
function updateSongDisplay() {
	var elements = levelSelectElements;
	var depth = GAME_CONFIG.DEPTHS[GameState.selectedDepth];
	var song = depth.songs[GameState.selectedSong];
	var owned = GameState.hasSong(GameState.selectedDepth, GameState.selectedSong);
	// Update song info
	elements.songTitle.setText(song.name);
	elements.songInfo.setText('BPM: ' + song.bpm + ' | Duration: ' + formatTime(song.duration));
	// Calculate potential earnings
	var minEarnings = Math.floor(depth.fishValue * 20); // Conservative estimate
	var maxEarnings = Math.floor(depth.fishValue * 60); // With combos and rare fish
	elements.songEarnings.setText('Potential Earnings: $' + minEarnings + '-$' + maxEarnings);
	// Update play/buy button
	if (owned) {
		elements.playButtonText.setText('PLAY');
		elements.playButton.tint = 0x1976d2;
	} else {
		elements.playButtonText.setText('BUY ($' + song.cost + ')');
		elements.playButton.tint = GameState.money >= song.cost ? 0x2e7d32 : 0x666666;
	}
	// Update arrow states
	elements.leftArrow.tint = GameState.selectedSong > 0 ? 0x1976d2 : 0x666666;
	elements.rightArrow.tint = GameState.selectedSong < depth.songs.length - 1 ? 0x1976d2 : 0x666666;
}
function updateShopButton() {
	var elements = levelSelectElements;
	var canUpgrade = GameState.canUpgrade();
	var nextDepth = GAME_CONFIG.DEPTHS[GameState.currentDepth + 1];
	if (nextDepth) {
		elements.shopButtonText.setText('UPGRADE ROD ($' + nextDepth.upgradeCost + ')');
		elements.shopButton.tint = canUpgrade ? 0x2e7d32 : 0x666666;
	} else {
		elements.shopButtonText.setText('MAX DEPTH REACHED');
		elements.shopButton.tint = 0x666666;
	}
}
function formatTime(ms) {
	var seconds = Math.floor(ms / 1000);
	var minutes = Math.floor(seconds / 60);
	seconds = seconds % 60;
	return minutes + ':' + (seconds < 10 ? '0' : '') + seconds;
}
/**** 
* Fishing Game Logic
****/ 
function startFishingSession() {
	// Reset session state
	GameState.sessionScore = 0;
	GameState.sessionFishCaught = 0;
	GameState.sessionFishSpawned = 0;
	GameState.combo = 0;
	GameState.maxCombo = 0;
	GameState.gameActive = true;
	GameState.songStartTime = 0;
	GameState.lastBeatTime = 0;
	GameState.beatCount = 0;
	// Clear any existing fish
	fishArray.forEach(function (fish) {
		fish.destroy();
	});
	fishArray = [];
	// Reset pattern generator for new session
	PatternGenerator.reset();
	// Start music
	LK.playMusic('rhythmTrack');
}
function spawnFish() {
	var depthConfig = GameState.getCurrentDepthConfig();
	var songConfig = GameState.getCurrentSongConfig();
	var pattern = GAME_CONFIG.PATTERNS[songConfig.pattern];
	// Skip spawn if pattern says no double spawns
	if (pattern.doubleSpawnChance === 0) {
		// Check if any fish are too close to spawn position
		for (var i = 0; i < fishArray.length; i++) {
			var fish = fishArray[i];
			if (Math.abs(fish.x - GAME_CONFIG.SCREEN_CENTER_X) < PatternGenerator.minDistanceBetweenFish) {
				return; // Skip this spawn
			}
		}
	}
	// Use pattern generator to choose lane
	var laneIndex = PatternGenerator.getNextLane();
	var targetLane = GAME_CONFIG.LANES[laneIndex];
	// Determine if this is a hold fish
	var isHoldFish = Math.random() < (pattern.holdFishChance || 0);
	// Determine fish type and value
	var fishType, fishValue;
	var rand = Math.random();
	if (rand < pattern.rareSpawnChance) {
		fishType = 'rare';
		fishValue = depthConfig.fishValue * 4; // Rare fish are more valuable
	} else if (GameState.selectedDepth >= 2 && rand < 0.3) {
		// Example: deep fish appear more in deeper levels
		fishType = 'deep';
		fishValue = Math.floor(depthConfig.fishValue * 2);
	} else if (GameState.selectedDepth >= 1 && rand < 0.6) {
		// Example: medium fish
		fishType = 'medium';
		fishValue = Math.floor(depthConfig.fishValue * 1.5);
	} else {
		fishType = 'shallow'; // Common fish
		fishValue = depthConfig.fishValue;
	}
	// Bonus value for hold fish
	if (isHoldFish) {
		fishValue = Math.floor(fishValue * 1.5); // Hold fish are worth more
	}
	var fishSpeed = Math.random() < 0.5 ? depthConfig.fishSpeed : -depthConfig.fishSpeed;
	// Create fish
	var fish = new Fish(fishType, fishValue, fishSpeed, laneIndex,
	// Pass lane index
	isHoldFish // Pass hold status
	);
	fish.x = fish.speed > 0 ? -150 : 2048 + 150; // Start off-screen
	fish.y = targetLane.y; // Set Y to the chosen lane's Y
	fishArray.push(fish);
	fishingScreen.addChild(fish);
	GameState.sessionFishSpawned++;
	// Register spawn position for pattern tracking
	PatternGenerator.registerSpawn(GAME_CONFIG.SCREEN_CENTER_X);
}
function checkCatch(touchLane, isHoldAction, holdDurationMs) {
	// Get the X position of the hook in the specific lane the player interacted with
	var hookX = fishingElements.hooks[touchLane].x;
	var closestFishInLane = null;
	var closestDistance = Infinity;
	// Find the closest fish in the *touched lane* that hasn't been caught
	for (var i = 0; i < fishArray.length; i++) {
		var fish = fishArray[i];
		if (!fish.caught && fish.lane === touchLane) {
			var distance = Math.abs(fish.x - hookX);
			if (distance < closestDistance) {
				closestDistance = distance;
				closestFishInLane = fish;
			}
		}
	}
	if (!closestFishInLane) {
		showFeedback('miss', touchLane);
		LK.getSound('miss').play();
		GameState.combo = 0;
		return;
	}
	// --- Hold Fish Logic ---
	if (closestFishInLane.isHoldFish) {
		if (!isHoldAction) {
			// Tapped a hold fish
			showFeedback('miss', touchLane);
			LK.getSound('miss').play();
			GameState.combo = 0;
			return;
		}
		if (holdDurationMs < closestFishInLane.requiredHoldTime) {
			// Held, but not long enough
			showFeedback('miss', touchLane);
			LK.getSound('miss').play();
			GameState.combo = 0;
			return;
		}
	} else {
		// Normal Fish
		if (isHoldAction) {
			// Held a normal fish (counts as miss/mistake)
			showFeedback('miss', touchLane);
			LK.getSound('miss').play();
			GameState.combo = 0;
			return;
		}
	}
	// --- End Hold Fish Logic ---
	var points = 0;
	var multiplier = Math.max(1, Math.floor(GameState.combo / 10) + 1);
	if (closestDistance < GAME_CONFIG.PERFECT_WINDOW) {
		points = closestFishInLane.value * 2 * multiplier;
		showFeedback('perfect', touchLane);
		GameState.combo++;
	} else if (closestDistance < GAME_CONFIG.GOOD_WINDOW) {
		points = closestFishInLane.value * multiplier;
		showFeedback('good', touchLane);
		GameState.combo++;
	} else if (closestDistance < GAME_CONFIG.MISS_WINDOW) {
		// Forgiving 'good' for near misses if it's not a hold fish requiring precise timing
		// or if it is a hold fish and they met the hold duration.
		points = Math.max(1, Math.floor(closestFishInLane.value * 0.5 * multiplier));
		showFeedback('good', touchLane); //{4Y} 
		GameState.combo++;
	} else {
		showFeedback('miss', touchLane);
		LK.getSound('miss').play();
		GameState.combo = 0;
		return;
	}
	// Successfully caught fish
	closestFishInLane.catchFish();
	var fishIndex = fishArray.indexOf(closestFishInLane);
	if (fishIndex > -1) {
		fishArray.splice(fishIndex, 1);
	}
	GameState.sessionScore += points;
	GameState.money += points; // Player earns money from catches
	GameState.sessionFishCaught++;
	GameState.totalFishCaught++;
	GameState.maxCombo = Math.max(GameState.maxCombo, GameState.combo);
	LK.getSound('catch').play();
	animateHookCatch(touchLane); // Animate the specific hook
}
// Note: The old animateHookCatch function that was defined right after checkCatch
// is now a global helper: animateHookCatch(laneIndex), defined earlier.
// We remove the old local one if it existed here by not re-inserting it.
function updateFishingUI() {
	var elements = fishingElements;
	elements.scoreText.setText('Score: ' + GameState.sessionScore);
	elements.fishText.setText('Fish: ' + GameState.sessionFishCaught + '/' + GameState.sessionFishSpawned);
	elements.comboText.setText('Combo: ' + GameState.combo);
	// Update progress
	if (GameState.songStartTime > 0) {
		var currentTime = LK.ticks * (1000 / 60);
		var elapsed = currentTime - GameState.songStartTime;
		var songConfig = GameState.getCurrentSongConfig();
		elements.progressText.setText(formatTime(elapsed) + ' / ' + formatTime(songConfig.duration));
	}
}
function endFishingSession() {
	GameState.gameActive = false;
	// Clear fish
	fishArray.forEach(function (fish) {
		fish.destroy();
	});
	fishArray = [];
	// Create results screen
	createResultsScreen();
	showScreen('results');
}
function createResultsScreen() {
	// Clear previous results
	resultsScreen.removeChildren();
	var resultsBg = resultsScreen.addChild(LK.getAsset('screenBackground', {
		x: 0,
		y: 0,
		alpha: 0.9
	}));
	var title = new Text2('Fishing Complete!', {
		size: 100,
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0.5);
	title.x = GAME_CONFIG.SCREEN_CENTER_X;
	title.y = 400;
	resultsScreen.addChild(title);
	var scoreResult = new Text2('Score: ' + GameState.sessionScore, {
		size: 70,
		fill: 0xFFD700
	});
	scoreResult.anchor.set(0.5, 0.5);
	scoreResult.x = GAME_CONFIG.SCREEN_CENTER_X;
	scoreResult.y = 550;
	resultsScreen.addChild(scoreResult);
	var fishResult = new Text2('Fish Caught: ' + GameState.sessionFishCaught + '/' + GameState.sessionFishSpawned, {
		size: 50,
		fill: 0xFFFFFF
	});
	fishResult.anchor.set(0.5, 0.5);
	fishResult.x = GAME_CONFIG.SCREEN_CENTER_X;
	fishResult.y = 650;
	resultsScreen.addChild(fishResult);
	var comboResult = new Text2('Max Combo: ' + GameState.maxCombo, {
		size: 50,
		fill: 0xFF9800
	});
	comboResult.anchor.set(0.5, 0.5);
	comboResult.x = GAME_CONFIG.SCREEN_CENTER_X;
	comboResult.y = 750;
	resultsScreen.addChild(comboResult);
	var moneyEarned = new Text2('Money Earned: $' + GameState.sessionScore, {
		size: 50,
		fill: 0x4CAF50
	});
	moneyEarned.anchor.set(0.5, 0.5);
	moneyEarned.x = GAME_CONFIG.SCREEN_CENTER_X;
	moneyEarned.y = 850;
	resultsScreen.addChild(moneyEarned);
	// Accuracy
	var accuracy = GameState.sessionFishSpawned > 0 ? Math.round(GameState.sessionFishCaught / GameState.sessionFishSpawned * 100) : 0;
	var accuracyResult = new Text2('Accuracy: ' + accuracy + '%', {
		size: 50,
		fill: 0x2196F3
	});
	accuracyResult.anchor.set(0.5, 0.5);
	accuracyResult.x = GAME_CONFIG.SCREEN_CENTER_X;
	accuracyResult.y = 950;
	resultsScreen.addChild(accuracyResult);
	// Continue button
	var continueButton = resultsScreen.addChild(LK.getAsset('bigButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: GAME_CONFIG.SCREEN_CENTER_X,
		y: 1200
	}));
	var continueText = new Text2('CONTINUE', {
		size: 50,
		fill: 0xFFFFFF
	});
	continueText.anchor.set(0.5, 0.5);
	continueText.x = GAME_CONFIG.SCREEN_CENTER_X;
	continueText.y = 1200;
	resultsScreen.addChild(continueText);
	// Fade in
	resultsScreen.alpha = 0;
	tween(resultsScreen, {
		alpha: 1
	}, {
		duration: 500,
		easing: tween.easeOut
	});
}
/**** 
* Input Handling
****/ 
game.down = function (x, y, obj) {
	LK.getSound('buttonClick').play();
	switch (GameState.currentScreen) {
		case 'title':
			// Check if click is within start button bounds
			var startButton = titleElements.startButton;
			if (x >= startButton.x - startButton.width / 2 && x <= startButton.x + startButton.width / 2 && y >= startButton.y - startButton.height / 2 && y <= startButton.y + startButton.height / 2) {
				showScreen('levelSelect');
			}
			// Check if click is within tutorial button bounds
			var tutorialButton = titleElements.tutorialButton;
			if (x >= tutorialButton.x - tutorialButton.width / 2 && x <= tutorialButton.x + tutorialButton.width / 2 && y >= tutorialButton.y - tutorialButton.height / 2 && y <= tutorialButton.y + tutorialButton.height / 2) {
				// TODO: Show tutorial
			}
			break;
		case 'levelSelect':
			handleLevelSelectInput(x, y);
			break;
		case 'fishing':
			handleFishingInput(x, y, true); // true for isDown
			break;
		case 'results':
			showScreen('levelSelect');
			break;
	}
};
function handleLevelSelectInput(x, y) {
	var elements = levelSelectElements;
	// Check depth tabs
	elements.depthTabs.forEach(function (tab) {
		var tabAsset = tab.tab;
		if (x >= tabAsset.x - tabAsset.width / 2 && x <= tabAsset.x + tabAsset.width / 2 && y >= tabAsset.y - tabAsset.height / 2 && y <= tabAsset.y + tabAsset.height / 2) {
			GameState.selectedDepth = tab.depthIndex;
			GameState.selectedSong = 0; // Reset to first song
			updateLevelSelectScreen();
		}
	});
	// Check song navigation
	var leftArrow = elements.leftArrow;
	if (x >= leftArrow.x - leftArrow.width / 2 && x <= leftArrow.x + leftArrow.width / 2 && y >= leftArrow.y - leftArrow.height / 2 && y <= leftArrow.y + leftArrow.height / 2 && GameState.selectedSong > 0) {
		GameState.selectedSong--;
		updateSongDisplay();
	}
	var rightArrow = elements.rightArrow;
	if (x >= rightArrow.x - rightArrow.width / 2 && x <= rightArrow.x + rightArrow.width / 2 && y >= rightArrow.y - rightArrow.height / 2 && y <= rightArrow.y + rightArrow.height / 2) {
		var depth = GAME_CONFIG.DEPTHS[GameState.selectedDepth];
		if (GameState.selectedSong < depth.songs.length - 1) {
			GameState.selectedSong++;
			updateSongDisplay();
		}
	}
	// Check play/buy button
	var playButton = elements.playButton;
	if (x >= playButton.x - playButton.width / 2 && x <= playButton.x + playButton.width / 2 && y >= playButton.y - playButton.height / 2 && y <= playButton.y + playButton.height / 2) {
		var owned = GameState.hasSong(GameState.selectedDepth, GameState.selectedSong);
		if (owned) {
			showScreen('fishing');
		} else {
			// Try to buy song
			if (GameState.buySong(GameState.selectedDepth, GameState.selectedSong)) {
				updateLevelSelectScreen();
			}
		}
	}
	// Check shop button
	var shopButton = elements.shopButton;
	if (x >= shopButton.x - shopButton.width / 2 && x <= shopButton.x + shopButton.width / 2 && y >= shopButton.y - shopButton.height / 2 && y <= shopButton.y + shopButton.height / 2) {
		if (GameState.upgrade()) {
			LK.getSound('upgrade').play();
			updateLevelSelectScreen();
		}
	}
	// Check back button
	var backButton = elements.backButton;
	if (x >= backButton.x - backButton.width / 2 && x <= backButton.x + backButton.width / 2 && y >= backButton.y - backButton.height / 2 && y <= backButton.y + backButton.height / 2) {
		showScreen('title');
	}
}
/**** 
* Main Game Loop
****/ 
game.update = function () {
	if (GameState.currentScreen !== 'fishing' || !GameState.gameActive) {
		return;
	}
	var currentTime = LK.ticks * (1000 / 60);
	// Initialize game timer
	if (GameState.songStartTime === 0) {
		GameState.songStartTime = currentTime;
	}
	var songConfig = GameState.getCurrentSongConfig();
	var pattern = GAME_CONFIG.PATTERNS[songConfig.pattern];
	var beatInterval = 60000 / songConfig.bpm;
	var spawnInterval = beatInterval * pattern.beatsPerFish;
	// Check song end
	if (currentTime - GameState.songStartTime >= songConfig.duration) {
		endFishingSession();
		return;
	}
	// Spawn fish on beat
	if (currentTime - GameState.lastBeatTime >= spawnInterval) {
		GameState.lastBeatTime = currentTime;
		GameState.beatCount++;
		spawnFish();
	}
	// Update fish
	for (var i = fishArray.length - 1; i >= 0; i--) {
		var fish = fishArray[i];
		fish.update();
		// Update hold fish visual state if being held
		if (fish.isHoldFish && inputState.holdFish === fish && inputState.touching) {
			var currentHoldDuration = currentTime - inputState.touchStartTime;
			// This is where you might add visual feedback for the fish being held
			// e.g., fish struggles, progress bar fills, etc.
			if (currentHoldDuration >= fish.requiredHoldTime && !fish.holdStarted) {
				fish.holdStarted = true; // Mark that the hold duration requirement was met
				// Potentially change fish graphic tint or add particle effect
				// console.log("Hold requirement met for fish: " + fish.type);
			}
		} else if (fish.isHoldFish && fish.holdStarted && !(inputState.holdFish === fish && inputState.touching)) {
			// If fish was previously 'holdStarted' but player released too early or switched targets
			fish.holdStarted = false; // Reset if no longer actively being held correctly.
		}
		// Remove off-screen fish (if not caught)
		if (!fish.caught && (fish.x < -150 || fish.x > 2048 + 150)) {
			fish.destroy();
			fishArray.splice(i, 1);
			// Optional: Penalize for missed fish if it wasn't a hold fish that was let go by design
			// if (!fish.isHoldFish) { GameState.combo = 0; } 
		}
	}
	// Update UI
	updateFishingUI();
};
// Initialize game
showScreen('title');

===================================================================
--- original.js
+++ change.js
@@ -101,8 +101,49 @@
 * Game Code
 ****/ 
 // If game.up already exists, integrate the 'fishing' case. Otherwise, this defines game.up.
 /**** 
+* Pattern Generation System
+****/ 
+var PatternGenerator = {
+	lastLane: -1,
+	lastSpawnX: -1000,
+	minDistanceBetweenFish: 300,
+	// Minimum X distance between fish
+	getNextLane: function getNextLane() {
+		if (this.lastLane === -1) {
+			// First fish, start in middle lane
+			this.lastLane = 1;
+			return 1;
+		}
+		// Prefer staying in same lane or moving to adjacent lane
+		var possibleLanes = [this.lastLane];
+		// Add adjacent lanes
+		if (this.lastLane > 0) possibleLanes.push(this.lastLane - 1);
+		if (this.lastLane < 2) possibleLanes.push(this.lastLane + 1);
+		// 70% chance to stay in same/adjacent lane
+		if (Math.random() < 0.7) {
+			this.lastLane = possibleLanes[Math.floor(Math.random() * possibleLanes.length)];
+		} else {
+			// 30% chance for any lane
+			this.lastLane = Math.floor(Math.random() * 3);
+		}
+		return this.lastLane;
+	},
+	canSpawnFish: function canSpawnFish(fishX) {
+		// Check if enough distance from last spawn
+		var distance = Math.abs(fishX - this.lastSpawnX);
+		return distance >= this.minDistanceBetweenFish;
+	},
+	registerSpawn: function registerSpawn(fishX) {
+		this.lastSpawnX = fishX;
+	},
+	reset: function reset() {
+		this.lastLane = -1;
+		this.lastSpawnX = -1000;
+	}
+};
+/**** 
 * Game Configuration
 ****/ 
 game.up = function (x, y, obj) {
 	// Note: We don't play buttonClick sound on 'up' typically, only on 'down'.
@@ -226,33 +267,41 @@
 			pattern: "expert",
 			cost: 600
 		}]
 	}],
-	// Updated patterns with hold fish
+	// Updated patterns with hold fish - reduced frequency for playability
 	PATTERNS: {
 		simple: {
-			beatsPerFish: 1,
-			doubleSpawnChance: 0.05,
+			beatsPerFish: 2,
+			// Increased from 1 - fish every 2 beats
+			doubleSpawnChance: 0,
+			// No double spawns in simple
 			rareSpawnChance: 0.02,
-			holdFishChance: 0.1
+			holdFishChance: 0.05 // Reduced from 0.1
 		},
 		medium: {
-			beatsPerFish: 0.75,
-			doubleSpawnChance: 0.1,
+			beatsPerFish: 1.5,
+			// Increased from 0.75
+			doubleSpawnChance: 0,
+			// No double spawns
 			rareSpawnChance: 0.05,
-			holdFishChance: 0.2
+			holdFishChance: 0.1 // Reduced from 0.2
 		},
 		complex: {
-			beatsPerFish: 0.5,
-			doubleSpawnChance: 0.15,
+			beatsPerFish: 1,
+			// Increased from 0.5
+			doubleSpawnChance: 0,
+			// No double spawns
 			rareSpawnChance: 0.08,
-			holdFishChance: 0.3
+			holdFishChance: 0.15 // Reduced from 0.3
 		},
 		expert: {
-			beatsPerFish: 0.25,
-			doubleSpawnChance: 0.2,
+			beatsPerFish: 0.75,
+			// Increased from 0.25
+			doubleSpawnChance: 0,
+			// No double spawns
 			rareSpawnChance: 0.12,
-			holdFishChance: 0.4
+			holdFishChance: 0.2 // Reduced from 0.4
 		}
 	}
 };
 /**** 
@@ -926,17 +975,29 @@
 	fishArray.forEach(function (fish) {
 		fish.destroy();
 	});
 	fishArray = [];
+	// Reset pattern generator for new session
+	PatternGenerator.reset();
 	// Start music
 	LK.playMusic('rhythmTrack');
 }
 function spawnFish() {
 	var depthConfig = GameState.getCurrentDepthConfig();
 	var songConfig = GameState.getCurrentSongConfig();
 	var pattern = GAME_CONFIG.PATTERNS[songConfig.pattern];
-	// Choose random lane (0, 1, or 2)
-	var laneIndex = Math.floor(Math.random() * GAME_CONFIG.LANES.length);
+	// Skip spawn if pattern says no double spawns
+	if (pattern.doubleSpawnChance === 0) {
+		// Check if any fish are too close to spawn position
+		for (var i = 0; i < fishArray.length; i++) {
+			var fish = fishArray[i];
+			if (Math.abs(fish.x - GAME_CONFIG.SCREEN_CENTER_X) < PatternGenerator.minDistanceBetweenFish) {
+				return; // Skip this spawn
+			}
+		}
+	}
+	// Use pattern generator to choose lane
+	var laneIndex = PatternGenerator.getNextLane();
 	var targetLane = GAME_CONFIG.LANES[laneIndex];
 	// Determine if this is a hold fish
 	var isHoldFish = Math.random() < (pattern.holdFishChance || 0);
 	// Determine fish type and value
@@ -971,8 +1032,10 @@
 	fish.y = targetLane.y; // Set Y to the chosen lane's Y
 	fishArray.push(fish);
 	fishingScreen.addChild(fish);
 	GameState.sessionFishSpawned++;
+	// Register spawn position for pattern tracking
+	PatternGenerator.registerSpawn(GAME_CONFIG.SCREEN_CENTER_X);
 }
 function checkCatch(touchLane, isHoldAction, holdDurationMs) {
 	// Get the X position of the hook in the specific lane the player interacted with
 	var hookX = fishingElements.hooks[touchLane].x;