Risk of Ruin Calculator for Blackjack

Master your bankroll and minimize your chances of going bust at the blackjack table.

Blackjack Risk of Ruin Calculator

Session Outcome Probabilities

Probabilities estimated based on simulation of typical session parameters.

Scenario	Probability (%)	Average Outcome ($)
Reach Profit Goal	—	—
Hit Stop-Loss	—	—
No Conclusion (Ruin/Goal)	—	—

What is Blackjack Risk of Ruin?

Blackjack Risk of Ruin refers to the probability that a player will lose their entire bankroll, or fall below a predetermined minimum threshold, before reaching their desired profit goal. In essence, it quantifies the likelihood of going broke. For any gambler, especially those playing games with a house edge like most casino games, understanding and managing this risk is paramount to long-term play and enjoyment. It’s not just about winning hands; it’s about surviving long enough to capitalize on winning streaks and weathering losing streaks without depleting your capital.

Who should use it?

• Casual Blackjack Players: To set realistic session limits and avoid chasing losses.
• Serious Gamblers: To determine optimal bet sizing relative to their bankroll for longer playing sessions.
• Professional Gamblers & Advantage Players: To calculate the exact probability of ruin under specific betting strategies (like card counting) and bankroll management systems.
• Anyone Practicing Bankroll Management: To understand the financial risks associated with their gambling activities.

Common Misconceptions:

• “It only applies to big losers.” Anyone playing a game with variance and a house edge faces some risk of ruin. Even a skilled player with a bankroll can go broke with an unlucky streak or poor bet sizing.
• “A win rate slightly below 50% means inevitable ruin.” Not necessarily. With proper bankroll management and appropriate bet sizing, you can significantly reduce your risk of ruin, even with a slight disadvantage.
• “Stopping when you’re ahead is enough.” While beneficial, simply stopping at a profit goal doesn’t automatically address the risk of ruin if your stop-loss isn’t defined or your bet sizes are too aggressive.

Blackjack Risk of Ruin Formula and Mathematical Explanation

The concept of risk of ruin is deeply rooted in probability and statistics. For a simplified, continuous game, the probability of ruin (P_ruin) for a player starting with bankroll B_start, aiming to reach B_target, with a defined ruin point B_ruin, and a win probability ‘p’ and loss probability ‘q’ (where q=1-p), can be approximated. If the bet size is constant (‘b’), the number of betting units is B/b.

For a game with a positive expectation (p > q), the formula gets complex, but for games with a negative expectation (like most casino games, where p is typically < 0.5), a common approximation is:

If p ≠ q (i.e., p ≠ 0.5):

P(ruin) ≈ [ (q/p)^(B_start/b) – (q/p)^(B_target/b) ] / [ (q/p)^(B_start/b) – 1 ]

This formula is often simplified when the target bankroll is simply to avoid ruin (i.e., B_target = B_ruin), reducing to:

P(ruin) ≈ (q/p)^(B_start/b)

If p = q = 0.5 (fair game):

P(ruin) ≈ (B_ruin / B_start) ^ (B_start / b)

The calculator also incorporates the idea of session goals and stop-losses. The probability of reaching a profit goal ($G$) before hitting a stop-loss limit ($L$) is calculated by considering the probability of winning a single session versus losing it. If you win a session, your bankroll increases by the profit goal; if you lose, it decreases by the stop-loss amount.

Let P_win_session be the probability of winning a session and P_loss_session be the probability of losing a session. These are approximated based on the bet size relative to the goal and stop-loss, and the underlying win probability per hand.

Variables Table

