Monte-Carlo-Basic-Run-behavior-with-NSF-positions

CODE:

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using System.Collections.Generic;
using System.Linq;


namespace WealthScript1
{
   public class MyStrategy : UserStrategyBase
   {
      // Buy list - symbols that pass entry conditions
      private static List<BarHistory> buys = new List<BarHistory>();

      // Maximum number of entry signals
      private const int maxEntrySignals = 10;

      public MyStrategy() : base()
      {
         StartIndex = 200;
      }

      public override void Initialize(BarHistory bars)
      {

         // Create indicators
         rsi = new RSI(bars.Close, 5);
         PlotIndicator(rsi, new WLColor(0, 0, 0));
         _startIndexList.Add(rsi);

         qqqHistory = GetHistory(bars, "QQQ");
         qqqClose = qqqHistory.Close;
         qqqSMA200 = new SMA(qqqHistory.Close, 200);
         PlotIndicator(qqqSMA200, new WLColor(0, 0, 255), default, default, "QQQPane");
         _startIndexList.Add(qqqSMA200);

         barsLow = bars.Low;
         percentMultiplier = 1.00;
         percentMultiplier = (100.0 - percentMultiplier) / 100.0;
         buyLimitPrice = barsLow * percentMultiplier;
         PlotStopsAndLimits(3);

         // Cache indicators for PreExecute access
         bars.Cache["rsi"] = rsi;
         bars.Cache["qqqClose"] = qqqClose;
         bars.Cache["qqqSMA200"] = qqqSMA200;
         bars.Cache["buyLimitPrice"] = buyLimitPrice;
         bars.Cache["qqqHistory"] = qqqHistory;

         foreach (IndicatorBase ib in _startIndexList)
            if (ib.FirstValidIndex > StartIndex)
               StartIndex = ib.FirstValidIndex;
      }


      public override void PreExecute(DateTime dt, List<BarHistory> participants)
      {
         // Clear previous buy list
         buys.Clear();

         // Evaluate each participant for entry conditions
         foreach (BarHistory participant in participants)
         {
            // Check if this participant passes all entry conditions
            string reason = "";
            bool passed = ShouldEnterPosition(participant, out reason);

            if (passed)
            {
               // Store RSI value for ranking
               int idx = GetCurrentIndex(participant);
               IndicatorBase rsiInd = (IndicatorBase)participant.Cache["rsi"];
               double rsiValue = rsiInd[idx];
               participant.Cache["rsiValue"] = rsiValue;

               buys.Add(participant);
            }
         }

         // Sort by RSI value (ascending - lowest RSI first) and limit to maxEntrySignals
         if (buys.Count > maxEntrySignals)
         {
            buys = buys.OrderBy(b => (double)b.Cache["rsiValue"]).Take(maxEntrySignals).ToList();
         }
      }

      private bool ShouldEnterPosition(BarHistory bars, out string reason)
      {
         int idx = GetCurrentIndex(bars);
         reason = "";

         // Get indicators from cache
         IndicatorBase rsiInd = (IndicatorBase)bars.Cache["rsi"];
         TimeSeries qqqClose = (TimeSeries)bars.Cache["qqqClose"];
         IndicatorBase qqqSMA200 = (IndicatorBase)bars.Cache["qqqSMA200"];

         // Condition 1: RSI < 25.00
         double rsiValue = rsiInd[idx];
         if (rsiValue >= 25.00)
         {
            reason = $"RSI={rsiValue:F2} >= 25.00";
            return false;
         }

         // Condition 2: QQQ Close > QQQ SMA200
         double qqqCloseValue = qqqClose[idx];
         double qqqSMA200Value = qqqSMA200[idx];
         if (qqqCloseValue <= qqqSMA200Value)
         {
            reason = $"QQQ Close={qqqCloseValue:F2} <= QQQ SMA200={qqqSMA200Value:F2}";
            return false;
         }

         return true;
      }

      public override void Execute(BarHistory bars, int idx)
      {
         Position foundPosition0 = FindOpenPosition(0);
         bool inBuyList = buys.Contains(bars);

         if (foundPosition0 == null)
         {
            // Entry logic - buy if symbol is in the buy list
            if (inBuyList)
            {
               // Get buy limit price from cache
               TimeSeries buyLimitPrice = (TimeSeries)bars.Cache["buyLimitPrice"];
               double limitPrice = buyLimitPrice[idx];

               Backtester.CancelationCode = 1;
               _transaction = PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, limitPrice, 0, "Buy " + 1.00 + "% below " + barsLow.Description);
            }
         }
         else
         {
            // Exit conditions
            // Exit: Close above previous high
            if (idx > 0 && bars.Close[idx] > bars.High[idx - 1])
            {
               Backtester.CancelationCode = 1;
               ClosePosition(foundPosition0, OrderType.Market, 0, "Sell At Market - Price Above Previous High");
            }
         }
      }



      private IndicatorBase rsi;
      private TimeSeries qqqClose;
      private IndicatorBase qqqSMA200;
      private BarHistory qqqHistory;
      private double percentMultiplier;
      private TimeSeries barsLow;
      private TimeSeries buyLimitPrice;

      private Transaction _transaction;
      private List<IndicatorBase> _startIndexList = new List<IndicatorBase>();
   }
}