/**** 
* Classes
****/
var GraphSegment = Container.expand(function () {
	var self = Container.call(this);
	self.yValue = 0; // Track the Y value of the segment
	self.updateSlide = function () {
		if (moveSegments) {
			self.x -= slideAmount;
		}
		if (moveSegmentsVertically) {
			var slideDirection = lastStockValue < self.yValue ? 1 : -1; // Slide up if stock value is increasing, down if decreasing
			self.y += slideAmount * slideDirection;
			if (Math.abs(self.y - game.height / 2) > verticalSlideThreshold) {
				moveSegmentsVertically = false; // Stop vertical sliding when threshold is reached
			}
		}
	};
	var segmentGraphics = self.createAsset('segment', 'Graph Segment', 0, 0.5);
	// Function to slide the segment to the left
});
// ValueIndicator class to represent the current value of the stock on the graph
// Player class to represent the player's portfolio
var Player = Container.expand(function () {
	var self = Container.call(this);
	self.balance = 100; // Start with $100
	self.stocks = {}; // Object to hold stocks and quantities
	self.buyStock = function (stock, quantity) {
		var cost = stock.getPrice() * quantity;
		if (self.balance >= cost) {
			self.balance -= cost;
			if (!self.stocks[stock]) {
				self.stocks[stock] = 0;
			}
			self.stocks[stock] += quantity;
		}
	};
	self.sellStock = function (stock, quantity) {
		if (self.stocks[stock] && self.stocks[stock] >= quantity) {
			self.balance += stock.getPrice() * quantity;
			self.stocks[stock] -= quantity;
			if (self.stocks[stock] === 0) {
				delete self.stocks[stock];
			}
		}
	};
	self.getBalance = function () {
		return self.balance;
	};
	self.getPortfolio = function () {
		return self.stocks;
	};
});

/**** 
* Initialize Game
****/
var game = new LK.Game({
	// No need to set backgroundColor since we are adding a background asset
});

/**** 
* Game Code
****/
var slideAmount = 5.0;
// Create and add background asset
var running = false;
var moveSegments = false;
var moveSegmentsVertically = false;
var verticalSlideThreshold = 200; // Define a global threshold for vertical sliding
var lastStockValue = 0; // Keep track of the last stock value to determine slide direction
var drawingInProgress = false;
var background = game.addChild(LK.getAsset('background', 'Game background', 0.5, 0.5));
background.x = 1024; // Center x position
background.y = 2732 - background.height / 2; // Center y position
// Initialize game elements
var player = new Player();
var stocks = [];
// Initialize stock values history with the first value of $10
var stockValuesHistory = [10];
// Define graphIndex and initialize to 0
var graphIndex = 0;
// Declare a global array to store graph segments
var graphSegments = [];
// Generate random deltas and add to previous value for stockValuesHistory
var previousValue = stockValuesHistory[stockValuesHistory.length - 1];
for (var i = 0; i < 100; i++) {
	var delta = (Math.random() - 0.5) * 100; // Generate a delta between -50 and 50
	var newValue = Math.max(previousValue + delta, 0);
	stockValuesHistory.push(newValue);
	previousValue = newValue;
}
var graphPoints = [];
var graphWidth = game.width;
var segmentWidth = graphWidth / 6; //; / stockValuesHistory.length;
var x, y;
// Compute the coordinates for the graph based on stockValuesHistory
for (var i = 0; i < stockValuesHistory.length; i++) {
	x = Math.min(segmentWidth * i, game.width * 0.75);
	y = game.height / 2 - stockValuesHistory[i] * 10; // Scale the stock value for display
	graphPoints.push({
		x: x,
		y: y
	});
}
function addNewStockValues() {
	if (moveSegments) {
		var newStockValue = Math.floor(Math.random() * 100) + 1;
		stockValuesHistory.push(newStockValue);
		var totalSlideDistance = graphSegments.length > 0 ? graphSegments[0].startX - graphSegments[0].x : 0;
		var newGraphPoint = {
			x: graphPoints[graphPoints.length - 1].x + segmentWidth - totalSlideDistance,
			y: game.height / 2 - newStockValue * 10
		};
		graphPoints.push(newGraphPoint);
	}
	LK.setTimeout(addNewStockValues, 1000); // Continue adding new values every second
}
var segmentDrawInterval = null;
var stockDisplay = []; // Array to hold stock display elements
var balanceText = new Text2('Balance: $' + player.getBalance(), {
	size: 50,
	fill: "#ffffff"
});
balanceText.anchor.set(0.5, 0);
LK.gui.top.addChild(balanceText);
// Update the player's balance display
function updateBalanceDisplay() {
	balanceText.setText('Balance: $' + player.getBalance().toFixed(2));
}
// Function to handle buying stocks
function buyStock(stock) {
	player.buyStock(stock, 1); // Buy 1 stock for simplicity
	updateBalanceDisplay();
}
// Function to handle selling stocks
function sellStock(stock) {
	player.sellStock(stock, 1); // Sell 1 stock for simplicity
	updateBalanceDisplay();
}
function drawNextSegment() {
	console.log("drawNextSegment " + graphIndex + ' isDrawing = ' + drawingInProgress);
	var hasFinished = graphIndex >= graphPoints.length - 1;
	if (hasFinished) {
		running = false;
		LK.showGameOver();
		return;
	}
	if (!drawingInProgress) {
		var pointA = graphPoints[graphIndex];
		var lastSegment = graphSegments.length > 0 ? graphSegments[graphSegments.length - 1] : null;
		var lastSegmentEndX = lastSegment ? lastSegment.x + Math.cos(lastSegment.rotation) * lastSegment.width : 0;
		pointA.x = lastSegment ? lastSegmentEndX : 0;
		var pointB = graphPoints[graphIndex + 1];
		var delay = 1; // Reduce delay if segments are moving
		drawingInProgress = true;
		drawSegment(game, graphIndex, pointA.x, pointA.y, pointB.x, pointB.y, delay);
		graphIndex++;
	}
}
function drawSegment(gameRef, index, x1, y1, x2, y2, delay) {
	var segment = gameRef.addChild(new GraphSegment());
	segment.yValue = y1; // Set the yValue to the starting Y of the segment
	// Add the new segment to the global graphSegments array
	graphSegments.push(segment);
	console.log('new segment index=' + index + '/' + (graphSegments.length - 1), x1, y1, x2, y2);
	segment.x = x1;
	segment.y = y1;
	segment.width = 1;
	segment.height = 20;
	var deltaX = x2 - x1;
	var deltaY = y2 - y1;
	if (deltaX === 0 && deltaY === 0) {
		console.error('Invalid deltaX and deltaY for rotation calculation.');
		return;
	}
	var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	segment.rotation = Math.atan2(deltaY, deltaX);
	/*console.log('segment.rotation ' + (graphSegments.length - 1), {
	deltaY: deltaY,
	deltaX: deltaX
	}, segment.rotation);*/
	var startTime = Date.now();
	var endTime = startTime + delay * 1000;
	var updateWidth = function updateWidth() {
		if (!running) {
			return;
		}
		var currentTime = Date.now();
		var timeElapsed = currentTime - startTime;
		var newWidth = Math.min(timeElapsed / (delay * 1000) * distance, distance);
		segment.width = newWidth;
		if (currentTime < endTime) {
			LK.setTimeout(updateWidth, 16);
		} else {
			if (!moveSegments && segment.x + segment.width / 2 >= game.width * 0.5) {
				moveSegments = true;
				console.log("Past center !");
			}
			// Activate vertical sliding if the new segment's Y value exceeds the threshold
			if (!moveSegmentsVertically && Math.abs(segment.y - game.height / 2) > verticalSlideThreshold) {
				moveSegmentsVertically = true;
				lastStockValue = segment.yValue; // Update the last stock value for slide direction
			}
			drawingInProgress = false;
		}
	};
	updateWidth();
}
function startGame() {
	// Initialize and start the game logic here
	running = true;
	// Set up a tick event to call drawNextSegment every second
	segmentDrawInterval = LK.setInterval(drawNextSegment, 100);
	// Add ValueIndicator to the game and update its position
	//LK.setTimeout(addNewStockValues, 1000);
}
// Main game loop
LK.on('tick', function () {
	if (!running) {
		return;
	}
	// Update slide for each graph segment
	graphSegments.forEach(function (segment) {
		segment.updateSlide();
	});
	// Check for game over conditions (e.g., player runs out of money)
	if (player.getBalance() <= 0) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
	}
});
LK.setTimeout(function () {
	startGame();
}, 1000);