Variable	Meaning	Unit	Typical Range
B_start (Starting Bankroll)	The total amount of money set aside for gambling.	Currency ($)	$100 – $10,000+
B_ruin (Ruin Threshold)	The minimum bankroll amount below which play stops; often $0.	Currency ($)	$0 – $500
B_target (Target Bankroll)	A desired bankroll level to reach.	Currency ($)	$500 – $5,000+
b (Average Bet Size)	The typical amount wagered per hand.	Currency ($)	$5 – $100+
p (Win Probability)	The probability of winning a single hand.	Decimal (0-1)	0.45 – 0.49 (for most players)
q (Loss Probability)	The probability of losing a single hand (1-p).	Decimal (0-1)	0.51 – 0.55 (for most players)
G (Profit Goal)	The desired profit for a single session.	Currency ($)	$50 – $500
L (Stop-Loss Limit)	The maximum loss allowed in a single session.	Currency ($)	$50 – $500

Practical Examples (Real-World Use Cases)

Understanding risk of ruin isn’t just theoretical. Let’s look at how it applies:

Example 1: The Cautious Recreational Player

Scenario: Sarah is a recreational blackjack player. She has a starting bankroll of $1,000. She likes to play for a few hours on weekends and decides her average bet will be $25. She wants to stop playing for the day if she loses $150 (stop-loss) or wins $100 (profit goal). She estimates her win probability, accounting for the house edge, is around 48% (0.48).

Inputs:

• Starting Bankroll: $1,000
• Session Stop-Loss: $150
• Session Profit Goal: $100
• Average Bet Size: $25
• Win Probability: 0.48
• Target Bankroll (for Ruin): $0

Calculator Output (Simulated):

• Primary Result (Risk of Ruin): 15.2%
• Probability of Reaching Goal: 65.8%
• Probability of Hitting Stop-Loss: 34.2%
• Expected Hands Until Ruin/Goal: Approx. 150-200

Financial Interpretation: Sarah has a 15.2% chance of losing her entire $1,000 bankroll if she continues playing indefinitely without hitting her session goals or stop-losses. However, within a single session, she has a 65.8% chance of hitting her $100 profit goal before losing $150. This suggests her session parameters are reasonable for her bankroll and win rate, offering a good chance of success in individual sessions while keeping the long-term risk manageable.

Example 2: The Aggressive Advantage Player

Scenario: John is a skilled advantage player who believes he has a slight edge (win probability of 51% or 0.51) using card counting. He has a larger bankroll of $10,000 and a more aggressive betting strategy, with an average bet of $100. His ruin threshold is set at $8,000 (meaning he’ll stop if his bankroll drops by $2,000). His profit goal for a session is $500.

Inputs:

• Starting Bankroll: $10,000
• Session Stop-Loss: $2,000 (Ruin Threshold)
• Session Profit Goal: $500
• Average Bet Size: $100
• Win Probability: 0.51
• Target Bankroll (for Ruin): $8,000

Calculator Output (Simulated):

• Primary Result (Risk of Ruin): 0.8%
• Probability of Reaching Goal: 70.5%
• Probability of Hitting Stop-Loss: 29.5%
• Expected Hands Until Ruin/Goal: Approx. 250-300

Financial Interpretation: With a positive expectation (p=0.51) and a large bankroll relative to his bet size and stop-loss, John’s long-term risk of ruin is extremely low (0.8%). His session play also heavily favors reaching his profit goal over hitting his stop-loss. This indicates a strong bankroll management strategy for his skill level and betting patterns. The higher number of expected hands suggests longer playing sessions are feasible without dramatically increasing risk.

How to Use This Blackjack Risk of Ruin Calculator

Using the calculator is straightforward, but providing accurate inputs is key to getting meaningful results. Follow these steps:

1. Input Your Starting Bankroll: Enter the total amount of money you have allocated for playing blackjack.
2. Set Session Stop-Loss: Define the maximum amount you are willing to lose in a single playing session. This is crucial for preventing catastrophic losses.
3. Set Session Profit Goal: Enter the profit you aim to achieve in a single session. Set a realistic target.
4. Enter Average Bet Size: Provide your typical wager amount per hand. This should be a conservative average, not your maximum bet.
5. Estimate Win Probability: Input your estimated probability of winning a single hand. For most players at a standard game, this is slightly below 50% (e.g., 0.48 for 48%). Advantage players might have a higher number.
6. Define Target Bankroll for Ruin: Typically, set this to $0 to calculate the risk of losing your entire starting bankroll. You can set it higher if you have a lower threshold for stopping play.
7. Click ‘Calculate Risk of Ruin’: The calculator will instantly provide your primary risk of ruin percentage, along with other key metrics.

