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

/**** 
* Initialize Game
****/ 
// Core game setup - stripped down to essentials
var game = new LK.Game({
	backgroundColor: 0x000000 // Dark background for terminal aesthetic
});

/**** 
* Game Code
****/ 
// Game states
var STATES = {
	TITLE: 'title',
	PLAYING: 'playing',
	GAME_OVER: 'gameOver'
};
// Game state object - much simplified
var gameState = {
	state: STATES.TITLE,
	day: 1,
	maxDays: 10,
	vibePoints: 100,
	codeCoherence: 100,
	bugs: 0,
	cardsPlayed: 0,
	maxCardsPerDay: 3,
	projectDescription: "",
	conceptCards: {
		platform: null,
		visual: null,
		genre: null,
		mechanic: null,
		feature: null
	},
	terminal: {
		log: [],
		statusLine: "",
		currentTask: "",
		featureTags: []
	}
};
// Card templates using actual prompts from your document
var cardTemplates = [
// Basic prompts
{
	type: 'basic',
	promptText: "Make the code run faster",
	vibePoints: 10,
	coherenceImpact: 5,
	bugChance: 0.2
}, {
	type: 'basic',
	promptText: "Use all the frameworks at the same time",
	vibePoints: 15,
	coherenceImpact: 15,
	bugChance: 0.3
},
// UI prompts
{
	type: 'UI',
	promptText: "Make the graphics better",
	vibePoints: 20,
	coherenceImpact: 10,
	bugChance: 0.2
}, {
	type: 'UI',
	promptText: "Add buttons that read user's minds",
	vibePoints: 25,
	coherenceImpact: 20,
	bugChance: 0.4
},
// Database prompts
{
	type: 'Database',
	promptText: "Store everything forever",
	vibePoints: 30,
	coherenceImpact: 15,
	bugChance: 0.3
}, {
	type: 'Database',
	promptText: "Make the database infinitely fast",
	vibePoints: 35,
	coherenceImpact: 25,
	bugChance: 0.5
}
// Add more cards from your prompt list document
];
// Concept cards for the 5 categories
var conceptCardTemplates = {
	platform: ["Mobile", "VR/AR", "Console", "PC", "Blockchain", "Web Browser", "Smart Watch", "Smart Fridge", "Metaverse"],
	visual: ["Pixel Art", "Voxel", "Realistic", "Hand-drawn", "Low-poly", "Claymation", "ASCII", "Demake", "Corporate PowerPoint"],
	genre: ["RPG", "Shooter", "Puzzle", "Platformer", "Roguelike", "Simulation", "Horror", "Dating Sim", "Educational", "Idle Clicker"],
	mechanic: ["Deckbuilding", "Physics-based", "Survival", "Tower Defense", "Match-3", "Rhythm", "Gacha", "Crafting", "Battle Royale", "Auto-battler"],
	feature: ["Multiplayer", "Procedural Generation", "Time Manipulation", "Player-created Content", "Perma-death", "AI Companions", "Weekly Challenges", "Social Media Integration", "Microtransactions", "Cloud Save"]
};
// Response templates for different card types at different coherence levels
var responseTemplates = {
	basic: {
		high: ["Implementing {feature} with standard protocols", "Adding {feature} functionality as requested", "Building core systems for {feature}"],
		medium: ["Attempting to create {feature} with questionable methods", "{platform} struggling with {feature} implementation", "Forcing {feature} despite {platform} limitations"],
		low: ["CRITICAL: {feature} IMPLEMENTATION CAUSING SYSTEM INSTABILITY", "{feature} NOW SENTIENT AND QUESTIONING PURPOSE", "{platform} REJECTING {feature} - ATTEMPTING OVERRIDE"]
	},
	UI: {
		high: ["Designing {visual} interface for {platform}", "Optimizing {visual} elements for {genre} feel", "Creating intuitive controls for {mechanic}"],
		medium: ["Stretching {platform} capabilities for {visual} rendering", "Users reporting eye strain from {visual} on {platform}", "{visual} clashing with {genre} expectations"],
		low: ["VISUALS EXCEEDING REALITY CONSTRAINTS", "{visual} CAUSING UNEXPLAINED PHENOMENA ON {platform}", "USERS REPORTING BEING PULLED INTO {genre} DIMENSION"]
	}
	// Add more for other card types
};
// Initialize game
function initGame() {
	// Clear screen
	while (game.children.length > 0) {
		game.removeChild(game.children[0]);
	}
	// Reset game state
	gameState = {
		state: STATES.PLAYING,
		day: 1,
		maxDays: 10,
		vibePoints: 100,
		codeCoherence: 100,
		bugs: 0,
		cardsPlayed: 0,
		maxCardsPerDay: 3,
		projectDescription: "New Project",
		conceptCards: {
			platform: null,
			visual: null,
			genre: null,
			mechanic: null,
			feature: null
		},
		terminal: {
			log: ["PROJECT INITIALIZED", "Waiting for instructions..."],
			statusLine: "",
			currentTask: "Awaiting first prompt",
			featureTags: []
		}
	};
	// Create main interface
	createInterface();
	// Initialize deck and draw cards
	initDeck();
	drawHand();
	// Initialize concept card selection if it's day 1
	if (gameState.day === 1) {
		showConceptCardSelection('platform');
	}
	// Update display
	updateTerminal();
}
// Create main interface
function createInterface() {
	// Create desk/monitor background
	var background = LK.getAsset('background', {});
	game.addChild(background);
	// Create terminal display
	createTerminal();
	// Create card area at bottom
	createCardArea();
	// Create day indicator
	var dayText = new Text2("DAY " + gameState.day + "/" + gameState.maxDays, {
		size: 60,
		fill: 0x00ff00 // Terminal green
	});
	dayText.x = 100;
	dayText.y = 100;
	game.addChild(dayText);
	gameState.dayText = dayText;
	// Create end day button
	var endDayButton = new Button("END DAY", 300, 80, function () {
		endDay();
	});
	endDayButton.x = 1848;
	endDayButton.y = 100;
	game.addChild(endDayButton);
}
// Create terminal display
function createTerminal() {
	// Create terminal container
	var terminal = new Container();
	terminal.x = 2048 / 2;
	terminal.y = 800; // Position in upper half of screen
	game.addChild(terminal);
	gameState.terminalContainer = terminal;
	// Create monitor frame
	var monitor = LK.getAsset('background', {
		width: 1600,
		height: 1000
	});
	monitor.tint = 0x333333; // Dark gray monitor
	terminal.addChild(monitor);
	// Create screen inside monitor
	var screen = LK.getAsset('background', {
		width: 1500,
		height: 900
	});
	screen.tint = 0x000000; // Black screen
	terminal.addChild(screen);
	// Create status line
	var statusLine = new Text2("PROJECT: [New Project] | VIBES: 100% | COHERENCE: 100%", {
		size: 30,
		fill: 0x00ff00 // Terminal green
	});
	statusLine.x = -700; // Relative to terminal container
	statusLine.y = -400;
	terminal.addChild(statusLine);
	gameState.statusLineText = statusLine;
	// Create terminal log area
	var logText = new Text2("PROJECT INITIALIZED\nAwaiting instructions...", {
		size: 24,
		fill: 0x00ff00,
		align: 'left',
		wordWrap: true,
		wordWrapWidth: 1400
	});
	logText.x = -700; // Relative to terminal container
	logText.y = -350;
	terminal.addChild(logText);
	gameState.logText = logText;
	// Create feature tags area
	var tagsText = new Text2("", {
		size: 24,
		fill: 0x00ff00
	});
	tagsText.x = -700;
	tagsText.y = 350;
	terminal.addChild(tagsText);
	gameState.tagsText = tagsText;
	// Create blinking cursor
	var cursor = new Text2("_", {
		size: 24,
		fill: 0x00ff00
	});
	cursor.x = -700;
	cursor.y = 300;
	terminal.addChild(cursor);
	// Make cursor blink
	LK.setInterval(function () {
		cursor.visible = !cursor.visible;
	}, 500);
}
// Create card area
function createCardArea() {
	// Create hand container
	var handContainer = new Container();
	handContainer.y = 2100; // Position in lower part of screen
	game.addChild(handContainer);
	gameState.handContainer = handContainer;
	// Create separator line
	var separator = LK.getAsset('background', {
		width: 2048,
		height: 2,
		tint: 0x00ff00,
		y: 1600
	});
	game.addChild(separator);
	// Create hand label
	var handLabel = new Text2("YOUR PROMPTS", {
		size: 40,
		fill: 0x00ff00
	});
	handLabel.x = 2048 / 2;
	handLabel.y = 1650;
	game.addChild(handLabel);
}
// Card class - simplified from your existing implementation
function Card(type, promptText, vibePoints, coherenceImpact, bugChance) {
	var card = new Container();
	// Card properties
	card.type = type;
	card.promptText = promptText;
	card.vibePoints = vibePoints;
	card.coherenceImpact = coherenceImpact;
	card.bugChance = bugChance;
	// Card visuals
	var cardAsset;
	switch (type.toLowerCase()) {
		case 'ui':
			cardAsset = 'uicard';
			break;
		case 'database':
			cardAsset = 'databasecard';
			break;
		case 'api':
			cardAsset = 'apicard';
			break;
		case 'security':
			cardAsset = 'securitycard';
			break;
		case 'special':
			cardAsset = 'specialcard';
			break;
		default:
			cardAsset = 'basiccard';
	}
	var cardBg = LK.getAsset(cardAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	card.addChild(cardBg);
	// Card title
	var titleText = new Text2(type.toUpperCase(), {
		size: 40,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0);
	titleText.y = -250;
	card.addChild(titleText);
	// Card prompt text
	var promptTextObj = new Text2(promptText, {
		size: 30,
		fill: 0xFFFFFF,
		align: 'center',
		wordWrap: true,
		wordWrapWidth: 350
	});
	promptTextObj.anchor.set(0.5, 0);
	promptTextObj.y = -180;
	card.addChild(promptTextObj);
	// Make card interactive
	card.interactive = true;
	card.down = function () {
		card.scale.set(0.95);
	};
	card.up = function () {
		card.scale.set(1);
		playCard(card);
	};
	return card;
}
// Initialize the deck
function initDeck() {
	gameState.deck = [];
	gameState.hand = [];
	// Add multiple copies of each card template
	cardTemplates.forEach(function (template) {
		var count = template.type === 'basic' ? 4 : 2; // More basic cards
		for (var i = 0; i < count; i++) {
			gameState.deck.push(Object.assign({}, template));
		}
	});
	// Shuffle deck
	shuffleDeck();
}
// Shuffle the deck
function shuffleDeck() {
	for (var i = gameState.deck.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = gameState.deck[i];
		gameState.deck[i] = gameState.deck[j];
		gameState.deck[j] = temp;
	}
}
// Draw a hand of cards
function drawHand() {
	// Clear existing hand
	while (gameState.handContainer.children.length > 0) {
		gameState.handContainer.removeChild(gameState.handContainer.children[0]);
	}
	gameState.hand = [];
	// Draw 5 cards
	for (var i = 0; i < 5; i++) {
		if (gameState.deck.length > 0) {
			var template = gameState.deck.pop();
			var card = new Card(template.type, template.promptText, template.vibePoints, template.coherenceImpact, template.bugChance);
			gameState.hand.push(card);
			gameState.handContainer.addChild(card);
		}
	}
	// Position cards
	positionCardsInHand();
}
// Position cards in hand
function positionCardsInHand() {
	var spacing = 420;
	var handWidth = gameState.hand.length * spacing;
	var startX = (2048 - handWidth) / 2 + spacing / 2;
	gameState.hand.forEach(function (card, index) {
		card.x = startX + index * spacing;
		card.y = 0;
	});
}
// Show concept card selection
function showConceptCardSelection(category) {
	// Create selection container
	var selectionContainer = new Container();
	selectionContainer.x = 2048 / 2;
	selectionContainer.y = 2732 / 2;
	game.addChild(selectionContainer);
	// Create background
	var bg = LK.getAsset('background', {
		width: 1800,
		height: 1200
	});
	bg.alpha = 0.9;
	selectionContainer.addChild(bg);
	// Create title
	var title = new Text2("SELECT " + category.toUpperCase(), {
		size: 60,
		fill: 0x00ff00
	});
	title.anchor.set(0.5, 0);
	title.y = -550;
	selectionContainer.addChild(title);
	// Get options for this category
	var options = conceptCardTemplates[category];
	// Choose 3 random options
	var selectedOptions = [];
	while (selectedOptions.length < 3 && options.length > 0) {
		var index = Math.floor(Math.random() * options.length);
		selectedOptions.push(options[index]);
		options.splice(index, 1);
	}
	// Create option buttons
	selectedOptions.forEach(function (option, index) {
		var button = new Button(option, 500, 100, function () {
			// Set concept card
			gameState.conceptCards[category] = option;
			// Update terminal
			addToTerminalLog("SELECTED " + category.toUpperCase() + ": " + option);
			updateTerminal();
			// Remove selection container
			game.removeChild(selectionContainer);
			// Add to feature tags
			updateFeatureTags();
		});
		button.x = 0;
		button.y = -200 + index * 200;
		selectionContainer.addChild(button);
	});
}
// Button class
function Button(text, width, height, callback) {
	var button = new Container();
	// Button background
	var bg = LK.getAsset('menuButton', {
		width: width,
		height: height
	});
	bg.tint = 0x333333;
	button.addChild(bg);
	// Button text
	var textObj = new Text2(text, {
		size: 30,
		fill: 0x00ff00
	});
	textObj.anchor.set(0.5, 0.5);
	button.addChild(textObj);
	// Make button interactive
	button.interactive = true;
	button.down = function () {
		bg.color = 0x555555;
	};
	button.up = function () {
		bg.color = 0x333333;
		if (callback) {
			callback();
		}
	};
	return button;
}
// Play a card
function playCard(card) {
	if (gameState.cardsPlayed >= gameState.maxCardsPerDay) {
		addToTerminalLog("CANNOT PLAY MORE CARDS TODAY");
		return;
	}
	// Generate response for this card
	var response = generateResponse(card);
	// Apply card effects
	gameState.vibePoints = Math.max(0, gameState.vibePoints + card.vibePoints);
	gameState.codeCoherence = Math.max(0, gameState.codeCoherence - card.coherenceImpact);
	gameState.cardsPlayed++;
	// Add response to terminal
	addToTerminalLog("IMPLEMENTING: \"" + card.promptText + "\"");
	addToTerminalLog(response);
	// Check for bugs
	checkForBugs(card);
	// Remove card from hand
	var index = gameState.hand.indexOf(card);
	if (index !== -1) {
		gameState.hand.splice(index, 1);
		gameState.handContainer.removeChild(card);
	}
	// Update terminal
	updateTerminal();
	// Reposition remaining cards
	positionCardsInHand();
	// Check game state
	checkGameState();
}
// Generate response for a card
function generateResponse(card) {
	// Determine coherence level
	var coherenceLevel = getCoherenceLevel();
	// Get templates for this card type and coherence level
	var templates = responseTemplates[card.type.toLowerCase()] || responseTemplates.basic;
	var levelTemplates = templates[coherenceLevel];
	// Select random template
	var template = levelTemplates[Math.floor(Math.random() * levelTemplates.length)];
	// Replace placeholders with concept card values
	var response = template.replace(/{(\w+)}/g, function (match, term) {
		return gameState.conceptCards[term] || match;
	});
	return response;
}
// Get coherence level based on current code coherence
function getCoherenceLevel() {
	if (gameState.codeCoherence > 70) {
		return "high";
	}
	if (gameState.codeCoherence > 30) {
		return "medium";
	}
	return "low";
}
// Add text to terminal log
function addToTerminalLog(text) {
	gameState.terminal.log.push(text);
	// Keep only last 8 entries
	if (gameState.terminal.log.length > 8) {
		gameState.terminal.log.shift();
	}
}
// Update terminal display
function updateTerminal() {
	// Update status line
	var conceptString = "";
	for (var category in gameState.conceptCards) {
		if (gameState.conceptCards[category]) {
			if (conceptString) {
				conceptString += " ";
			}
			conceptString += gameState.conceptCards[category];
		}
	}
	var statusText = "PROJECT: [" + conceptString + "] | VIBES: " + gameState.vibePoints + "% | COHERENCE: " + gameState.codeCoherence + "% | BUGS: " + gameState.bugs;
	gameState.statusLineText.setText(statusText);
	// Update terminal log
	gameState.logText.setText(gameState.terminal.log.join('\n\n'));
	// Update feature tags
	updateFeatureTags();
}
// Update feature tags
function updateFeatureTags() {
	var tags = [];
	for (var category in gameState.conceptCards) {
		if (gameState.conceptCards[category]) {
			tags.push("#" + gameState.conceptCards[category].replace(/\s+/g, ''));
		}
	}
	gameState.tagsText.setText(tags.join(' '));
}
// Check for bugs
function checkForBugs(card) {
	var bugChance = card.bugChance * (1 + (100 - gameState.codeCoherence) / 100);
	if (Math.random() < bugChance) {
		gameState.bugs++;
		// Add bug message to terminal
		var bugMessages = ["WARNING: Bug detected in " + card.type + " implementation", "ERROR: Unexpected behavior in " + card.promptText, "CRITICAL: System instability increasing", "BUG ALERT: Code coherence affected"];
		addToTerminalLog(bugMessages[Math.floor(Math.random() * bugMessages.length)]);
	}
}
// Check game state
function checkGameState() {
	// Check for game over conditions
	if (gameState.bugs >= 10) {
		gameOver("TOO MANY BUGS - PROJECT CRASHED");
		return;
	}
	if (gameState.codeCoherence <= 0) {
		gameOver("CODE COHERENCE ZERO - AI HALLUCINATING");
		return;
	}
	// Check if all cards have been played for this day
	if (gameState.cardsPlayed >= gameState.maxCardsPerDay) {
		addToTerminalLog("DAILY CARD LIMIT REACHED - END DAY TO CONTINUE");
	}
}
// End the day
function endDay() {
	gameState.day++;
	if (gameState.day > gameState.maxDays) {
		evaluateProject();
		return;
	}
	// Update day text
	gameState.dayText.setText("DAY " + gameState.day + "/" + gameState.maxDays);
	// Reset cards played
	gameState.cardsPlayed = 0;
	// Recover some code coherence
	gameState.codeCoherence = Math.min(100, gameState.codeCoherence + 10);
	// Draw new hand
	drawHand();
	// Add day change to terminal
	addToTerminalLog("DAY " + gameState.day + " STARTED");
	updateTerminal();
	// Check if it's a concept card day
	var conceptDays = {
		1: 'platform',
		3: 'visual',
		5: 'genre',
		7: 'mechanic',
		9: 'feature'
	};
	if (conceptDays[gameState.day]) {
		showConceptCardSelection(conceptDays[gameState.day]);
	}
}
// Evaluate project at end of game
function evaluateProject() {
	// Calculate score based on vibes, features implemented, bugs, coherence
	var score = gameState.vibePoints * 0.4 + Object.values(gameState.conceptCards).filter(Boolean).length * 10 + (10 - gameState.bugs) * 5 + gameState.codeCoherence * 0.2;
	score = Math.round(score);
	// Generate review text
	var reviewText = generateReview(score);
	// Show game over with review
	gameOver("PROJECT COMPLETE! SCORE: " + score + "/100\n\n" + reviewText);
}
// Generate review text based on game results
function generateReview(score) {
	var platform = gameState.conceptCards.platform || "Unknown Platform";
	var visual = gameState.conceptCards.visual || "Unknown Visual Style";
	var genre = gameState.conceptCards.genre || "Unknown Genre";
	var mechanic = gameState.conceptCards.mechanic || "Unknown Mechanic";
	var feature = gameState.conceptCards.feature || "Unknown Feature";
	// Create compatibility assessment
	var compatibility = "surprisingly effective";
	if (platform === "Smart Watch" && visual === "Realistic" || platform === "Blockchain" && mechanic === "Rhythm") {
		compatibility = "technically impossible";
	} else if (platform === "Smart Fridge" && genre === "Horror" || visual === "ASCII" && feature === "Procedural Generation") {
		compatibility = "bizarrely compelling";
	}
	// Generate review based on score
	if (score >= 80) {
		return "GameDev Weekly Review: " + score + "%\n\n" + "The " + platform + " " + genre + " with " + visual + " visuals is a breakthrough hit! " + "The " + mechanic + " mechanics combined with " + feature + " create a " + compatibility + " experience. " + "Despite the odd bug, players can't stop talking about this unique creation.";
	} else if (score >= 50) {
		return "GameDev Weekly Review: " + score + "%\n\n" + "This " + visual + " " + genre + " for " + platform + " is an ambitious mess. " + "The " + mechanic + " system is interesting but poorly implemented, and " + feature + " feels tacked on as an afterthought. This " + compatibility + " combination " + "shows promise but needs serious bug fixing.";
	} else {
		return "GameDev Weekly Review: " + score + "%\n\n" + "What were they thinking? A " + genre + " game with " + visual + " visuals on " + platform + "?! " + "The " + mechanic + " mechanics are completely broken, and " + feature + " crashes constantly. " + "This " + compatibility + " disaster sets a new standard for technical problems. " + "However, it's so bad it might become a cult classic for ironic enjoyment.";
	}
}
// Game over
function gameOver(message) {
	gameState.state = STATES.GAME_OVER;
	// Create game over container
	var gameOverContainer = new Container();
	gameOverContainer.x = 2048 / 2;
	gameOverContainer.y = 2732 / 2;
	game.addChild(gameOverContainer);
	// Create background
	var bg = LK.getAsset('background', {
		width: 1800,
		height: 1500
	});
	bg.alpha = 0.9;
	gameOverContainer.addChild(bg);
	// Create game over text
	var gameOverText = new Text2(message, {
		size: 40,
		fill: 0x00ff00,
		align: 'left',
		wordWrap: true,
		wordWrapWidth: 1600
	});
	gameOverText.anchor.set(0.5, 0.5);
	gameOverContainer.addChild(gameOverText);
	// Create restart button
	var restartButton = new Button("NEW PROJECT", 400, 100, function () {
		initGame();
	});
	restartButton.y = 600;
	gameOverContainer.addChild(restartButton);
}
// Create title screen
function showTitleScreen() {
	// Clear screen
	while (game.children.length > 0) {
		game.removeChild(game.children[0]);
	}
	// Set state
	gameState.state = STATES.TITLE;
	// Create background
	var background = LK.getAsset('background', {
		width: 2048,
		height: 2732
	});
	game.addChild(background);
	// Create title
	var title = new Text2("VIBE CODER", {
		size: 120,
		fill: 0x00ff00
	});
	title.x = 2048 / 2;
	title.y = 800;
	game.addChild(title);
	// Create subtitle
	var subtitle = new Text2("The AI Coding Simulator", {
		size: 60,
		fill: 0x00ff00
	});
	subtitle.x = 2048 / 2;
	subtitle.y = 900;
	game.addChild(subtitle);
	// Create start button
	var startButton = new Button("START", 400, 100, function () {
		initGame();
	});
	startButton.x = 2048 / 2;
	startButton.y = 1200;
	game.addChild(startButton);
}
// Start the game
showTitleScreen();
// Game update function - called every frame
game.update = function () {
	if (gameState.state !== STATES.PLAYING) {
		return; // Skip updates if not in playing state
	}
	// Update blinking cursor position if needed
	updateCursorPosition();
	// Add any other frame-by-frame updates needed
};
// Update cursor position based on current terminal text
function updateCursorPosition() {
	if (!gameState.logText || !gameState.terminalContainer) {
		return;
	}
	var cursor = gameState.terminalContainer.children.find(function (child) {
		return child instanceof Text2 && child.text === "_";
	});
	if (cursor) {
		// Get last line of text
		var lines = gameState.terminal.log[gameState.terminal.log.length - 1] || "";
		var lastLine = lines.split("\n").pop();
		// Position cursor after the last line
		var textWidth = lastLine.length * 14; // Approximate width per character
		cursor.x = -700 + textWidth; // Start position + text width
		// Calculate y position based on number of lines in log
		var totalLines = 0;
		gameState.terminal.log.forEach(function (entry) {
			totalLines += entry.split("\n").length + 1; // +1 for spacing
		});
		cursor.y = -350 + totalLines * 30; // Starting y + line height * lines
	}
}
// Game touch/click event handlers
game.down = function (x, y, obj) {
	// Object-specific handlers will trigger first if clicked
};
game.move = function (x, y, obj) {
	// Handle drag operations if needed
};
game.up = function (x, y, obj) {
	// Handle any touch/click releases not caught by objects
};
// Add cards to hand with dragging functionality
function addCardToHand(cardData) {
	var card = new Card(cardData.type, cardData.promptText, cardData.vibePoints, cardData.coherenceImpact, cardData.bugChance);
	// Add dragging behavior
	card.isDragging = false;
	card.dragOffsetX = 0;
	card.dragOffsetY = 0;
	card.originalX = 0;
	card.originalY = 0;
	// Override default handlers with drag functionality
	card.down = function (x, y) {
		this.isDragging = true;
		this.dragOffsetX = this.x - x;
		this.dragOffsetY = this.y - y;
		this.originalX = this.x;
		this.originalY = this.y;
		// Bring to front
		if (this.parent) {
			this.parent.setChildIndex(this, this.parent.children.length - 1);
		}
		// Visual feedback
		this.scale.set(1.1);
	};
	card.move = function (x, y) {
		if (this.isDragging) {
			this.x = x + this.dragOffsetX;
			this.y = y + this.dragOffsetY;
		}
	};
	card.up = function (x, y) {
		this.isDragging = false;
		this.scale.set(1);
		// Check if dropped on terminal
		var terminalBounds = {
			x: gameState.terminalContainer.x - 800,
			y: gameState.terminalContainer.y - 500,
			width: 1600,
			height: 1000
		};
		if (x > terminalBounds.x && x < terminalBounds.x + terminalBounds.width && y > terminalBounds.y && y < terminalBounds.y + terminalBounds.height) {
			// Card dropped on terminal
			playCard(this);
		} else {
			// Return to original position
			this.x = this.originalX;
			this.y = this.originalY;
		}
	};
	gameState.hand.push(card);
	gameState.handContainer.addChild(card);
	return card;
}
// More detailed implementation of card drawing
// Enhanced terminal text handling with typing effect
function addToTerminalLogWithEffect(text) {
	// Store the text to be added
	var typingState = {
		fullText: text,
		currentPosition: 0,
		typingSpeed: 50 // ms per character
	};
	// Save reference to typing state
	gameState.currentTyping = typingState;
	// Add empty string to log first
	gameState.terminal.log.push("");
	// Start typing effect
	typeNextCharacter();
	function typeNextCharacter() {
		if (!typingState.fullText || !gameState.terminal) {
			return;
		}
		if (typingState.currentPosition < typingState.fullText.length) {
			// Get current log text
			var logEntry = gameState.terminal.log[gameState.terminal.log.length - 1];
			// Add next character
			logEntry += typingState.fullText[typingState.currentPosition];
			// Update log
			gameState.terminal.log[gameState.terminal.log.length - 1] = logEntry;
			// Update display
			updateTerminal();
			// Increment position
			typingState.currentPosition++;
			// Schedule next character
			LK.setTimeout(typeNextCharacter, typingState.typingSpeed);
		} else {
			// Typing complete
			gameState.currentTyping = null;
			// Keep only last 8 entries
			if (gameState.terminal.log.length > 8) {
				gameState.terminal.log.shift();
				updateTerminal();
			}
		}
	}
}
// Enhanced version of playCard with visual effects
// Enhanced day transition with effects
function endDayWithEffects() {
	// Animate day transition
	var dayTransition = new Text2("END OF DAY " + gameState.day, {
		size: 80,
		fill: 0x00ff00
	});
	dayTransition.x = 2048 / 2;
	dayTransition.y = 2732 / 2;
	dayTransition.alpha = 0;
	game.addChild(dayTransition);
	// Fade in
	tween(dayTransition, {
		alpha: 1
	}, {
		duration: 500,
		onFinish: function onFinish() {
			// Hold for a moment
			LK.setTimeout(function () {
				// Fade out
				tween(dayTransition, {
					alpha: 0
				}, {
					duration: 500,
					onFinish: function onFinish() {
						game.removeChild(dayTransition);
						// Proceed with day end
						gameState.day++;
						if (gameState.day > gameState.maxDays) {
							evaluateProject();
							return;
						}
						// Update day text
						gameState.dayText.setText("DAY " + gameState.day + "/" + gameState.maxDays);
						// Reset cards played
						gameState.cardsPlayed = 0;
						// Recover some code coherence
						gameState.codeCoherence = Math.min(100, gameState.codeCoherence + 10);
						// Draw new hand
						drawHand();
						// Add day change to terminal
						addToTerminalLogWithEffect("DAY " + gameState.day + " STARTED");
						updateTerminal();
						// Check if it's a concept card day
						var conceptDays = {
							1: 'platform',
							3: 'visual',
							5: 'genre',
							7: 'mechanic',
							9: 'feature'
						};
						if (conceptDays[gameState.day]) {
							LK.setTimeout(function () {
								showConceptCardSelection(conceptDays[gameState.day]);
							}, 500);
						}
					}
				});
			}, 1000);
		}
	});
}
// Launch Screen special effect
function showLaunchScreen() {
	// Black overlay
	var overlay = LK.getAsset('background', {
		width: 2048,
		height: 2732
	});
	overlay.tint = 0x000000;
	game.addChild(overlay);
	// "Booting up" text
	var bootText = new Text2("BOOTING VIBE CODER OS v1.0...", {
		size: 40,
		fill: 0x00ff00
	});
	bootText.x = 2048 / 2;
	bootText.y = 2732 / 2;
	game.addChild(bootText);
	// Simulate boot sequence
	LK.setTimeout(function () {
		bootText.setText(bootText.text + "\nINITIALIZING TERMINAL...");
		LK.setTimeout(function () {
			bootText.setText(bootText.text + "\nLOADING VIBE DATABASE...");
			LK.setTimeout(function () {
				bootText.setText(bootText.text + "\nCONNECTING TO AI SUBSYSTEMS...");
				LK.setTimeout(function () {
					bootText.setText(bootText.text + "\nREADY!");
					LK.setTimeout(function () {
						// Fade out
						tween(overlay, {
							alpha: 0
						}, {
							duration: 500,
							onFinish: function onFinish() {
								game.removeChild(overlay);
								game.removeChild(bootText);
								// Show the title screen
								showTitleScreen();
							}
						});
					}, 800);
				}, 800);
			}, 800);
		}, 800);
	}, 800);
}
// Enhanced game initialization with intro sequence
function initGameWithIntro() {
	// Reset game state
	gameState = {
		state: STATES.PLAYING,
		day: 1,
		maxDays: 10,
		vibePoints: 100,
		codeCoherence: 100,
		bugs: 0,
		cardsPlayed: 0,
		maxCardsPerDay: 3,
		projectDescription: "New Project",
		conceptCards: {
			platform: null,
			visual: null,
			genre: null,
			mechanic: null,
			feature: null
		},
		terminal: {
			log: [],
			statusLine: "",
			currentTask: "Awaiting first prompt",
			featureTags: []
		},
		deck: [],
		hand: []
	};
	// Clear screen with fade effect
	var fadeOverlay = new Sprite();
	fadeOverlay.width = 2048;
	fadeOverlay.height = 2732;
	fadeOverlay.color = 0x000000;
	fadeOverlay.alpha = 0;
	game.addChild(fadeOverlay);
	// Fade to black
	tween(fadeOverlay, {
		alpha: 1
	}, {
		duration: 500,
		onFinish: function onFinish() {
			// Clear screen
			while (game.children.length > 0) {
				game.removeChild(game.children[0]);
			}
			// Create main interface
			createInterface();
			// Initialize deck and draw cards
			initDeck();
			drawHand();
			// Add initial terminal messages
			addToTerminalLogWithEffect("VIBE CODER OS v1.0 INITIALIZED");
			LK.setTimeout(function () {
				addToTerminalLogWithEffect("NEW PROJECT CREATED");
				LK.setTimeout(function () {
					addToTerminalLogWithEffect("AWAITING CONCEPT SELECTION...");
					updateTerminal();
					// Initialize concept card selection for day 1
					LK.setTimeout(function () {
						showConceptCardSelection('platform');
					}, 500);
				}, 1000);
			}, 1000);
			// Fade from black
			fadeOverlay.alpha = 1;
			game.addChild(fadeOverlay);
			tween(fadeOverlay, {
				alpha: 0
			}, {
				duration: 500,
				onFinish: function onFinish() {
					game.removeChild(fadeOverlay);
				}
			});
		}
	});
}
// Start the application with boot sequence
showLaunchScreen();

===================================================================
--- original.js
+++ change.js
@@ -255,13 +255,14 @@
 	handContainer.y = 2100; // Position in lower part of screen
 	game.addChild(handContainer);
 	gameState.handContainer = handContainer;
 	// Create separator line
-	var separator = new Sprite();
-	separator.width = 2048;
-	separator.height = 2;
-	separator.color = 0x00ff00;
-	separator.y = 1600;
+	var separator = LK.getAsset('background', {
+		width: 2048,
+		height: 2,
+		tint: 0x00ff00,
+		y: 1600
+	});
 	game.addChild(separator);
 	// Create hand label
 	var handLabel = new Text2("YOUR PROMPTS", {
 		size: 40,