prophetdiceskills 1.0.0__tar.gz

prophetdiceskills-1.0.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: prophetdiceskills
+Version: 1.0.0
+Summary: A library converting RNG cracking algorithms into callable functions with bot emulation.
+Author: Prophet Dice Skills
+Author-email: prophet@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: PyWavelets
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Requires-Dist: river
+Requires-Dist: torch
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Prophet Dice Skills
+
+This library provides all the fundamental RNG cracking functions converted into callable API methods. 
+It also brings a full object-oriented dice bot simulation suite, letting you retrieve balances, place conditions, and wager effectively using standard interfaces.
+
+## Usage
+
+```python
+from prophetdiceskills import ProphetBot, aggressive_time_crack
+
+bot = ProphetBot(initial_balance=5000.0)
+bot.setwager(10)
+bot.setcondition("<")
+bot.settarget(49.5)
+
+result = 45.12
+bot.simulate_roll(result)
+
+print(bot.getbalance())
+print(bot.getprofit())
+```
+
+## Functions Included
+- `getbalance()`
+- `setcondition()`
+- `setwager()`
+- `getresult()`
+- ... and more, along with all `beatstake` / `stakeenhanced` capabilities!
+- `GroundbreakingPredictor` for Deep Learning (Transformer/MLP/RF) time-series forecasting.
+- `AdvancedBettingSystem` with Anti-Human Burst Strategies.
+- `RegimeDetector` and `SimpleKalmanFilter` for signal processing and anomaly detection.

prophetdiceskills-1.0.0/README.md

@@ -0,0 +1,31 @@
+# Prophet Dice Skills
+
+This library provides all the fundamental RNG cracking functions converted into callable API methods. 
+It also brings a full object-oriented dice bot simulation suite, letting you retrieve balances, place conditions, and wager effectively using standard interfaces.
+
+## Usage
+
+```python
+from prophetdiceskills import ProphetBot, aggressive_time_crack
+
+bot = ProphetBot(initial_balance=5000.0)
+bot.setwager(10)
+bot.setcondition("<")
+bot.settarget(49.5)
+
+result = 45.12
+bot.simulate_roll(result)
+
+print(bot.getbalance())
+print(bot.getprofit())
+```
+
+## Functions Included
+- `getbalance()`
+- `setcondition()`
+- `setwager()`
+- `getresult()`
+- ... and more, along with all `beatstake` / `stakeenhanced` capabilities!
+- `GroundbreakingPredictor` for Deep Learning (Transformer/MLP/RF) time-series forecasting.
+- `AdvancedBettingSystem` with Anti-Human Burst Strategies.
+- `RegimeDetector` and `SimpleKalmanFilter` for signal processing and anomaly detection.

prophetdiceskills-1.0.0/prophetdiceskills/__init__.py

@@ -0,0 +1,29 @@
+from .core import StakeRNG, aggressive_time_crack, aggressive_collision_farm, analyze_n_gram_transitions, verify_server_seed
+from .bot import ProphetBot
+from .ml import GroundbreakingPredictor, AdvancedFeatureEngineer, RegimeDetector, SimpleKalmanFilter
+from .advanced_bot import AdvancedBettingSystem, ConfigManager
+from .charting import RealTimePlotter
+from .online_learning import OnlineLearningTracker
+from .advanced_dl import TransformerPredictor
+from .anomaly import RNGAnomalyDetector
+from .quantum import QuantumInspiredOptimizer
+
+__all__ = [
+    "StakeRNG",
+    "aggressive_time_crack",
+    "aggressive_collision_farm",
+    "analyze_n_gram_transitions",
+    "verify_server_seed",
+    "ProphetBot",
+    "GroundbreakingPredictor",
+    "AdvancedFeatureEngineer",
+    "RegimeDetector",
+    "SimpleKalmanFilter",
+    "AdvancedBettingSystem",
+    "ConfigManager",
+    "RealTimePlotter",
+    "OnlineLearningTracker",
+    "TransformerPredictor",
+    "RNGAnomalyDetector",
+    "QuantumInspiredOptimizer"
+]

prophetdiceskills-1.0.0/prophetdiceskills/advanced_bot.py