How to Read Results:

• Primary Result (Risk of Ruin %): This is your overall probability of losing your entire bankroll (or hitting your defined ruin threshold) over the long term. Lower is always better.
• Probability of Reaching Goal / Hitting Stop-Loss: These indicate the likelihood of success within a typical session based on your defined goals and limits. A higher probability of reaching your goal is desirable.
• Expected Hands: This gives you a rough idea of how many hands you might expect to play before reaching your goal, hitting your stop-loss, or going broke, based on the parameters.
• Assumptions: Double-check these to ensure they accurately reflect your input values.
• Chart & Table: Visualize potential bankroll paths and understand session outcome probabilities.

Decision-Making Guidance:

• High Risk of Ruin (>20%): Re-evaluate your bet sizing relative to your bankroll, your win probability, or your session goals/stop-losses. Consider smaller bets or less aggressive play.
• Low Probability of Reaching Goal (<50%): Your profit goal might be too high, or your stop-loss too low, relative to your bet size and win rate. Adjust these parameters for more favorable session outcomes.
• Balanced Results: If your risk of ruin is acceptable and you have a reasonable chance of hitting your session goal, you’re likely in a good position.

Key Factors That Affect Blackjack Risk of Ruin Results

Several variables significantly influence your probability of ruin. Understanding these helps in making informed decisions:

1. Bankroll Size (B_start): A larger bankroll provides a greater buffer against losing streaks, thus reducing the risk of ruin. The larger your bankroll relative to your bet size, the lower your risk.
2. Bet Size (b): This is perhaps the most critical factor. Smaller, more conservative bets dramatically reduce your risk of ruin. Aggressive betting (large bets relative to your bankroll) significantly increases it, as you can go broke much faster.
3. Win Probability (p): A higher win probability (closer to or above 0.5) reduces your risk of ruin. Players with a genuine edge have a significantly lower risk of ruin than those playing with a disadvantage.
4. House Edge / Negative Expectation: The inherent advantage the casino has in most games means players are statistically likely to lose over the long run. A larger house edge translates to a lower ‘p’ and a higher risk of ruin.
5. Session Stop-Loss Limit (L): A well-defined and adhered-to stop-loss limit is a powerful tool to *cap* your risk of ruin in the short term. Without it, a bad session can quickly turn into long-term ruin.
6. Profit Goal (G): While setting a profit goal is good, an overly ambitious goal in relation to your bankroll and bet size can lead to extended play, increasing exposure to variance and the house edge, thus indirectly increasing long-term risk.
7. Game Rules and Variations: Different blackjack variations have slightly different house edges (e.g., rules on dealer hitting on soft 17, number of decks, payouts for blackjack). Better rules slightly increase your ‘p’ and reduce risk.
8. Betting Systems: While no betting system can overcome a house edge, some (like progressive betting) can dramatically increase short-term volatility and risk of ruin, while others might keep it steady but don’t improve long-term odds. Flat betting is generally best for managing risk.

Frequently Asked Questions (FAQ)

Q1: What is the ideal bet size to minimize risk of ruin in blackjack?

A1: There’s no single “ideal” size, but a common guideline is the “1%” or “2%” rule: never bet more than 1% or 2% of your total bankroll on a single hand. For a $1000 bankroll, this means bets of $10-$20. Smaller bets drastically reduce your risk of ruin.

Q2: Can card counting eliminate the risk of ruin?

A2: Card counting can give a player a statistical edge (p > 0.5), significantly *reducing* the risk of ruin compared to an average player. However, it does not eliminate it entirely. Variance (luck) still plays a role, and larger swings can occur. Proper bankroll management is still essential.

Q3: Does the number of decks used in blackjack affect risk of ruin?