===================================================================
--- original.js
+++ change.js
@@ -3,22 +3,19 @@
 ****/
 var GraphSegment = Container.expand(function () {
 	var self = Container.call(this);
 	self.yValue = 0; // Track the Y value of the segment
-	self.verticalThreshold = 1366; // Half of the game height
 	self.updateSlide = function () {
 		if (moveSegments) {
 			self.x -= slideAmount;
-			self.distanceToSlide -= slideAmount;
-			if (self.distanceToSlide <= 0) {
-				self.distanceToSlide = null;
+		}
+		if (moveSegmentsVertically) {
+			var slideDirection = lastStockValue < self.yValue ? 1 : -1; // Slide up if stock value is increasing, down if decreasing
+			self.y += slideAmount * slideDirection;
+			if (Math.abs(self.y - game.height / 2) > verticalSlideThreshold) {
+				moveSegmentsVertically = false; // Stop vertical sliding when threshold is reached
 			}
 		}
-		// Check if the Y value exceeds the vertical threshold
-		if (Math.abs(self.y - self.verticalThreshold) > verticalSlideThreshold) {
-			var slideDirection = self.y > self.verticalThreshold ? -1 : 1;
-			self.y += slideDirection * verticalSlideAmount;
-		}
 	};
 	var segmentGraphics = self.createAsset('segment', 'Graph Segment', 0, 0.5);
 	// Function to slide the segment to the left
 });
@@ -65,13 +62,14 @@
 /**** 
 * Game Code
 ****/
 var slideAmount = 5.0;
-var verticalSlideThreshold = 200; // Define a global threshold for vertical sliding
-var verticalSlideAmount = 2.0; // Define the amount to slide vertically
 // Create and add background asset
 var running = false;
 var moveSegments = false;
+var moveSegmentsVertically = false;
+var verticalSlideThreshold = 200; // Define a global threshold for vertical sliding
+var lastStockValue = 0; // Keep track of the last stock value to determine slide direction
 var drawingInProgress = false;
 var background = game.addChild(LK.getAsset('background', 'Game background', 0.5, 0.5));
 background.x = 1024; // Center x position
 background.y = 2732 - background.height / 2; // Center y position
@@ -198,8 +196,13 @@
 			if (!moveSegments && segment.x + segment.width / 2 >= game.width * 0.5) {
 				moveSegments = true;
 				console.log("Past center !");
 			}
+			// Activate vertical sliding if the new segment's Y value exceeds the threshold
+			if (!moveSegmentsVertically && Math.abs(segment.y - game.height / 2) > verticalSlideThreshold) {
+				moveSegmentsVertically = true;
+				lastStockValue = segment.yValue; // Update the last stock value for slide direction
+			}
 			drawingInProgress = false;
 		}
 	};
 	updateWidth();