@@ -0,0 +1,198 @@
+import json
+import os
+import random
+from collections import deque
+import numpy as np
+
+CONFIG_FILE = "auditor_config.json"
+
+class ConfigManager:
+    """Manages persistent settings"""
+    def __init__(self, filename=CONFIG_FILE):
+        self.filename = filename
+        self.config = {
+            "base_bet": 0.0000001,
+            "risk_level": "balanced", # conservative, balanced, aggressive
+            "stop_loss_pct": 0.15,
+            "take_profit_pct": 0.50,
+            "auto_retrain": True
+        }
+        self.load()
+
+    def load(self):
+        if os.path.exists(self.filename):
+            try:
+                with open(self.filename, 'r') as f:
+                    loaded = json.load(f)
+                    self.config.update(loaded)
+            except:
+                pass
+
+    def save(self):
+        try:
+            with open(self.filename, 'w') as f:
+                json.dump(self.config, f, indent=4)
+        except:
+            pass
+
+    def get(self, key):
+        return self.config.get(key)
+
+    def set(self, key, value):
+        self.config[key] = value
+        self.save()
+
+class AdvancedBettingSystem:
+    """
+    Short Burst Reset Anti-Human Non-Standard Strategy
+    Focuses on short, aggressive profit taking sequences with frequent resets
+    to avoid pattern detection and long-term negative variance.
+    """
+
+    def __init__(self, config_manager=None):
+        self.config = config_manager or ConfigManager()
+        self.base_bet = self.config.get("base_bet")
+        self.bankroll = 1.0
+        self.peak_bankroll = 1.0
+        self.drawdown = 0.0
+        
+        # Performance tracking
+        self.trade_history = deque(maxlen=100)
+        self.short_term_memory = deque(maxlen=10) # For circuit breaker
+        self.win_rate = 0.5
+        self.sharpe_ratio = 0.0
+        
+        # Burst Strategy State
+        self.burst_active = False
+        self.burst_step = 0
+        self.burst_history = []
+        self.cooldown_steps = 0
+        self.circuit_breaker_active = False
+        self.circuit_breaker_steps = 0
+        self.retrain_requested = False # Request model retraining
+        
+        # Configuration
+        self.max_burst_length = 4
+        self.burst_multiplier = 2.5  # Aggressive start
+        self.compound_rate = 1.5     # Reinvest 50% of winnings in burst
+        self.reset_on_loss = True    # Anti-Martingale (Reset immediately on loss)
+        
+        # Anti-Human Parameters
+        self.jitter_factor = 0.13    # Add randomness to bet size
+        self.random_reset_prob = 0.05 # Randomly reset burst
+        
+        # Flaw Detection / Risk Management
+        self.min_confidence_threshold = 0.55
+        self.max_drawdown_pct = 0.15 # Tightened stop loss
+        
+        self.apply_risk_profile()
+
+    def apply_risk_profile(self):
+        """Adjust parameters based on risk profile"""
+        profile = self.config.get("risk_level")
+        if profile == "conservative":
+            self.burst_multiplier = 1.5
+            self.compound_rate = 1.1
+            self.min_confidence_threshold = 0.65
+            self.max_drawdown_pct = 0.10
+        elif profile == "aggressive":
+            self.burst_multiplier = 3.0
+            self.compound_rate = 1.8
+            self.min_confidence_threshold = 0.50
+            self.max_drawdown_pct = 0.25
+        else: # balanced
+            self.burst_multiplier = 2.5
+            self.compound_rate = 1.5
+            self.min_confidence_threshold = 0.55
+            self.max_drawdown_pct = 0.15
+
+    def get_bet_size(self, prediction_data):
+        """Calculate bet size based on Short Burst Reset Strategy"""
+        # Refresh base bet from config in case it changed
+        self.base_bet = self.config.get("base_bet")
+        
+        if not prediction_data:
+            return self.base_bet
+
+        confidence = prediction_data['confidence']
+        model_health = prediction_data.get('model_health', 100.0)
+        micro_regime = prediction_data.get('micro_regime', 'NORMAL')
+        
+        if self.circuit_breaker_active:
+            self.circuit_breaker_steps -= 1
+            if self.circuit_breaker_steps <= 0:
+                self.circuit_breaker_active = False
+            return self.base_bet
+            
+        if self.cooldown_steps > 0:
+            self.cooldown_steps -= 1
+            return self.base_bet
+            
+        if not self.burst_active:
+            threshold = self.min_confidence_threshold
+            if model_health < 70:
+                threshold += 0.1
+            if micro_regime == "CHAOS":
+                threshold += 0.15
+                
+            if confidence > threshold or (random.random() < 0.10 and model_health > 80):
+                self.burst_active = True
+                self.burst_step = 1
+                bet = self.base_bet * self.burst_multiplier
+            else:
+                return self.base_bet
+        else:
+            if self.burst_step == 1:
+                bet = self.base_bet * self.burst_multiplier
+            else:
+                bet = self.base_bet * (self.burst_multiplier * (self.compound_rate ** (self.burst_step - 1)))
+                
+            bet = min(bet, self.base_bet * 100.0)
+
+        jitter = bet * (random.uniform(-self.jitter_factor, self.jitter_factor))
+        final_bet = bet + jitter
+        final_bet = max(self.base_bet, final_bet)
+        
+        if self.drawdown > self.max_drawdown_pct:
+            final_bet = self.base_bet
+            self.burst_active = False
+
+        return final_bet
+
+    def update(self, bet_size, won, profit):
+        """Update state based on result"""
+        self.bankroll += profit
+        self.peak_bankroll = max(self.peak_bankroll, self.bankroll)
+        self.drawdown = (self.peak_bankroll - self.bankroll) / self.peak_bankroll
+        
+        self.trade_history.append({'profit': profit, 'bet': bet_size})
+        self.short_term_memory.append(1 if won else 0)
+        
+        if len(self.short_term_memory) >= 5:
+            recent_wins = sum(list(self.short_term_memory)[-5:])
+            if recent_wins <= 1:
+                self.circuit_breaker_active = True
+                self.circuit_breaker_steps = 10
+                self.burst_active = False
+                self.retrain_requested = True
+        
+        if self.burst_active:
+            if won:
+                self.burst_step += 1
+                if self.burst_step > self.max_burst_length:
+                    self.burst_active = False
+                    self.cooldown_steps = random.randint(2, 5)
+            else:
+                self.burst_active = False
+                self.cooldown_steps = random.randint(1, 3)
+                
+        if self.burst_active and random.random() < self.random_reset_prob:
+             self.burst_active = False
+             self.cooldown_steps = 1
+
+        wins = [t for t in self.trade_history if t['profit'] > 0]
+        self.win_rate = len(wins) / len(self.trade_history) if self.trade_history else 0
+        
+        if len(self.trade_history) > 10:
+            profits = [t['profit'] for t in self.trade_history]
+            self.sharpe_ratio = np.mean(profits) / (np.std(profits) + 1e-9)