A3: Yes. Generally, fewer decks are better for the player, as they allow for more effective card counting and can slightly improve the player’s edge or reduce the house edge. This translates to a slightly lower risk of ruin.

Q4: What’s the difference between session stop-loss and overall ruin?

A4: A session stop-loss is a limit for a single playing session, designed to prevent a bad day from becoming a disaster. Overall ruin is the risk of losing your entire allocated bankroll over time. The calculator helps assess both.

Q5: Should I increase my bet size when I’m winning?

A5: While tempting, increasing bet size when winning (a form of progressive betting) can significantly increase your risk of ruin. If you hit a losing streak after increasing bets, you can deplete your bankroll much faster. Flat betting (same bet size always) is generally recommended for managing risk.

Q6: How does table selection impact my risk of ruin?

A5: Choosing tables with more favorable rules (e.g., 3:2 blackjack payout, dealer stands on soft 17, ability to double down anywhere, late surrender) reduces the house edge, improving your win probability ‘p’ and thereby lowering your risk of ruin.

Q7: Is it better to have a high profit goal or a low stop-loss?

A7: It’s a balance. A very high profit goal might be unrealistic and lead to longer play, increasing exposure. A very low stop-loss might cause you to quit too often, missing out on winning sessions. The optimal settings depend on your bankroll, bet size, and risk tolerance.

Q8: Can this calculator predict exactly when I’ll go broke?

A8: No. The risk of ruin is a probability, not a certainty. The calculator provides a statistical likelihood based on your inputs. Blackjack involves variance (randomness), so actual outcomes can differ significantly from predictions.

Related Tools and Internal Resources

• Blackjack Strategy Guide

  Learn optimal basic strategy to minimize the house edge and improve your win probability.

• Bankroll Management Calculator

  Helps determine appropriate bet sizing based on your total funds and risk tolerance.

• Casino Edge Calculator

  Understand the house advantage for various casino games.

• General Odds Calculator

  Calculate probabilities for a wide range of scenarios.

• Card Counting Primer

  An introduction to techniques for gaining an edge in blackjack.

• Variance and Volatility Explained

  Understand how luck and randomness impact your gambling results.

// Since we cannot use external libraries or CDNs per instructions, we simulate chart drawing with Canvas API.
// NOTE: This implementation uses Canvas API directly for drawing, avoiding external libraries.

// Simplified direct canvas drawing (without Chart.js)
// This section replaces the Chart.js logic IF Chart.js is NOT available.
// Given the prompt's strictness on "NO external chart libraries", we'll proceed with pure canvas drawing.

// If Chart.js IS desired and allowed, uncomment the line below and ensure the CDN is added in the
// The `updateChart` function above is written for Chart.js.
// If pure canvas is required, a custom drawing function would replace `updateChart`.

// --- Pure Canvas Drawing Implementation ---
function updateChart(startBankroll, betSize, winRate, profitGoal, stopLoss, ruinThreshold, expectedHandsVal) {
if (!chartCtx) return;

var canvas = chartCtx.canvas;
var ctx = chartCtx;
var width = canvas.width;
var height = canvas.height;

// Clear canvas
ctx.clearRect(0, 0, width, height);

var maxHandsForChart = expectedHandsVal && typeof expectedHandsVal === 'number' ? Math.min(expectedHandsVal * 3, 1000) : 500;
maxHandsForChart = Math.max(50, maxHandsForChart); // Ensure reasonable minimum

var trend = (winRate - (1 - winRate)) * betSize;
var maxBankroll = startBankroll + profitGoal * 2; // Max possible value for Y axis
var minBankroll = ruinThreshold - betSize * 2; // Min possible value for Y axis
minBankroll = Math.min(minBankroll, startBankroll - stopLoss * 1.5);
if (minBankroll > ruinThreshold) minBankroll = ruinThreshold - betSize; // Ensure ruin threshold is visible

// Adjust max/min for better visualization
maxBankroll = Math.max(maxBankroll, startBankroll + Math.abs(trend)*maxHandsForChart*0.5);
minBankroll = Math.min(minBankroll, startBankroll - Math.abs(trend)*maxHandsForChart*0.5);
if (minBankroll > 0) minBankroll = 0; // Never show below 0 unless ruin is set higher

var range = maxBankroll - minBankroll;
if (range === 0) range = 1; // Avoid division by zero

// Function to map data value to canvas Y coordinate
var getY = function(value) {
return height - ((value - minBankroll) / range) * height;
};

// Function to map data value to canvas X coordinate
var getX = function(hand) {
return (hand / maxHandsForChart) * width;
};

// Draw Axes
ctx.strokeStyle = '#ccc';
ctx.lineWidth = 1;
ctx.beginPath();
ctx.moveTo(0, getY(minBankroll)); // Y-axis start
ctx.lineTo(0, getY(maxBankroll)); // Y-axis end
ctx.lineTo(width, getY(maxBankroll)); // X-axis end (top line)
ctx.stroke();

// Draw X-axis line at bankroll 0 if applicable
if (minBankroll < 0 && maxBankroll > 0) {
ctx.beginPath();
ctx.moveTo(0, getY(0));
ctx.lineTo(width, getY(0));
ctx.strokeStyle = '#aaa';
ctx.setLineDash([5, 5]);
ctx.stroke();
ctx.setLineDash([]);
}

// Draw Labels and Ticks (simplified)
ctx.fillStyle = '#555';
ctx.font = '10px Arial';
ctx.textAlign = 'center';

// Y-axis ticks
var numTicks = 5;
for (var i = 0; i <= numTicks; i++) { var value = minBankroll + (range / numTicks) * i; var yPos = getY(value); ctx.fillText(value.toFixed(0), 30, yPos); // Label value ctx.beginPath(); ctx.moveTo(0, yPos); ctx.lineTo(5, yPos); // Tick mark ctx.stroke(); } // X-axis ticks (simplified) var numXTicks = 10; for (var i = 0; i <= numXTicks; i++) { var xPos = getX(i * maxHandsForChart / numXTicks); ctx.fillText((i * maxHandsForChart / numXTicks).toFixed(0), xPos, height - 5); ctx.beginPath(); ctx.moveTo(xPos, height); ctx.lineTo(xPos, height-5); ctx.stroke(); } // Draw Data Series var drawSeries = function(color, data, fillToDatasetIndex = null) { ctx.strokeStyle = color; ctx.fillStyle = color; ctx.lineWidth = 2; ctx.beginPath(); var firstPoint = true; for (var i = 0; i < data.length; i++) { var xPos = getX(i); var yPos = getY(data[i]); // Clamp values to visible range yPos = Math.max(0, Math.min(height, yPos)); if (firstPoint) { ctx.moveTo(xPos, yPos); firstPoint = false; } else { ctx.lineTo(xPos, yPos); } } ctx.stroke(); // Fill Area (simplified) if (fillToDatasetIndex !== null) { ctx.globalAlpha = 0.15; // Lower opacity for fill ctx.lineTo(width, getY(data[data.length - 1])); // Go to end of line // Need to draw path backwards for fill var bottomPath = []; for (var i = data.length - 1; i >= 0; i--) {
var xPos = getX(i);
var yPos = getY(data[i]);
yPos = Math.max(0, Math.min(height, yPos)); // Clamp again

// Determine the fill boundary based on the dataset index
var boundaryY;
if (fillToDatasetIndex === 0) { // Fill down to the bottom of the chart (or a baseline)
boundaryY = height; // Fill to the bottom of the canvas
} else {
// Get the corresponding y-value from the target dataset
var targetData = datasets[fillToDatasetIndex].data;
var targetY = getY(targetData[i]);
boundaryY = Math.max(0, Math.min(height, targetY)); // Clamp boundary
}

bottomPath.push({x: xPos, y: boundaryY});
}
ctx.lineTo(bottomPath[bottomPath.length - 1].x, bottomPath[bottomPath.length - 1].y); // Back to start x
ctx.lineTo(bottomPath[0].x, bottomPath[0].y); // Back to start y
ctx.fill();
ctx.globalAlpha = 1.0; // Reset opacity
}
};