prophetdiceskills-1.0.0/prophetdiceskills/advanced_dl.py

@@ -0,0 +1,146 @@
+import numpy as np
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from torch.utils.data import DataLoader, TensorDataset
+    HAS_TORCH = True
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+except ImportError:
+    HAS_TORCH = False
+    DEVICE = None
+
+class TimeSeriesTransformer(nn.Module if HAS_TORCH else object):
+    """
+    Advanced Multi-Head Attention Transformer for Deep Sequence Forecasting.
+    Designed to catch non-linear microscopic patterns in RNG outputs.
+    """
+    def __init__(self, input_dim=1, d_model=64, nhead=4, num_layers=3, dropout=0.1):
+        if not HAS_TORCH:
+            raise ImportError("PyTorch is required for the Transformer module.")
+        super().__init__()
+        self.input_projection = nn.Linear(input_dim, d_model)
+        
+        # Positional Encoding
+        self.pos_encoder = PositionalEncoding(d_model, dropout)
+        
+        encoder_layers = nn.TransformerEncoderLayer(d_model, nhead, d_model*4, dropout, batch_first=True)
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layers, num_layers)
+        
+        self.decoder = nn.Sequential(
+            nn.Linear(d_model, d_model // 2),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_model // 2, 1)
+        )
+
+    def forward(self, src):
+        # src shape: [batch_size, sequence_length, input_dim]
+        src = self.input_projection(src)
+        src = self.pos_encoder(src)
+        output = self.transformer_encoder(src)
+        # Take the last sequence output to predict the next step
+        last_out = output[:, -1, :]
+        return self.decoder(last_out)
+
+class PositionalEncoding(nn.Module if HAS_TORCH else object):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        if not HAS_TORCH: return
+        super().__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        position = torch.arange(max_len).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2) * (-np.log(10000.0) / d_model))
+        pe = torch.zeros(max_len, 1, d_model)
+        pe[:, 0, 0::2] = torch.sin(position * div_term)
+        pe[:, 0, 1::2] = torch.cos(position * div_term)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        """
+        Arguments:
+            x: Tensor, shape ``[batch_size, seq_len, embedding_dim]``
+        """
+        x = x + self.pe[:x.size(1)].transpose(0, 1)
+        return self.dropout(x)
+
+class TransformerPredictor:
+    """Wrapper to easily train and infer using the Transformer."""
+    def __init__(self, sequence_length=20, epochs=50, lr=0.001):
+        self.sequence_length = sequence_length
+        self.epochs = epochs
+        self.lr = lr
+        self.model = None
+        self.is_trained = False
+        
+        if HAS_TORCH:
+            self.model = TimeSeriesTransformer(input_dim=1).to(DEVICE)
+            self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr)
+            self.criterion = nn.MSELoss()
+
+    def _prepare_data(self, history):
+        if len(history) <= self.sequence_length:
+            return None, None
+            
+        X, y = [], []
+        for i in range(len(history) - self.sequence_length):
+            raw_x = history[i:i+self.sequence_length]
+            raw_y = history[i+self.sequence_length]
+            
+            flat_x = [float(np.ravel(val)[0]) for val in raw_x]
+            flat_y = float(np.ravel(raw_y)[0])
+            
+            X.append(flat_x)
+            y.append(flat_y)
+            
+        # Normalize to 0-1 for better gradients
+        X = np.array(X, dtype=np.float32) / 100.0
+        y = np.array(y, dtype=np.float32) / 100.0
+        
+        X = torch.tensor(X).unsqueeze(-1).to(DEVICE) # [Batch, Seq, 1]
+        y = torch.tensor(y).unsqueeze(-1).to(DEVICE) # [Batch, 1]
+        return X, y
+
+    def train(self, history):
+        if not HAS_TORCH or len(history) < self.sequence_length * 2:
+            return False
+            
+        X, y = self._prepare_data(history)
+        if X is None: return False
+        
+        dataset = TensorDataset(X, y)
+        loader = DataLoader(dataset, batch_size=32, shuffle=True)
+        
+        self.model.train()
+        for epoch in range(self.epochs):
+            total_loss = 0
+            for batch_x, batch_y in loader:
+                self.optimizer.zero_grad()
+                output = self.model(batch_x)
+                loss = self.criterion(output, batch_y)
+                loss.backward()
+                self.optimizer.step()
+                total_loss += loss.item()
+                
+        self.is_trained = True
+        return True
+        
+    def predict(self, recent_history):
+        if not self.is_trained or not HAS_TORCH:
+            return None
+        if len(recent_history) < self.sequence_length:
+            return None
+            
+        # Take the most recent sequences and flatten them in case they are nested
+        raw_seq = recent_history[-self.sequence_length:]
+        flat_seq = [float(np.ravel(x)[0]) for x in raw_seq]
+        seq = np.array(flat_seq, dtype=np.float32) / 100.0
+        seq = torch.tensor(seq).unsqueeze(0).unsqueeze(-1).to(DEVICE) # [1, Seq, 1]
+        
+        self.model.eval()
+        with torch.no_grad():
+            pred = self.model(seq)
+            
+        # Denormalize
+        return float(pred.item() * 100.0)