// Prepare datasets for fill logic
var datasets = [];
var expectedPathData = [];
var upsideBoundsData = [];
var downsideBoundsData = [];

for (var i = 0; i < data.length; i++) { var trendVal = startBankroll + trend * i; var varianceFactor = 0.8 * Math.sqrt(i); var upsideVal = startBankroll + trend * i + varianceFactor * betSize * 2; var downsideVal = startBankroll + trend * i - varianceFactor * betSize * 2; expectedPathData.push(trendVal); upsideBoundsData.push(Math.min(upsideVal, startBankroll + profitGoal * 1.5)); downsideBoundsData.push(Math.max(downsideVal, ruinThreshold - betSize)); // Break if essential paths reach limits if (i > 50 && (trendVal >= startBankroll + profitGoal || trendVal <= startBankroll - stopLoss || trendVal <= ruinThreshold)) { break; } } // Ensure arrays are of same length for filling var currentMaxHands = expectedPathData.length; while(upsideBoundsData.length < currentMaxHands) upsideBoundsData.push(upsideBoundsData[upsideBoundsData.length-1]); while(downsideBoundsData.length < currentMaxHands) downsideBoundsData.push(downsideBoundsData[downsideBoundsData.length-1]); datasets.push({label: 'Downside', data: downsideBoundsData}); // Dataset 0 datasets.push({label: 'Expected', data: expectedPathData}); // Dataset 1 datasets.push({label: 'Upside', data: upsideBoundsData}); // Dataset 2 // Draw Upside drawSeries('#28a745', datasets[2].data); // Green for upside // Fill between Upside and Expected (Dataset 2 -> Dataset 1)
ctx.globalAlpha = 0.15;
ctx.fillStyle = '#28a745';
ctx.beginPath();
for (var i = 0; i < datasets[2].data.length; i++) { var xPos = getX(i); var yPos = getY(datasets[2].data[i]); yPos = Math.max(0, Math.min(height, yPos)); if (i === 0) ctx.moveTo(xPos, yPos); else ctx.lineTo(xPos, yPos); } // Draw back along the expected path for (var i = datasets[1].data.length - 1; i >= 0; i--) {
var xPos = getX(i);
var yPos = getY(datasets[1].data[i]);
yPos = Math.max(0, Math.min(height, yPos));
ctx.lineTo(xPos, yPos);
}
ctx.closePath();
ctx.fill();
ctx.globalAlpha = 1.0;

// Draw Downside
drawSeries('rgba(220, 53, 69, 1)', datasets[0].data); // Red for downside
// Fill between Expected and Downside (Dataset 1 -> Dataset 0)
ctx.globalAlpha = 0.15;
ctx.fillStyle = 'rgba(220, 53, 69, 1)';
ctx.beginPath();
for (var i = 0; i < datasets[1].data.length; i++) { var xPos = getX(i); var yPos = getY(datasets[1].data[i]); yPos = Math.max(0, Math.min(height, yPos)); if (i === 0) ctx.moveTo(xPos, yPos); else ctx.lineTo(xPos, yPos); } // Draw back along the downside path for (var i = datasets[0].data.length - 1; i >= 0; i--) {
var xPos = getX(i);
var yPos = getY(datasets[0].data[i]);
yPos = Math.max(0, Math.min(height, yPos));
ctx.lineTo(xPos, yPos);
}
ctx.closePath();
ctx.fill();
ctx.globalAlpha = 1.0;

// Draw Expected Path last
drawSeries('#004a99', datasets[1].data);

// Add Goal and Stop-Loss lines
var goalY = getY(startBankroll + profitGoal);
var stopLossY = getY(startBankroll - stopLoss);
var ruinY = getY(ruinThreshold);

ctx.strokeStyle = '#28a745'; // Green for goal
ctx.setLineDash([10, 5]);
ctx.beginPath();
ctx.moveTo(0, goalY);
ctx.lineTo(width, goalY);
ctx.stroke();