prophetdiceskills-1.0.0/prophetdiceskills/anomaly.py

@@ -0,0 +1,81 @@
+import numpy as np
+from collections import deque
+
+try:
+    from sklearn.ensemble import IsolationForest
+    HAS_IFOREST = True
+except ImportError:
+    HAS_IFOREST = False
+
+class RNGAnomalyDetector:
+    """
+    Monitors the stream of RNG values to detect statistically bizarre 
+    sequences that indicate the Casino might have altered the seed 
+    or logic server-side.
+    """
+    def __init__(self, window_size=50, contamination=0.05):
+        self.window_size = window_size
+        self.contamination = contamination
+        self.history = deque(maxlen=2000)
+        self.model = None
+        self.is_fitted = False
+        
+        if HAS_IFOREST:
+            self.model = IsolationForest(
+                n_estimators=100, 
+                contamination=self.contamination,
+                random_state=42
+            )
+            
+    def _extract_window_features(self, sequence):
+        """Extracts spatial/temporal properties of a sequence window."""
+        seq = np.array(sequence)
+        return [
+            np.mean(seq),
+            np.std(seq),
+            np.max(seq) - np.min(seq),
+            np.mean(np.abs(np.diff(seq))), # Average jump size
+            np.sum(seq > 50) / len(seq),   # Ratio over 50
+            np.median(seq)
+        ]
+
+    def add(self, roll):
+        self.history.append(roll)
+        
+        # Fit the anomaly baseline when we have enough data
+        if HAS_IFOREST and not self.is_fitted and len(self.history) >= 500:
+            self.fit_baseline()
+
+    def fit_baseline(self):
+        """Trains what a 'Normal' RNG sequence looks like for this seed."""
+        if not HAS_IFOREST or len(self.history) < self.window_size * 2:
+            return
+            
+        data = list(self.history)
+        features = []
+        for i in range(len(data) - self.window_size):
+            window = data[i:i+self.window_size]
+            features.append(self._extract_window_features(window))
+            
+        if len(features) > 100:
+            self.model.fit(features)
+            self.is_fitted = True
+
+    def check_anomaly(self):
+        """
+        Checks if the most recent window is anomalous compared to the baseline.
+        Returns: ExceptionScore (-1 for Anomaly, 1 for Normal), and Raw Distance.
+        """
+        if not self.is_fitted or not HAS_IFOREST:
+            return 1, 0.0
+            
+        if len(self.history) < self.window_size:
+            return 1, 0.0
+            
+        recent_window = list(self.history)[-self.window_size:]
+        feat = np.array([self._extract_window_features(recent_window)])
+        
+        prediction = self.model.predict(feat)[0]
+        score = self.model.decision_function(feat)[0]
+        
+        return prediction, score

prophetdiceskills-1.0.0/prophetdiceskills/bot.py

@@ -0,0 +1,62 @@
+class ProphetBot:
+    """A standard bot framework with typical dice bot functions."""
+    def __init__(self, initial_balance=1000.0):
+        self._balance = initial_balance
+        self._wager = 0.0
+        self._condition = "<"
+        self._target = 50.0
+        self._win = False
+        self._current_streak = 0
+        self._last_result = 0.0
+        self._profit = 0.0
+        
+    def getbalance(self):
+        """Returns the current balance."""
+        return self._balance
+        
+    def setwager(self, amount):
+        """Sets the current wager."""
+        self._wager = amount
+        
+    def setcondition(self, condition):
+        """Sets the win condition ('<' or '>')."""
+        self._condition = condition
+        
+    def settarget(self, target):
+        """Sets the target outcome (multiplier or chance)."""
+        self._target = target
+        
+    def getresult(self):
+        """Returns the result of the last roll."""
+        return self._last_result
+        
+    def simulate_roll(self, result):
+        """Simulates an incoming roll result from the casino."""
+        self._last_result = result
+        if self._condition == "<":
+            self._win = result < self._target
+        elif self._condition == ">":
+            self._win = result > self._target
+            
+        if self._win:
+            # Simple assumption: 99% RTP
+            multiplier = 99.0 / self._target if self._target > 0 else 2.0
+            payout = self._wager * multiplier
+            self._profit += (payout - self._wager)
+            self._balance += (payout - self._wager)
+            self._current_streak = self._current_streak + 1 if self._current_streak > 0 else 1
+        else:
+            self._profit -= self._wager
+            self._balance -= self._wager
+            self._current_streak = self._current_streak - 1 if self._current_streak < 0 else -1
+            
+        return self._win
+        
+    def getprofit(self):
+        return self._profit
+        
+    def is_win(self):
+        return self._win
+        
+    def getstreak(self):
+        return self._current_streak