ctx.strokeStyle = 'red'; // Red for stop-loss
ctx.beginPath();
ctx.moveTo(0, stopLossY);
ctx.lineTo(width, stopLossY);
ctx.stroke();

if (ruinThreshold > 0) {
ctx.strokeStyle = 'orange'; // Orange for specific ruin threshold
ctx.beginPath();
ctx.moveTo(0, ruinY);
ctx.lineTo(width, ruinY);
ctx.stroke();
}
ctx.setLineDash([]); // Reset line dash

// Draw legend (simplified)
ctx.textAlign = 'left';
ctx.font = '12px Arial';
var legendY = 20;
var legendX = 10;
var lineHeight = 18;

// Expected Path Legend
ctx.fillStyle = '#004a99';
ctx.fillRect(legendX, legendY, 15, 10);
ctx.fillStyle = '#333';
ctx.fillText('Expected Path', legendX + 25, legendY + 10);
legendY += lineHeight;

// Upside Legend
ctx.fillStyle = '#28a745';
ctx.fillRect(legendX, legendY, 15, 10);
ctx.fillStyle = '#333';
ctx.fillText('Potential Upside', legendX + 25, legendY + 10);
legendY += lineHeight;

// Downside Legend
ctx.fillStyle = 'rgba(220, 53, 69, 0.5)'; // Use a slightly transparent red fill color for legend consistency
ctx.fillRect(legendX, legendY, 15, 10);
ctx.fillStyle = '#333';
ctx.fillText('Potential Downside', legendX + 25, legendY + 10);
legendY += lineHeight;

// Goal Line Legend
ctx.strokeStyle = '#28a745';
ctx.lineWidth = 2;
ctx.beginPath();
ctx.moveTo(legendX, legendY + 5);
ctx.lineTo(legendX + 15, legendY + 5);
ctx.stroke();
ctx.fillStyle = '#333';
ctx.fillText('Profit Goal Line', legendX + 25, legendY + 10);
legendY += lineHeight;

// Stop-Loss Line Legend
ctx.strokeStyle = 'red';
ctx.beginPath();
ctx.moveTo(legendX, legendY + 5);
ctx.lineTo(legendX + 15, legendY + 5);
ctx.stroke();
ctx.fillStyle = '#333';
ctx.fillText('Stop-Loss Line', legendX + 25, legendY + 10);

if (ruinThreshold > 0) {
legendY += lineHeight;
ctx.strokeStyle = 'orange';
ctx.beginPath();
ctx.moveTo(legendX, legendY + 5);
ctx.lineTo(legendX + 15, legendY + 5);
ctx.stroke();
ctx.fillStyle = '#333';
ctx.fillText('Ruin Threshold Line', legendX + 25, legendY + 10);
}

ctx.lineWidth = 1; // Reset line width
}

// Initial calculation on load
document.addEventListener('DOMContentLoaded', function() {
// Set canvas size based on container width
var canvas = document.getElementById('bankrollChart');
if (canvas) {
// Make canvas responsive
canvas.style.width ='100%';
canvas.style.height ='auto';
// You might need to set explicit dimensions if CSS doesn't handle it perfectly
// canvas.width = canvas.offsetWidth; // Set to current CSS width
// canvas.height = 400; // Set a fixed height or calculate based on aspect ratio
canvas.height = Math.max(250, canvas.offsetWidth * 0.5); // Example: maintain aspect ratio 2:1

chartCtx = canvas.getContext('2d');
}
calculateRiskOfRuin();
});

// Adjust canvas size on resize
window.addEventListener('resize', function() {
var canvas = document.getElementById('bankrollChart');
if (canvas && chartCtx) {
canvas.height = Math.max(250, canvas.offsetWidth * 0.5); // Re-calculate height
// Re-draw chart with new dimensions if necessary, or rely on calculateRiskOfRuin() to be called again
calculateRiskOfRuin(); // Recalculate and redraw on resize
}
});