prophetdiceskills-1.0.0/prophetdiceskills/charting.py

@@ -0,0 +1,81 @@
+import numpy as np
+import collections
+
+try:
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    from IPython.display import clear_output
+    HAS_PLOTTING = True
+except ImportError:
+    HAS_PLOTTING = False
+
+class RealTimePlotter:
+    """Provides real-time matplotlib/seaborn charts tracking predictions, accuracy, and bankroll."""
+    def __init__(self, max_points=200):
+        self.max_points = max_points
+        self.rolls = collections.deque(maxlen=max_points)
+        self.predictions = collections.deque(maxlen=max_points)
+        self.accuracy = collections.deque(maxlen=max_points)
+        self.bankroll = collections.deque(maxlen=max_points)
+        self.win_loss = collections.deque(maxlen=max_points)
+        
+        if HAS_PLOTTING:
+            sns.set_theme(style="darkgrid")
+            plt.ion()  # Interactive mode
+            self.fig, self.axs = plt.subplots(3, 1, figsize=(10, 12))
+            self.fig.canvas.manager.set_window_title('Prophet ML Auditor Dashboard')
+            plt.tight_layout(pad=3.0)
+            
+    def update(self, roll_result, prediction, current_accuracy, current_bankroll, won):
+        """Update tracker with new data from the latest roll step."""
+        self.rolls.append(roll_result)
+        self.predictions.append(prediction)
+        self.accuracy.append(current_accuracy)
+        self.bankroll.append(current_bankroll)
+        self.win_loss.append(1 if won else 0)
+        
+        if HAS_PLOTTING and len(self.rolls) > 5:
+            self._draw()
+            
+    def _draw(self):
+        """Redraws the matplot canvas."""
+        for ax in self.axs:
+            ax.clear()
+            
+        x_data = range(len(self.rolls))
+        
+        # Plot 1: Rolls vs Predictions
+        self.axs[0].plot(x_data, self.rolls, label="Actual Roll", color="blue", alpha=0.6)
+        pred_array = np.array(self.predictions)
+        
+        # Color correct predictions green, incorrect red
+        colors = ['green' if w else 'red' for w in self.win_loss]
+        self.axs[0].scatter(x_data, pred_array, c=colors, label="Prediction (G=Win, R=Loss)", s=15, zorder=5)
+        self.axs[0].axhline(y=50, color='gray', linestyle='--', alpha=0.5)
+        self.axs[0].set_title("Actual Rolls vs Predictions")
+        self.axs[0].set_ylabel("Outcome")
+        self.axs[0].legend(loc="upper left")
+        
+        # Plot 2: Model Accuracy (Moving Average)
+        self.axs[1].plot(x_data, [a * 100 for a in self.accuracy], label="Overall Accuracy %", color="purple")
+        self.axs[1].axhline(y=50, color='red', linestyle='--', alpha=0.5, label="Baseline (50%)")
+        self.axs[1].set_title("Prediction Accuracy")
+        self.axs[1].set_ylabel("Accuracy (%)")
+        self.axs[1].set_ylim([0, 100])
+        self.axs[1].legend(loc="upper left")
+        
+        # Plot 3: Bankroll
+        self.axs[2].plot(x_data, self.bankroll, label="Bankroll", color="gold")
+        self.axs[2].set_title("Bankroll Evolution")
+        self.axs[2].set_ylabel("Balance")
+        self.axs[2].set_xlabel("Roll Number")
+        self.axs[2].legend(loc="upper left")
+        
+        plt.draw()
+        plt.pause(0.01)
+        
+    def show_final(self):
+        """Blocking call to show final charts."""
+        if HAS_PLOTTING:
+            plt.ioff()
+            plt.show()