algorembrant commited on 2 days ago

Commit

9f5939d

verified ·

1 Parent(s): ee00585

Add files using upload-large-folder tool

Browse files

Files changed (20) hide show

MQL5 Folder/0_00-3_00 Range/Diversification.ipynb +340 -0
MQL5 Folder/0_00-3_00 Range/Refined version.ipynb +0 -0
MQL5 Folder/0_00-3_00 Range/attempts.ipynb +0 -0
MQL5 Folder/0_00-3_00 Range/scratch.mql +237 -0
MQL5 Folder/89RS MT5 version/89RS MT5 version.ipynb +174 -0
MQL5 Folder/ADX Filter/First candle highlighter with adx.ipynb +178 -0
MQL5 Folder/ADX Filter/template with 1st candle highlighter.mq5 +86 -0
MQL5 Folder/Dec25_Volume Profile based breakout momentuim strategy/codeclaude.c++ +445 -0
MQL5 Folder/Dec25_Volume Profile based breakout momentuim strategy/codegemini.c++ +382 -0
MQL5 Folder/Dec29_6-8 range/strategy.ipynb +0 -0
MQL5 Folder/Dec29_6-8 range/v1.c++ +273 -0
MQL5 Folder/Dec29_6-8 range/v2.c++ +284 -0
MQL5 Folder/Developing POC/developing POC line.ipynb +34 -0
MQL5 Folder/H3 0 bar redbear bluebull (indicator)/1_version.mq5 +86 -0
MQL5 Folder/H3 0 bar redbear bluebull (indicator)/H3 0 bar redbear bluebull (indicator).ipynb +322 -0
MQL5 Folder/Revised 0-3/1_latestbest.mq5 +256 -0
MQL5 Folder/Revised 0-3/2_latestbest.mq5 +262 -0
MQL5 Folder/Revised 0-3/3_latestbest.mw5 +297 -0
MQL5 Folder/Revised 0-3/4_latestbest.mq5 +294 -0
MQL5 Folder/Revised 0-3/revised from very begining.ipynb +0 -0

MQL5 Folder/0_00-3_00 Range/Diversification.ipynb ADDED Viewed

	@@ -0,0 +1,340 @@

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "54b64fc5",
+   "metadata": {},
+   "source": [
+    "make it able to trade all {BTCUSDc\n",
+    "AUDCADc\n",
+    "AUDCHFc\n",
+    "AUDJPYc\n",
+    "AUDNZDc\n",
+    "AUDUSDc\n",
+    "CADJPYc\n",
+    "CHFJPYc\n",
+    "EURAUDc\n",
+    "EURCADc\n",
+    "EURCHFc \n",
+    "EURGBPc\n",
+    "EURJPYc   \n",
+    "EURNZDc   \n",
+    "EURUSDc   \n",
+    "GBPAUDc   \n",
+    "GBPCADc   \n",
+    "GBPCHFc   \n",
+    "GBPJPYc   \n",
+    "GBPNZDc   \n",
+    "GBPUSDc   \n",
+    "NZDJPYc    \n",
+    "NZDUSDc   \n",
+    "USDCADc   \n",
+    "USDCHFc\n",
+    "USDHKDc   \n",
+    "USDJPYc   \n",
+    "XAGUSDc    \n",
+    "XAUUSDc  }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "794e17b1",
+   "metadata": {},
+   "source": [
+    "trade all of these assets with each 1% risk per trade {NZDUSDc, USDJPYc, XAGUSDc, XAUUSDc} for {#property strict\n",
+    "#include <Trade/Trade.mqh>\n",
+    "\n",
+    "CTrade trade;\n",
+    "\n",
+    "// =====================\n",
+    "// INPUTS\n",
+    "// =====================\n",
+    "input double RiskPercent = 1.0;   // 1% risk per trade\n",
+    "input int    TimerSec    = 5;     // timer interval in seconds\n",
+    "\n",
+    "// =====================\n",
+    "// GLOBALS\n",
+    "// =====================\n",
+    "string   TradeSymbol;\n",
+    "datetime lastEntryBarTime = 0;     // track last entry bar time\n",
+    "datetime lastTrailBarTime = 0;     // track last trailing bar time\n",
+    "\n",
+    "double BuyInitialSL  = 0.0;       // store initial BUY SL\n",
+    "double SellInitialSL = 0.0;       // store initial SELL SL\n",
+    "\n",
+    "// =====================\n",
+    "// INIT\n",
+    "// =====================\n",
+    "int OnInit()\n",
+    "{\n",
+    "   TradeSymbol = _Symbol;\n",
+    "   if(!SymbolSelect(TradeSymbol, true))\n",
+    "      return INIT_FAILED;\n",
+    "\n",
+    "   EventSetTimer(TimerSec);\n",
+    "   return INIT_SUCCEEDED;\n",
+    "}\n",
+    "\n",
+    "// =====================\n",
+    "void OnDeinit(const int reason)\n",
+    "{\n",
+    "   EventKillTimer();\n",
+    "}\n",
+    "\n",
+    "// =====================\n",
+    "void OnTimer()\n",
+    "{\n",
+    "   HandleEntry();\n",
+    "   HandleReversal();\n",
+    "   HandleTrailing();\n",
+    "}\n",
+    "\n",
+    "// ============================================================\n",
+    "// ENTRY LOGIC\n",
+    "// ============================================================\n",
+    "void HandleEntry()\n",
+    "{\n",
+    "   // Only one position at a time\n",
+    "   if(PositionSelect(TradeSymbol))\n",
+    "      return;\n",
+    "\n",
+    "   // Get the last closed H3 candle\n",
+    "   datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);\n",
+    "   if(barTime == 0 || barTime == lastEntryBarTime)\n",
+    "      return;\n",
+    "\n",
+    "   lastEntryBarTime = barTime;\n",
+    "\n",
+    "   // Confirm this is the 00:00 H3 candle close\n",
+    "   MqlDateTime t;\n",
+    "   TimeToStruct(barTime, t);\n",
+    "   if(t.hour != 0)\n",
+    "      return;\n",
+    "\n",
+    "   double open  = iOpen(TradeSymbol, PERIOD_H3, 1);\n",
+    "   double close = iClose(TradeSymbol, PERIOD_H3, 1);\n",
+    "   double low   = iLow(TradeSymbol, PERIOD_H3, 1);\n",
+    "   double high  = iHigh(TradeSymbol, PERIOD_H3, 1);\n",
+    "\n",
+    "   trade.SetDeviationInPoints(20);\n",
+    "   trade.SetTypeFillingBySymbol(TradeSymbol);\n",
+    "\n",
+    "   // ---------------- BUY ----------------\n",
+    "   if(close > open)\n",
+    "   {\n",
+    "      double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);\n",
+    "      double sl    = low;\n",
+    "      double vol   = CalculateRiskVolume(entry, sl);\n",
+    "      if(vol > 0)\n",
+    "      {\n",
+    "         if(trade.Buy(vol, TradeSymbol, entry, sl, 0.0))\n",
+    "            BuyInitialSL = sl; // store initial SL\n",
+    "      }\n",
+    "   }\n",
+    "\n",
+    "   // ---------------- SELL ----------------\n",
+    "   if(close < open)\n",
+    "   {\n",
+    "      double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);\n",
+    "      double sl    = high;\n",
+    "      double vol   = CalculateRiskVolume(entry, sl);\n",
+    "      if(vol > 0)\n",
+    "      {\n",
+    "         if(trade.Sell(vol, TradeSymbol, entry, sl, 0.0))\n",
+    "            SellInitialSL = sl; // store initial SL\n",
+    "      }\n",
+    "   }\n",
+    "}\n",
+    "\n",
+    "// ============================================================\n",
+    "// REVERSAL LOGIC (APPLY SPREAD × 10 RULE)\n",
+    "// ============================================================\n",
+    "void HandleReversal()\n",
+    "{\n",
+    "   double bid = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);\n",
+    "   double ask = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);\n",
+    "\n",
+    "   // ---------- BUY Reversal ----------\n",
+    "   if(BuyInitialSL > 0 && !PositionSelect(TradeSymbol))\n",
+    "   {\n",
+    "      if(bid <= BuyInitialSL) // BUY SL hit\n",
+    "      {\n",
+    "         datetime firstBullishBarTime = FindFirstBullishH3From0();\n",
+    "         if(firstBullishBarTime > 0)\n",
+    "         {\n",
+    "            int shift = iBarShift(TradeSymbol, PERIOD_H3, firstBullishBarTime);\n",
+    "            double sl = iHigh(TradeSymbol, PERIOD_H3, shift);\n",
+    "\n",
+    "            // check spread x 10 rule\n",
+    "            double vol = CalculateRiskVolume(bid, sl);\n",
+    "            if(vol > 0)\n",
+    "            {\n",
+    "               if(trade.Sell(vol, TradeSymbol, bid, sl, 0.0))\n",
+    "                  BuyInitialSL = 0.0; // reset\n",
+    "            }\n",
+    "         }\n",
+    "      }\n",
+    "   }\n",
+    "\n",
+    "   // ---------- SELL Reversal ----------\n",
+    "   if(SellInitialSL > 0 && !PositionSelect(TradeSymbol))\n",
+    "   {\n",
+    "      if(ask >= SellInitialSL) // SELL SL hit\n",
+    "      {\n",
+    "         datetime firstBearishBarTime = FindFirstBearishH3From0();\n",
+    "         if(firstBearishBarTime > 0)\n",
+    "         {\n",
+    "            int shift = iBarShift(TradeSymbol, PERIOD_H3, firstBearishBarTime);\n",
+    "            double sl = iLow(TradeSymbol, PERIOD_H3, shift);\n",
+    "\n",
+    "            // check spread x 10 rule\n",
+    "            double vol = CalculateRiskVolume(ask, sl);\n",
+    "            if(vol > 0)\n",
+    "            {\n",
+    "               if(trade.Buy(vol, TradeSymbol, ask, sl, 0.0))\n",
+    "                  SellInitialSL = 0.0; // reset\n",
+    "            }\n",
+    "         }\n",
+    "      }\n",
+    "   }\n",
+    "}\n",
+    "\n",
+    "// ============================================================\n",
+    "// TRAILING LOGIC (STRICT RULES)\n",
+    "// ============================================================\n",
+    "void HandleTrailing()\n",
+    "{\n",
+    "   if(!PositionSelect(TradeSymbol))\n",
+    "      return;\n",
+    "\n",
+    "   // Trailing only after H3 candle closes\n",
+    "   datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);\n",
+    "   if(barTime == 0 || barTime == lastTrailBarTime)\n",
+    "      return;\n",
+    "\n",
+    "   lastTrailBarTime = barTime;\n",
+    "\n",
+    "   long   type      = PositionGetInteger(POSITION_TYPE);\n",
+    "   double currentSL = PositionGetDouble(POSITION_SL);\n",
+    "\n",
+    "   double open  = iOpen(TradeSymbol, PERIOD_H3, 1);\n",
+    "   double close = iClose(TradeSymbol, PERIOD_H3, 1);\n",
+    "   double low   = iLow(TradeSymbol, PERIOD_H3, 1);\n",
+    "   double high  = iHigh(TradeSymbol, PERIOD_H3, 1);\n",
+    "\n",
+    "   // ---------------- BUY ----------------\n",
+    "   if(type == POSITION_TYPE_BUY)\n",
+    "   {\n",
+    "      if(close > open && low > currentSL)\n",
+    "         trade.PositionModify(TradeSymbol, low, 0.0);\n",
+    "   }\n",
+    "\n",
+    "   // ---------------- SELL ----------------\n",
+    "   if(type == POSITION_TYPE_SELL)\n",
+    "   {\n",
+    "      if(close < open && high < currentSL)\n",
+    "         trade.PositionModify(TradeSymbol, high, 0.0);\n",
+    "   }\n",
+    "}\n",
+    "\n",
+    "// ============================================================\n",
+    "// RISK-BASED LOT CALCULATION (APPLY SPREAD × 10 RULE)\n",
+    "// ============================================================\n",
+    "double CalculateRiskVolume(double entry, double stop)\n",
+    "{\n",
+    "   double distance = MathAbs(entry - stop);\n",
+    "   if(distance <= 0)\n",
+    "      return 0;\n",
+    "\n",
+    "   // spread x 10 rule\n",
+    "   int spread_points = (int)SymbolInfoInteger(TradeSymbol, SYMBOL_SPREAD);\n",
+    "   double spread     = spread_points * SymbolInfoDouble(TradeSymbol, SYMBOL_POINT);\n",
+    "   if(distance < spread * 10)\n",
+    "      return 0;\n",
+    "\n",
+    "   double balance = AccountInfoDouble(ACCOUNT_BALANCE);\n",
+    "   double riskAmt = balance * (RiskPercent / 100.0);\n",
+    "\n",
+    "   double tickSize  = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_SIZE);\n",
+    "   double tickValue = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_VALUE);\n",
+    "\n",
+    "   double costPerLot = (distance / tickSize) * tickValue;\n",
+    "   if(costPerLot <= 0)\n",
+    "      return 0;\n",
+    "\n",
+    "   double volume = riskAmt / costPerLot;\n",
+    "\n",
+    "   double minLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MIN);\n",
+    "   double maxLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MAX);\n",
+    "   double stepLot = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_STEP);\n",
+    "\n",
+    "   volume = MathFloor(volume / stepLot) * stepLot;\n",
+    "   volume = MathMax(volume, minLot);\n",
+    "   volume = MathMin(volume, maxLot);\n",
+    "\n",
+    "   return volume;\n",
+    "}\n",
+    "\n",
+    "// ============================================================\n",
+    "// HELPER FUNCTIONS TO FIND FIRST H3 BULLISH/BEARISH BAR FROM 0:00\n",
+    "// ============================================================\n",
+    "datetime FindFirstBullishH3From0()\n",
+    "{\n",
+    "   MqlDateTime t;\n",
+    "   datetime today = iTime(TradeSymbol, PERIOD_D1, 0);\n",
+    "   TimeToStruct(today, t);\n",
+    "   datetime start = StructToTime(t);\n",
+    "\n",
+    "   for(int i=0; i<50; i++)\n",
+    "   {\n",
+    "      datetime bar = iTime(TradeSymbol, PERIOD_H3, i);\n",
+    "      if(bar < start) break;\n",
+    "      double open  = iOpen(TradeSymbol, PERIOD_H3, i);\n",
+    "      double close = iClose(TradeSymbol, PERIOD_H3, i);\n",
+    "      if(close > open) return bar;\n",
+    "   }\n",
+    "   return 0;\n",
+    "}\n",
+    "\n",
+    "datetime FindFirstBearishH3From0()\n",
+    "{\n",
+    "   MqlDateTime t;\n",
+    "   datetime today = iTime(TradeSymbol, PERIOD_D1, 0);\n",
+    "   TimeToStruct(today, t);\n",
+    "   datetime start = StructToTime(t);\n",
+    "\n",
+    "   for(int i=0; i<50; i++)\n",
+    "   {\n",
+    "      datetime bar = iTime(TradeSymbol, PERIOD_H3, i);\n",
+    "      if(bar < start) break;\n",
+    "      double open  = iOpen(TradeSymbol, PERIOD_H3, i);\n",
+    "      double close = iClose(TradeSymbol, PERIOD_H3, i);\n",
+    "      if(close < open) return bar;\n",
+    "   }\n",
+    "   return 0;\n",
+    "}\n",
+    "}"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "33da4df1",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

MQL5 Folder/0_00-3_00 Range/Refined version.ipynb ADDED Viewed

The diff for this file is too large to render. See raw diff

MQL5 Folder/0_00-3_00 Range/attempts.ipynb ADDED Viewed

The diff for this file is too large to render. See raw diff

MQL5 Folder/0_00-3_00 Range/scratch.mql ADDED Viewed

	@@ -0,0 +1,237 @@

+#property strict
+#include <Trade/Trade.mqh>
+CTrade trade;
+// =====================
+// INPUTS
+// =====================
+input double RiskPercent = 1.0;
+input int    TimerSec    = 5;
+// =====================
+// SYMBOLS
+// =====================
+string TradeSymbols[] =
+{
+   "NZDUSDc",
+   "USDJPYc",
+   "XAGUSDc",
+   "XAUUSDc"
+};
+#define SYM_COUNT 4
+// =====================
+// PER-SYMBOL STATE
+// =====================
+datetime lastEntryBar[SYM_COUNT];
+datetime lastTrailBar[SYM_COUNT];
+double   lastBuySL[SYM_COUNT];
+double   lastSellSL[SYM_COUNT];
+bool     buyStoppedLoss[SYM_COUNT];
+bool     sellStoppedLoss[SYM_COUNT];
+// =====================
+// INIT
+// =====================
+int OnInit()
+{
+   for(int i=0;i<SYM_COUNT;i++)
+   {
+      SymbolSelect(TradeSymbols[i],true);
+      lastEntryBar[i]=0;
+      lastTrailBar[i]=0;
+      lastBuySL[i]=0;
+      lastSellSL[i]=0;
+      buyStoppedLoss[i]=false;
+      sellStoppedLoss[i]=false;
+   }
+   EventSetTimer(TimerSec);
+   return INIT_SUCCEEDED;
+}
+void OnDeinit(const int reason)
+{
+   EventKillTimer();
+}
+void OnTimer()
+{
+   for(int i=0;i<SYM_COUNT;i++)
+   {
+      HandleEntry(i);
+      HandleReversal(i);
+      HandleTrailing(i);
+   }
+}
+// ============================================================
+// ORIGINAL ENTRY (ONLY 0:00–3:00 H3 BAR)
+// ============================================================
+void HandleEntry(int i)
+{
+   string s = TradeSymbols[i];
+   if(PositionSelect(s))
+      return;
+   datetime barTime = iTime(s,PERIOD_H3,1);
+   if(barTime==0 || barTime==lastEntryBar[i])
+      return;
+   lastEntryBar[i]=barTime;
+   MqlDateTime t;
+   TimeToStruct(barTime,t);
+   if(t.hour!=0) return;
+   double o=iOpen(s,PERIOD_H3,1);
+   double c=iClose(s,PERIOD_H3,1);
+   double l=iLow(s,PERIOD_H3,1);
+   double h=iHigh(s,PERIOD_H3,1);
+   trade.SetDeviationInPoints(20);
+   trade.SetTypeFillingBySymbol(s);
+   if(c>o)
+   {
+      double entry=SymbolInfoDouble(s,SYMBOL_ASK);
+      double sl=l;
+      double vol=CalcRiskVol(s,entry,sl);
+      if(vol>0 && trade.Buy(vol,s,entry,sl,0))
+      {
+         lastBuySL[i]=sl;
+         buyStoppedLoss[i]=false;
+      }
+   }
+   else if(c<o)
+   {
+      double entry=SymbolInfoDouble(s,SYMBOL_BID);
+      double sl=h;
+      double vol=CalcRiskVol(s,entry,sl);
+      if(vol>0 && trade.Sell(vol,s,entry,sl,0))
+      {
+         lastSellSL[i]=sl;
+         sellStoppedLoss[i]=false;
+      }
+   }
+}
+// ============================================================
+// REVERSAL ENTRY (ONLY NEGATIVE STOP OUT)
+// ============================================================
+void HandleReversal(int i)
+{
+   string s=TradeSymbols[i];
+   if(PositionSelect(s))
+      return;
+   double bid=SymbolInfoDouble(s,SYMBOL_BID);
+   double ask=SymbolInfoDouble(s,SYMBOL_ASK);
+   // BUY STOPPED → SELL
+   if(lastBuySL[i]>0 && !buyStoppedLoss[i])
+   {
+      if(bid<=lastBuySL[i])
+      {
+         buyStoppedLoss[i]=true;
+         double entry=bid;
+         double sl=iHigh(s,PERIOD_H3,1);
+         double vol=CalcRiskVol(s,entry,sl);
+         if(vol>0)
+            trade.Sell(vol,s,entry,sl,0);
+      }
+   }
+   // SELL STOPPED → BUY
+   if(lastSellSL[i]>0 && !sellStoppedLoss[i])
+   {
+      if(ask>=lastSellSL[i])
+      {
+         sellStoppedLoss[i]=true;
+         double entry=ask;
+         double sl=iLow(s,PERIOD_H3,1);
+         double vol=CalcRiskVol(s,entry,sl);
+         if(vol>0)
+            trade.Buy(vol,s,entry,sl,0);
+      }
+   }
+}
+// ============================================================
+// TRAILING (H3 CLOSE ONLY, SAME-COLOR ONLY, INFINITE)
+// ============================================================
+void HandleTrailing(int i)
+{
+   string s=TradeSymbols[i];
+   if(!PositionSelect(s))
+      return;
+   datetime barTime=iTime(s,PERIOD_H3,1);
+   if(barTime==0 || barTime==lastTrailBar[i])
+      return;
+   lastTrailBar[i]=barTime;
+   long type=PositionGetInteger(POSITION_TYPE);
+   double curSL=PositionGetDouble(POSITION_SL);
+   double o=iOpen(s,PERIOD_H3,1);
+   double c=iClose(s,PERIOD_H3,1);
+   double l=iLow(s,PERIOD_H3,1);
+   double h=iHigh(s,PERIOD_H3,1);
+   if(type==POSITION_TYPE_BUY)
+   {
+      if(c>o && l>curSL)
+         trade.PositionModify(s,l,0);
+   }
+   else if(type==POSITION_TYPE_SELL)
+   {
+      if(c<o && h<curSL)
+         trade.PositionModify(s,h,0);
+   }
+}
+// ============================================================
+// RISK & SPREAD ×10 FILTER
+// ============================================================
+double CalcRiskVol(string s,double entry,double sl)
+{
+   double dist=MathAbs(entry-sl);
+   if(dist<=0) return 0;
+   double spread=
+      SymbolInfoInteger(s,SYMBOL_SPREAD) *
+      SymbolInfoDouble(s,SYMBOL_POINT);
+   if(dist < spread*10) return 0;
+   double risk=AccountInfoDouble(ACCOUNT_BALANCE)*RiskPercent/100.0;
+   double tickSize=SymbolInfoDouble(s,SYMBOL_TRADE_TICK_SIZE);
+   double tickVal =SymbolInfoDouble(s,SYMBOL_TRADE_TICK_VALUE);
+   double cost=(dist/tickSize)*tickVal;
+   if(cost<=0) return 0;
+   double vol=risk/cost;
+   double minLot=SymbolInfoDouble(s,SYMBOL_VOLUME_MIN);
+   double maxLot=SymbolInfoDouble(s,SYMBOL_VOLUME_MAX);
+   double step  =SymbolInfoDouble(s,SYMBOL_VOLUME_STEP);
+   vol=MathFloor(vol/step)*step;
+   vol=MathMax(vol,minLot);
+   vol=MathMin(vol,maxLot);
+   return vol;
+}
+{gg as}

MQL5 Folder/89RS MT5 version/89RS MT5 version.ipynb ADDED Viewed

	@@ -0,0 +1,174 @@

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0d3db06f",
+   "metadata": {},
+   "source": [
+    "analyzed, extract, and exammine the lines-of-code and create a corrected version of the code addressing the red error from \"Description, File, Line, Column\"-formatted-toolbox-terminal-in-mt5-platform statements; it is saying:{}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1fc41fb6",
+   "metadata": {},
+   "source": [
+    "make everything ideal in live environment, use your knowledge to enchance the code"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bb937c2",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ec950491",
+   "metadata": {},
+   "source": [
+    "{Design the code ideal for live executions and live environment, robust, with no errors} {Do not make unnecessary inputs }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7738ccfb",
+   "metadata": {},
+   "source": [
+    "make an EA using MT5 MQL5, Use MQL5, do not ever mix MT4-style functions in MT5, do not ever use the MT4-style helper. Use onTimer() logic is ideal for a live environment.  \n",
+    "\n",
+    "Wait for H1-12pm-candle to close. Then after, locate the highest high and lowest low of that range or candle. Place buystop at the high, and the stoploss is at the middle of the range. Place sellstop at the low, and the stoploss is at the middle of the range. Risking 1% for each trade, accounting for the individual stop-loss distance. The take profit is 2R-multiple. These stoporders (both buystop and sellstop) are only valid within its coresponding day.{Design the code ideal for live executions and live environment, robust, with no errors} {Do not make unnecessary inputs }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ab6b4aa",
+   "metadata": {},
+   "source": [
+    "//+------------------------------------------------------------------+\n",
+    "//|                                                   BreakoutEA.mq5 |\n",
+    "//|                        Robust MT5 EA using OnTimer               |\n",
+    "//+------------------------------------------------------------------+\n",
+    "#include <Trade/Trade.mqh>\n",
+    "CTrade trade;\n",
+    "\n",
+    "//--- Global variables\n",
+    "datetime lastProcessed = 0;\n",
+    "\n",
+    "//+------------------------------------------------------------------+\n",
+    "//| Expert initialization function                                   |\n",
+    "//+------------------------------------------------------------------+\n",
+    "int OnInit()\n",
+    "{\n",
+    "   // Set timer to check every 60 seconds\n",
+    "   EventSetTimer(60);\n",
+    "   return(INIT_SUCCEEDED);\n",
+    "}\n",
+    "\n",
+    "//+------------------------------------------------------------------+\n",
+    "//| Expert deinitialization function                                 |\n",
+    "//+------------------------------------------------------------------+\n",
+    "void OnDeinit(const int reason)\n",
+    "{\n",
+    "   EventKillTimer();\n",
+    "}\n",
+    "\n",
+    "//+------------------------------------------------------------------+\n",
+    "//| Timer function for live environment                              |\n",
+    "//+------------------------------------------------------------------+\n",
+    "void OnTimer()\n",
+    "{\n",
+    "   datetime currentTime = TimeCurrent();\n",
+    "   MqlDateTime tm;\n",
+    "   TimeToStruct(currentTime, tm);\n",
+    "\n",
+    "   // Only trigger after 12:00 H1 candle close\n",
+    "   if(tm.hour == 12 && lastProcessed != iTime(_Symbol, PERIOD_H1, 1))\n",
+    "   {\n",
+    "      lastProcessed = iTime(_Symbol, PERIOD_H1, 1); // Record last processed candle\n",
+    "      ProcessBreakout();\n",
+    "   }\n",
+    "}\n",
+    "\n",
+    "//+------------------------------------------------------------------+\n",
+    "//| Main processing function                                         |\n",
+    "//+------------------------------------------------------------------+\n",
+    "void ProcessBreakout()\n",
+    "{\n",
+    "   // Get last closed H1 candle\n",
+    "   double h = iHigh(_Symbol, PERIOD_H1, 1);\n",
+    "   double l = iLow(_Symbol, PERIOD_H1, 1);\n",
+    "\n",
+    "   double rangeMid = (h + l) / 2.0;\n",
+    "\n",
+    "   // Calculate distance for SL and TP in price\n",
+    "   double slDistance = MathAbs(h - rangeMid); // Same for both sides\n",
+    "   double tpDistance = slDistance * 2;        // 2R take profit\n",
+    "\n",
+    "   // Calculate lot size to risk 1% of account\n",
+    "   double riskPercent = 1.0;\n",
+    "   double lot = CalculateLotSize(slDistance, riskPercent);\n",
+    "\n",
+    "   if(lot <= 0)\n",
+    "      return; // If lot is too small, skip\n",
+    "\n",
+    "   // Place BuyStop above high\n",
+    "   double buyPrice = h;\n",
+    "   double buySL    = rangeMid;\n",
+    "   double buyTP    = buyPrice + tpDistance;\n",
+    "\n",
+    "   trade.BuyStop(lot, buyPrice, _Symbol, buySL, buyTP, ORDER_TIME_DAY, 0, \"H1 12PM BuyStop\");\n",
+    "\n",
+    "   // Place SellStop below low\n",
+    "   double sellPrice = l;\n",
+    "   double sellSL    = rangeMid;\n",
+    "   double sellTP    = sellPrice - tpDistance;\n",
+    "\n",
+    "   trade.SellStop(lot, sellPrice, _Symbol, sellSL, sellTP, ORDER_TIME_DAY, 0, \"H1 12PM SellStop\");\n",
+    "}\n",
+    "\n",
+    "//+------------------------------------------------------------------+\n",
+    "//| Calculate lot size based on risk %                                |\n",
+    "//+------------------------------------------------------------------+\n",
+    "double CalculateLotSize(double slDistance, double riskPercent)\n",
+    "{\n",
+    "   if(slDistance <= 0)\n",
+    "      return 0;\n",
+    "\n",
+    "   double tickValue    = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);\n",
+    "   double tickSize     = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);\n",
+    "   double accountRisk  = AccountInfoDouble(ACCOUNT_BALANCE) * riskPercent / 100.0;\n",
+    "\n",
+    "   // Lot calculation: lot = risk / (SL in price * tick value)\n",
+    "   double lot = accountRisk / (slDistance * tickValue / tickSize);\n",
+    "\n",
+    "   // Round lot to symbol precision\n",
+    "   double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);\n",
+    "   lot = MathFloor(lot/step) * step;\n",
+    "\n",
+    "   // Ensure minimum volume\n",
+    "   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);\n",
+    "   if(lot < minLot)\n",
+    "      lot = 0;\n",
+    "\n",
+    "   return lot;\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b583fa3",
+   "metadata": {},
+   "source": [
+    "note: its truly worse"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

MQL5 Folder/ADX Filter/First candle highlighter with adx.ipynb ADDED Viewed

	@@ -0,0 +1,178 @@

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7a1ca979",
+   "metadata": {},
+   "source": [
+    "Make an MT5 indicator that highlights the corresponding candle red if bearish and blue if bullish on the very first candlestick formed at 0:00. Use MQL5, do not ever mix MT4-style functions in MT5, do not ever use the MT4-style helper. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "036e1127",
+   "metadata": {},
+   "source": [
+    "#property indicator_chart_window\n",
+    "#property indicator_buffers 5\n",
+    "#property indicator_plots   1\n",
+    "\n",
+    "#property indicator_type1   DRAW_COLOR_CANDLES\n",
+    "#property indicator_color1  clrBlue, clrRed\n",
+    "#property indicator_label1  \"First Daily Candle\"\n",
+    "\n",
+    "//--- buffers\n",
+    "double OpenBuf[];\n",
+    "double HighBuf[];\n",
+    "double LowBuf[];\n",
+    "double CloseBuf[];\n",
+    "double ColorBuf[];\n",
+    "\n",
+    "//--- colors index\n",
+    "#define BULL 0\n",
+    "#define BEAR 1\n",
+    "\n",
+    "int OnInit()\n",
+    "{\n",
+    "   SetIndexBuffer(0, OpenBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(1, HighBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(2, LowBuf,   INDICATOR_DATA);\n",
+    "   SetIndexBuffer(3, CloseBuf, INDICATOR_DATA);\n",
+    "   SetIndexBuffer(4, ColorBuf, INDICATOR_COLOR_INDEX);\n",
+    "\n",
+    "   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, 1);\n",
+    "\n",
+    "   //--- chart appearance\n",
+    "   ChartSetInteger(0, CHART_SHOW_GRID, false);      // remove grid\n",
+    "   ChartSetInteger(0, CHART_SHOW_BID_LINE, true);   // show bid line\n",
+    "   ChartSetInteger(0, CHART_SHOW_ASK_LINE, true);   // show ask line\n",
+    "\n",
+    "   return(INIT_SUCCEEDED);\n",
+    "}\n",
+    "\n",
+    "int OnCalculate(\n",
+    "   const int rates_total,\n",
+    "   const int prev_calcula_\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f3293169",
+   "metadata": {},
+   "source": [
+    "#property indicator_chart_window\n",
+    "#property indicator_buffers 10\n",
+    "#property indicator_plots   2\n",
+    "\n",
+    "// First plot: custom candle\n",
+    "#property indicator_type1   DRAW_COLOR_CANDLES\n",
+    "#property indicator_color1  clrBlue, clrRed\n",
+    "#property indicator_label1  \"First Daily Candle\"\n",
+    "\n",
+    "// Second plot: ADX\n",
+    "#property indicator_type2   DRAW_LINE\n",
+    "#property indicator_color2  clrOrange\n",
+    "#property indicator_label2  \"ADX(14)\"\n",
+    "#property indicator_separate_window true\n",
+    "\n",
+    "//--- buffers for custom candle\n",
+    "double OpenBuf[];\n",
+    "double HighBuf[];\n",
+    "double LowBuf[];\n",
+    "double CloseBuf[];\n",
+    "double ColorBuf[];\n",
+    "\n",
+    "//--- buffer for ADX\n",
+    "double ADXBuf[];\n",
+    "\n",
+    "//--- colors index\n",
+    "#define BULL 0\n",
+    "#define BEAR 1\n",
+    "\n",
+    "int OnInit()\n",
+    "{\n",
+    "   // Custom candle buffers\n",
+    "   SetIndexBuffer(0, OpenBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(1, HighBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(2, LowBuf,   INDICATOR_DATA);\n",
+    "   SetIndexBuffer(3, CloseBuf, INDICATOR_DATA);\n",
+    "   SetIndexBuffer(4, ColorBuf, INDICATOR_COLOR_INDEX);\n",
+    "\n",
+    "   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, 1);\n",
+    "\n",
+    "   // ADX buffer\n",
+    "   SetIndexBuffer(5, ADXBuf, INDICATOR_DATA);\n",
+    "   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, 14);  // ADX period\n",
+    "\n",
+    "   //--- chart appearance for main chart\n",
+    "   ChartSetInteger(0, CHART_SHOW_GRID, false);      // remove grid\n",
+    "   ChartSetInteger(0, CHART_SHOW_BID_LINE, true);   // show bid line\n",
+    "   ChartSetInteger(0, CHART_SHOW_ASK_LINE, true);   // show ask line\n",
+    "\n",
+    "   return(INIT_SUCCEEDED);\n",
+    "}\n",
+    "\n",
+    "int OnCalculate(\n",
+    "   const int rates_total,\n",
+    "   const int prev_calculated,\n",
+    "   const datetime &time[],\n",
+    "   const double &open[],\n",
+    "   const double &high[],\n",
+    "   const double &low[],\n",
+    "   const double &close[],\n",
+    "   const long &tick_volume[],\n",
+    "   const long &volume[],\n",
+    "   const int &spread[]\n",
+    ")\n",
+    "{\n",
+    "   if(rates_total < 15) // minimum for ADX(14)\n",
+    "      return 0;\n",
+    "\n",
+    "   int start = prev_calculated > 1 ? prev_calculated - 1 : 1;\n",
+    "\n",
+    "   for(int i = start; i < rates_total; i++)\n",
+    "   {\n",
+    "      OpenBuf[i]  = EMPTY_VALUE;\n",
+    "      HighBuf[i]  = EMPTY_VALUE;\n",
+    "      LowBuf[i]   = EMPTY_VALUE;\n",
+    "      CloseBuf[i] = EMPTY_VALUE;\n",
+    "\n",
+    "      datetime cur = time[i];\n",
+    "      datetime prev = time[i - 1];\n",
+    "\n",
+    "      MqlDateTime tcur, tprev;\n",
+    "      TimeToStruct(cur, tcur);\n",
+    "      TimeToStruct(prev, tprev);\n",
+    "\n",
+    "      bool is_first_daily_candle =\n",
+    "         (tcur.hour == 0 && tcur.min == 0) ||\n",
+    "         (tcur.day != tprev.day);\n",
+    "\n",
+    "      if(is_first_daily_candle)\n",
+    "      {\n",
+    "         OpenBuf[i]  = open[i];\n",
+    "         HighBuf[i]  = high[i];\n",
+    "         LowBuf[i]   = low[i];\n",
+    "         CloseBuf[i] = close[i];\n",
+    "\n",
+    "         ColorBuf[i] = close[i] >= open[i] ? BULL : BEAR;\n",
+    "      }\n",
+    "   }\n",
+    "\n",
+    "   //--- calculate ADX(14) on close price\n",
+    "   for(int i = start; i < rates_total; i++)\n",
+    "      ADXBuf[i] = iADX(NULL, 0, 14, PRICE_CLOSE, MODE_MAIN, i);\n",
+    "\n",
+    "   return(rates_total);\n",
+    "}\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

MQL5 Folder/ADX Filter/template with 1st candle highlighter.mq5 ADDED Viewed

	@@ -0,0 +1,86 @@

+#property indicator_chart_window
+#property indicator_buffers 5
+#property indicator_plots   1
+#property indicator_type1   DRAW_COLOR_CANDLES
+#property indicator_color1  clrBlue, clrRed
+#property indicator_label1  "First Daily Candle"
+//--- buffers
+double OpenBuf[];
+double HighBuf[];
+double LowBuf[];
+double CloseBuf[];
+double ColorBuf[];
+//--- colors index
+#define BULL 0
+#define BEAR 1
+int OnInit()
+{
+   SetIndexBuffer(0, OpenBuf,  INDICATOR_DATA);
+   SetIndexBuffer(1, HighBuf,  INDICATOR_DATA);
+   SetIndexBuffer(2, LowBuf,   INDICATOR_DATA);
+   SetIndexBuffer(3, CloseBuf, INDICATOR_DATA);
+   SetIndexBuffer(4, ColorBuf, INDICATOR_COLOR_INDEX);
+   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, 1);
+   //--- chart appearance
+   ChartSetInteger(0, CHART_SHOW_GRID, false);      // remove grid
+   ChartSetInteger(0, CHART_SHOW_BID_LINE, true);   // show bid line
+   ChartSetInteger(0, CHART_SHOW_ASK_LINE, true);   // show ask line
+   return(INIT_SUCCEEDED);
+}
+int OnCalculate(
+   const int rates_total,
+   const int prev_calculated,
+   const datetime &time[],
+   const double &open[],
+   const double &high[],
+   const double &low[],
+   const double &close[],
+   const long &tick_volume[],
+   const long &volume[],
+   const int &spread[]
+)
+{
+   if(rates_total < 2)
+      return 0;
+   int start = prev_calculated > 1 ? prev_calculated - 1 : 1;
+   for(int i = start; i < rates_total; i++)
+   {
+      OpenBuf[i]  = EMPTY_VALUE;
+      HighBuf[i]  = EMPTY_VALUE;
+      LowBuf[i]   = EMPTY_VALUE;
+      CloseBuf[i] = EMPTY_VALUE;
+      datetime cur = time[i];
+      datetime prev = time[i - 1];
+      MqlDateTime tcur, tprev;
+      TimeToStruct(cur, tcur);
+      TimeToStruct(prev, tprev);
+      bool is_first_daily_candle =
+         (tcur.hour == 0 && tcur.min == 0) ||
+         (tcur.day != tprev.day);
+      if(is_first_daily_candle)
+      {
+         OpenBuf[i]  = open[i];
+         HighBuf[i]  = high[i];
+         LowBuf[i]   = low[i];
+         CloseBuf[i] = close[i];
+         ColorBuf[i] = close[i] >= open[i] ? BULL : BEAR;
+      }
+   }
+   return(rates_total);
+}

MQL5 Folder/Dec25_Volume Profile based breakout momentuim strategy/codeclaude.c++ ADDED Viewed

	@@ -0,0 +1,445 @@

+//+------------------------------------------------------------------+
+//|                                          VolumeProfileTradingEA.mq5 |
+//|                                                                  |
+//+------------------------------------------------------------------+
+#property copyright "Volume Profile Trading EA"
+#property version   "1.00"
+#property strict
+input double   RiskPercent = 1.0;              // Risk per trade (%)
+input int      SpreadMultiplier = 10;          // Minimum SL = Spread x This
+input double   ValueAreaPercent = 0.70;        // Value Area (70%)
+input double   PriceStepForVP = 0.10;          // Price step for volume profile
+// Global variables
+datetime g_lastTradeHour = 0;                  // Track last trade hour
+double g_cumVolume[];                          // Cumulative volume by price
+double g_priceLevels[];                        // Price levels array
+int g_volumeSize = 0;                          // Size of volume arrays
+struct SessionData {
+   datetime startTime;
+   datetime currentTime;
+   double poc;
+   double vah;
+   double val;
+   bool isValid;
+};
+SessionData g_currentSession;
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit() {
+   Print("Volume Profile Trading EA initialized");
+   // Initialize session
+   g_currentSession.isValid = false;
+   g_lastTradeHour = 0;
+   // Reserve array space
+   ArrayResize(g_cumVolume, 10000);
+   ArrayResize(g_priceLevels, 10000);
+   ArrayFill(g_cumVolume, 0, 10000, 0.0);
+   g_volumeSize = 0;
+   return(INIT_SUCCEEDED);
+}
+//+------------------------------------------------------------------+
+//| Expert deinitialization function                                 |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason) {
+   Print("EA deinitialized: ", reason);
+}
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick() {
+   datetime currentTime = TimeCurrent();
+   MqlDateTime dt;
+   TimeToStruct(currentTime, dt);
+   // Detect new trading session (gap detection)
+   if(IsNewTradingSession(currentTime)) {
+      ResetSession(currentTime);
+   }
+   // Update developing POC/VAH/VAL with each new bar
+   if(IsNewBar()) {
+      UpdateVolumeProfile();
+      // Check trading conditions on bar close
+      CheckTradingSignals();
+   }
+}
+//+------------------------------------------------------------------+
+//| Detect new trading session based on time gaps                    |
+//+------------------------------------------------------------------+
+bool IsNewTradingSession(datetime currentTime) {
+   static datetime lastBarTime = 0;
+   if(lastBarTime == 0) {
+      lastBarTime = currentTime;
+      return true;
+   }
+   // Detect gap larger than normal bar interval
+   int barInterval = PeriodSeconds();
+   long timeDiff = currentTime - lastBarTime;
+   lastBarTime = currentTime;
+   // If gap is more than 2x normal interval, it's a new session
+   if(timeDiff > barInterval * 2) {
+      return true;
+   }
+   return false;
+}
+//+------------------------------------------------------------------+
+//| Reset session data                                               |
+//+------------------------------------------------------------------+
+void ResetSession(datetime startTime) {
+   g_currentSession.startTime = startTime;
+   g_currentSession.currentTime = startTime;
+   g_currentSession.isValid = false;
+   // Clear cumulative volume
+   ArrayFill(g_cumVolume, 0, ArraySize(g_cumVolume), 0.0);
+   g_volumeSize = 0;
+   Print("New trading session started at: ", TimeToString(startTime));
+}
+//+------------------------------------------------------------------+
+//| Check if new bar formed                                          |
+//+------------------------------------------------------------------+
+bool IsNewBar() {
+   static datetime lastBarTime = 0;
+   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
+   if(currentBarTime != lastBarTime) {
+      lastBarTime = currentBarTime;
+      return true;
+   }
+   return false;
+}
+//+------------------------------------------------------------------+
+//| Update developing volume profile                                 |
+//+------------------------------------------------------------------+
+void UpdateVolumeProfile() {
+   int bar = 0;
+   double high = iHigh(_Symbol, PERIOD_CURRENT, bar);
+   double low = iLow(_Symbol, PERIOD_CURRENT, bar);
+   long volume = iVolume(_Symbol, PERIOD_CURRENT, bar);
+   if(volume <= 0) return;
+   // Distribute volume across price levels
+   double priceStep = PriceStepForVP;
+   int numLevels = (int)MathCeil((high - low) / priceStep) + 1;
+   if(numLevels <= 0) numLevels = 1;
+   double volPerLevel = (double)volume / numLevels;
+   for(double p = low; p <= high + 0.001; p += priceStep) {
+      double priceLevel = NormalizeDouble(p, 2);
+      AddVolumeToLevel(priceLevel, volPerLevel);
+   }
+   // Calculate POC, VAH, VAL
+   CalculateVolumeProfileLevels();
+}
+//+------------------------------------------------------------------+
+//| Add volume to specific price level                               |
+//+------------------------------------------------------------------+
+void AddVolumeToLevel(double price, double volume) {
+   // Find if price level exists
+   int index = -1;
+   for(int i = 0; i < g_volumeSize; i++) {
+      if(MathAbs(g_priceLevels[i] - price) < 0.001) {
+         index = i;
+         break;
+      }
+   }
+   if(index >= 0) {
+      g_cumVolume[index] += volume;
+   } else {
+      // Add new level
+      if(g_volumeSize < ArraySize(g_cumVolume)) {
+         g_priceLevels[g_volumeSize] = price;
+         g_cumVolume[g_volumeSize] = volume;
+         g_volumeSize++;
+      }
+   }
+}
+//+------------------------------------------------------------------+
+//| Calculate POC, VAH, VAL from cumulative volume                   |
+//+------------------------------------------------------------------+
+void CalculateVolumeProfileLevels() {
+   if(g_volumeSize == 0) return;
+   // Find POC (Point of Control - highest volume)
+   int pocIndex = 0;
+   double maxVolume = g_cumVolume[0];
+   for(int i = 1; i < g_volumeSize; i++) {
+      if(g_cumVolume[i] > maxVolume) {
+         maxVolume = g_cumVolume[i];
+         pocIndex = i;
+      }
+   }
+   g_currentSession.poc = g_priceLevels[pocIndex];
+   // Calculate total volume
+   double totalVolume = 0;
+   for(int i = 0; i < g_volumeSize; i++) {
+      totalVolume += g_cumVolume[i];
+   }
+   // Calculate Value Area (70% of volume around POC)
+   double targetVolume = totalVolume * ValueAreaPercent;
+   double cumVol = g_cumVolume[pocIndex];
+   int loIndex = pocIndex;
+   int hiIndex = pocIndex;
+   while(cumVol < targetVolume && (loIndex > 0 || hiIndex < g_volumeSize - 1)) {
+      bool expandLow = false;
+      bool expandHigh = false;
+      if(loIndex > 0) expandLow = true;
+      if(hiIndex < g_volumeSize - 1) expandHigh = true;
+      if(expandLow && expandHigh) {
+         // Expand to side with more volume
+         if(g_cumVolume[loIndex - 1] > g_cumVolume[hiIndex + 1]) {
+            loIndex--;
+            cumVol += g_cumVolume[loIndex];
+         } else {
+            hiIndex++;
+            cumVol += g_cumVolume[hiIndex];
+         }
+      } else if(expandLow) {
+         loIndex--;
+         cumVol += g_cumVolume[loIndex];
+      } else if(expandHigh) {
+         hiIndex++;
+         cumVol += g_cumVolume[hiIndex];
+      }
+   }
+   g_currentSession.vah = g_priceLevels[hiIndex];
+   g_currentSession.val = g_priceLevels[loIndex];
+   g_currentSession.isValid = true;
+   g_currentSession.currentTime = TimeCurrent();
+}
+//+------------------------------------------------------------------+
+//| Check for trading signals                                        |
+//+------------------------------------------------------------------+
+void CheckTradingSignals() {
+   if(!g_currentSession.isValid) return;
+   // Only one trade per whole trading hour
+   datetime currentTime = TimeCurrent();
+   MqlDateTime dt;
+   TimeToStruct(currentTime, dt);
+   datetime currentHour = StringToTime(StringFormat("%04d.%02d.%02d %02d:00",
+                                       dt.year, dt.mon, dt.day, dt.hour));
+   if(g_lastTradeHour == currentHour) {
+      return; // Already traded this hour
+   }
+   // Check if we already have an open position
+   if(PositionSelect(_Symbol)) {
+      return; // Position already open
+   }
+   // Get latest closed candle
+   int bar = 1;
+   double close = iClose(_Symbol, PERIOD_CURRENT, bar);
+   double high = iHigh(_Symbol, PERIOD_CURRENT, bar);
+   double low = iLow(_Symbol, PERIOD_CURRENT, bar);
+   double open = iOpen(_Symbol, PERIOD_CURRENT, bar);
+   // Determine body boundaries
+   double bodyHigh = MathMax(open, close);
+   double bodyLow = MathMin(open, close);
+   // Check if POC is between candle body (for exit check if position exists)
+   // This will be handled in position management
+   // Trading logic
+   bool buySignal = false;
+   bool sellSignal = false;
+   double sl = 0;
+   // Buy signal: Close above VAH
+   if(close > g_currentSession.vah) {
+      buySignal = true;
+      sl = low;
+   }
+   // Sell signal: Close below VAL
+   if(close < g_currentSession.val) {
+      sellSignal = true;
+      sl = high;
+   }
+   // Execute trades
+   if(buySignal) {
+      double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
+      double spread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) * SymbolInfoDouble(_Symbol, SYMBOL_POINT);
+      double slDistance = currentPrice - sl;
+      // Check minimum SL distance
+      if(slDistance >= spread * SpreadMultiplier) {
+         OpenBuyTrade(currentPrice, sl);
+         g_lastTradeHour = currentHour;
+      }
+   } else if(sellSignal) {
+      double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID);
+      double spread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) * SymbolInfoDouble(_Symbol, SYMBOL_POINT);
+      double slDistance = sl - currentPrice;
+      // Check minimum SL distance
+      if(slDistance >= spread * SpreadMultiplier) {
+         OpenSellTrade(currentPrice, sl);
+         g_lastTradeHour = currentHour;
+      }
+   }
+   // Check exit conditions for existing positions
+   CheckExitConditions(bodyLow, bodyHigh);
+}
+//+------------------------------------------------------------------+
+//| Open Buy Trade with 1% risk                                      |
+//+------------------------------------------------------------------+
+void OpenBuyTrade(double price, double sl) {
+   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+   double riskAmount = balance * (RiskPercent / 100.0);
+   double slDistance = price - sl;
+   if(slDistance <= 0) return;
+   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
+   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
+   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
+   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
+   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
+   double lotSize = (riskAmount * tickSize) / (slDistance * tickValue);
+   lotSize = MathFloor(lotSize / lotStep) * lotStep;
+   lotSize = MathMax(lotSize, minLot);
+   lotSize = MathMin(lotSize, maxLot);
+   MqlTradeRequest request = {};
+   MqlTradeResult result = {};
+   request.action = TRADE_ACTION_DEAL;
+   request.symbol = _Symbol;
+   request.volume = lotSize;
+   request.type = ORDER_TYPE_BUY;
+   request.price = price;
+   request.sl = sl;
+   request.tp = 0; // Dynamic TP based on POC
+   request.deviation = 10;
+   request.magic = 123456;
+   request.comment = "VP Buy";
+   if(OrderSend(request, result)) {
+      Print("Buy order opened: ", result.order, " at ", price);
+   } else {
+      Print("Buy order failed: ", GetLastError());
+   }
+}
+//+------------------------------------------------------------------+
+//| Open Sell Trade with 1% risk                                     |
+//+------------------------------------------------------------------+
+void OpenSellTrade(double price, double sl) {
+   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+   double riskAmount = balance * (RiskPercent / 100.0);
+   double slDistance = sl - price;
+   if(slDistance <= 0) return;
+   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
+   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
+   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
+   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
+   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
+   double lotSize = (riskAmount * tickSize) / (slDistance * tickValue);
+   lotSize = MathFloor(lotSize / lotStep) * lotStep;
+   lotSize = MathMax(lotSize, minLot);
+   lotSize = MathMin(lotSize, maxLot);
+   MqlTradeRequest request = {};
+   MqlTradeResult result = {};
+   request.action = TRADE_ACTION_DEAL;
+   request.symbol = _Symbol;
+   request.volume = lotSize;
+   request.type = ORDER_TYPE_SELL;
+   request.price = price;
+   request.sl = sl;
+   request.tp = 0; // Dynamic TP based on POC
+   request.deviation = 10;
+   request.magic = 123456;
+   request.comment = "VP Sell";
+   if(OrderSend(request, result)) {
+      Print("Sell order opened: ", result.order, " at ", price);
+   } else {
+      Print("Sell order failed: ", GetLastError());
+   }
+}
+//+------------------------------------------------------------------+
+//| Check exit conditions based on POC crossing candle body          |
+//+------------------------------------------------------------------+
+void CheckExitConditions(double bodyLow, double bodyHigh) {
+   if(!PositionSelect(_Symbol)) return;
+   // Check if POC is between candle body
+   if(g_currentSession.poc >= bodyLow && g_currentSession.poc <= bodyHigh) {
+      // Close position
+      MqlTradeRequest request = {};
+      MqlTradeResult result = {};
+      request.action = TRADE_ACTION_DEAL;
+      request.symbol = _Symbol;
+      request.volume = PositionGetDouble(POSITION_VOLUME);
+      request.deviation = 10;
+      request.magic = 123456;
+      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
+         request.type = ORDER_TYPE_SELL;
+         request.price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
+      } else {
+         request.type = ORDER_TYPE_BUY;
+         request.price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
+      }
+      if(OrderSend(request, result)) {
+         Print("Position closed: POC crossed candle body");
+      }
+   }
+}
+//+------------------------------------------------------------------+

MQL5 Folder/Dec25_Volume Profile based breakout momentuim strategy/codegemini.c++ ADDED Viewed

	@@ -0,0 +1,382 @@

+//+------------------------------------------------------------------+
+//|                                       VolumeProfile_Breakout.mq5 |
+//|                                      Copyright 2024, Claude AI   |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#property copyright "Claude AI"
+#property link      "https://www.mql5.com"
+#property version   "1.00"
+#property strict
+#include <Trade\Trade.mqh>
+#include <Trade\SymbolInfo.mqh>
+#include <Trade\PositionInfo.mqh>
+#include <Trade\AccountInfo.mqh>
+//--- INPUT PARAMETERS
+input group             "Risk Management"
+input double            InpRiskPercent       = 1.0;      // Risk per trade (%) or simply 1%
+input double            InpPriceStep         = 0.10;     // VP Price Step (e.g., 0.10 XAU price unit precision)
+input double            InpValueAreaPct      = 0.70;     // Value Area Percent (0.70)
+input group             "Filters"
+input int               InpMinSLDistance     = 10;       // Min StopLoss Factor (Spread * X) for example in XAU (Sl is not < 0.160 x 10)
+input group             "System"
+input int               InpMagicNumber       = 123456;   // Magic Number
+input string            InpTradeComment      = "VP_Algo"; // Trade Comment
+//--- GLOBAL OBJECTS
+CTrade         m_trade;
+CSymbolInfo    m_symbol;
+CPositionInfo  m_position;
+CAccountInfo   m_account;
+//--- GLOBAL VARIABLES
+datetime       m_last_calc_time;
+datetime       m_last_trade_hour; // Tracks the hour of the last trade
+double         m_developing_poc;
+double         m_developing_vah;
+double         m_developing_val;
+//--- DATA STRUCTURE FOR VOLUME PROFILE
+struct PriceLevel
+{
+   double price;
+   double volume;
+};
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit()
+{
+   if(!m_symbol.Name(Symbol()))
+      return(INIT_FAILED);
+   m_trade.SetExpertMagicNumber(InpMagicNumber);
+   m_trade.SetMarginMode();
+   m_trade.SetTypeFillingBySymbol(Symbol());
+   // Normalize Price Step to avoid zero division
+   if(InpPriceStep <= 0)
+   {
+      Print("Error: Price Step must be > 0");
+      return(INIT_PARAMETERS_INCORRECT);
+   }
+   m_last_calc_time = 0;
+   m_last_trade_hour = 0;
+   return(INIT_SUCCEEDED);
+}
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick()
+{
+   if(!m_symbol.RefreshRates()) return;
+   // 1. Manage Open Trades (Dynamic TP Logic)
+   ManageOpenTrades();
+   // 2. Check for New Bar to Calculate Profile and Signals
+   // We only calculate logic on bar close as per requirement
+   datetime time_0 = iTime(_Symbol, PERIOD_CURRENT, 0);
+   if(time_0 <= m_last_calc_time) return; // Already calculated for this bar
+   m_last_calc_time = time_0;
+   // --- CALCULATE PROFILE FOR PREVIOUS BARS ---
+   CalculateVolumeProfile();
+   // --- CHECK TRADING HOUR LOGIC ---
+   // Logic: Max one trade per whole trading hour.
+   datetime current_hour_dt = time_0 - (time_0 % 3600); // Floor to hour
+   if(m_last_trade_hour == current_hour_dt)
+   {
+      // We already traded this hour
+      return;
+   }
+   // --- CHECK ENTRY SIGNALS ---
+   CheckEntrySignals(current_hour_dt);
+}
+//+------------------------------------------------------------------+
+//| Logic: Calculate Developing POC/VAH/VAL                          |
+//| Replicates the Python "cumulative_volume" distribution           |
+//+------------------------------------------------------------------+
+void CalculateVolumeProfile()
+{
+   // Get Start of Day (Session)
+   datetime time_current = iTime(_Symbol, PERIOD_CURRENT, 0);
+   datetime time_day_start = iTime(_Symbol, PERIOD_D1, 0);
+   // If data is unavailable, fallback
+   if(time_day_start == 0) time_day_start = time_current - 86400;
+   // Get all bars from start of day up to index 1 (closed bar)
+   int start_idx = iBarShift(_Symbol, PERIOD_CURRENT, time_day_start);
+   int end_idx = 1; // We look at closed bars only for calculation
+   if(start_idx < end_idx) return;
+   // Map: Price(int normalized) -> Volume
+   // Using dynamic arrays as a simple hash map replacement
+   double volumes[];
+   double prices[];
+   int    total_levels = 0;
+   // Resize initially to a reasonable estimate
+   ArrayResize(volumes, 1000);
+   ArrayResize(prices, 1000);
+   ArrayInitialize(volumes, 0);
+   ArrayInitialize(prices, 0);
+   // --- ITERATE CANDLES ---
+   for(int i = start_idx; i >= end_idx; i--)
+   {
+      double h = iHigh(_Symbol, PERIOD_CURRENT, i);
+      double l = iLow(_Symbol, PERIOD_CURRENT, i);
+      long   v = iVolume(_Symbol, PERIOD_CURRENT, i); // Tick Volume
+      if(v <= 0) continue;
+      // Python logic: prices = np.arange(low, high + 0.01, step)
+      // Count steps
+      int steps = (int)((h - l) / InpPriceStep) + 1;
+      if(steps <= 0) steps = 1;
+      double vol_per_step = (double)v / steps;
+      for(int s = 0; s < steps; s++)
+      {
+         double p_raw = l + (s * InpPriceStep);
+         double p_norm = NormalizeDouble(p_raw, _Digits);
+         // Find or Add to array (Simple linear search is slow but robust for MQL5 arrays without generics)
+         // Optimization: In production, use a sorted array + binary search or a min-max offset array.
+         // Here we use a simplified accumulating method sufficient for M15 data.
+         bool found = false;
+         for(int k=0; k<total_levels; k++)
+         {
+             // Floating point comparison
+             if(MathAbs(prices[k] - p_norm) < _Point)
+             {
+                 volumes[k] += vol_per_step;
+                 found = true;
+                 break;
+             }
+         }
+         if(!found)
+         {
+             if(total_levels >= ArraySize(prices))
+             {
+                 ArrayResize(prices, total_levels + 500);
+                 ArrayResize(volumes, total_levels + 500);
+             }
+             prices[total_levels] = p_norm;
+             volumes[total_levels] = vol_per_step;
+             total_levels++;
+         }
+      }
+   }
+   // Sort Data (Bubble sort is slow, we copy to struct array and use built-in Sort)
+   PriceLevel levels[];
+   ArrayResize(levels, total_levels);
+   double total_vol = 0;
+   for(int i=0; i<total_levels; i++)
+   {
+      levels[i].price = prices[i];
+      levels[i].volume = volumes[i];
+      total_vol += volumes[i];
+   }
+   // Sort by Price Ascending for Value Area calc
+   // Note: We need a custom sort or manual sort.
+   // Simple selection sort for Price (since total_levels usually < 500 per session on M15)
+   for(int i=0; i<total_levels-1; i++)
+   {
+      int min_idx = i;
+      for(int j=i+1; j<total_levels; j++)
+      {
+         if(levels[j].price < levels[min_idx].price) min_idx = j;
+      }
+      PriceLevel temp = levels[min_idx];
+      levels[min_idx] = levels[i];
+      levels[i] = temp;
+   }
+   // --- FIND POC ---
+   int poc_idx = 0;
+   double max_vol = -1.0;
+   for(int i=0; i<total_levels; i++)
+   {
+      if(levels[i].volume > max_vol)
+      {
+         max_vol = levels[i].volume;
+         poc_idx = i;
+      }
+   }
+   m_developing_poc = levels[poc_idx].price;
+   // --- CALCULATE VAH / VAL (70% Rule) ---
+   double target_vol = total_vol * InpValueAreaPct;
+   double current_vol = levels[poc_idx].volume;
+   int idx_low = poc_idx;
+   int idx_high = poc_idx;
+   // Expand outwards from POC
+   while(current_vol < target_vol)
+   {
+      double vol_below = (idx_low > 0) ? levels[idx_low - 1].volume : 0;
+      double vol_above = (idx_high < total_levels - 1) ? levels[idx_high + 1].volume : 0;
+      // If we hit boundaries
+      if(idx_low == 0 && idx_high == total_levels - 1) break;
+      if(vol_above > vol_below || idx_low == 0)
+      {
+         if(idx_high < total_levels - 1)
+         {
+            idx_high++;
+            current_vol += levels[idx_high].volume;
+         }
+      }
+      else
+      {
+         if(idx_low > 0)
+         {
+            idx_low--;
+            current_vol += levels[idx_low].volume;
+         }
+      }
+   }
+   m_developing_val = levels[idx_low].price;
+   m_developing_vah = levels[idx_high].price;
+}
+//+------------------------------------------------------------------+
+//| Check Logic and Open Trades                                      |
+//+------------------------------------------------------------------+
+void CheckEntrySignals(datetime current_hour)
+{
+   // Previous closed candle (Signal Candle)
+   double close = iClose(_Symbol, PERIOD_CURRENT, 1);
+   double low   = iLow(_Symbol, PERIOD_CURRENT, 1);
+   double high  = iHigh(_Symbol, PERIOD_CURRENT, 1);
+   // Get Spread
+   double spread = (double)SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) * _Point;
+   // --- BUY LOGIC ---
+   // Candle Closes ABOVE VAH
+   if(close > m_developing_vah)
+   {
+      double sl_price = low;
+      double sl_dist = close - sl_price;
+      // Filter: Stop Loss Distance < Spread * 10
+      if(sl_dist < (spread * InpMinSLDistance)) return;
+      // Calculate Lot Size
+      double vol = GetLotSize(sl_dist);
+      if(m_trade.Buy(vol, _Symbol, 0, sl_price, 0, InpTradeComment))
+      {
+         m_last_trade_hour = current_hour;
+      }
+   }
+   // --- SELL LOGIC ---
+   // Candle Closes BELOW VAL
+   else if(close < m_developing_val)
+   {
+      double sl_price = high;
+      double sl_dist = sl_price - close;
+      // Filter: Stop Loss Distance < Spread * 10
+      if(sl_dist < (spread * InpMinSLDistance)) return;
+      double vol = GetLotSize(sl_dist);
+      if(m_trade.Sell(vol, _Symbol, 0, sl_price, 0, InpTradeComment))
+      {
+         m_last_trade_hour = current_hour;
+      }
+   }
+}
+//+------------------------------------------------------------------+
+//| Manage Open Trades (Dynamic Take Profit)                         |
+//| "Close if corresponding POC closes between body of candle"       |
+//+------------------------------------------------------------------+
+void ManageOpenTrades()
+{
+   if(PositionsTotal() == 0) return;
+   // Check current active candle data
+   double open_current  = iOpen(_Symbol, PERIOD_CURRENT, 0);
+   double close_current = iClose(_Symbol, PERIOD_CURRENT, 0); // Current price
+   double body_high = MathMax(open_current, close_current);
+   double body_low  = MathMin(open_current, close_current);
+   // Iterate backwards to avoid index issues on close
+   for(int i = PositionsTotal() - 1; i >= 0; i--)
+   {
+      if(m_position.SelectByIndex(i))
+      {
+         if(m_position.Symbol() == _Symbol && m_position.Magic() == InpMagicNumber)
+         {
+            // Logic: Is current POC inside current candle BODY?
+            if(m_developing_poc >= body_low && m_developing_poc <= body_high)
+            {
+               // Close the trade
+               m_trade.PositionClose(m_position.Ticket());
+            }
+         }
+      }
+   }
+}
+//+------------------------------------------------------------------+
+//| Helper: Calculate Lot Size based on Risk %                       |
+//+------------------------------------------------------------------+
+double GetLotSize(double sl_distance)
+{
+   if(sl_distance <= 0) return 0.01;
+   double risk_money = m_account.Balance() * (InpRiskPercent / 100.0);
+   double tick_value = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
+   double tick_size  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
+   if(tick_size == 0 || tick_value == 0) return 0.01;
+   double loss_per_lot = (sl_distance / tick_size) * tick_value;
+   if(loss_per_lot == 0) return 0.01;
+   double lots = risk_money / loss_per_lot;
+   // Normalize lots
+   double min_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
+   double max_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
+   double step_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
+   lots = MathFloor(lots / step_lot) * step_lot;
+   if(lots < min_lot) lots = min_lot;
+   if(lots > max_lot) lots = max_lot;
+   return lots;
+}

MQL5 Folder/Dec29_6-8 range/strategy.ipynb ADDED Viewed

The diff for this file is too large to render. See raw diff

MQL5 Folder/Dec29_6-8 range/v1.c++ ADDED Viewed

	@@ -0,0 +1,273 @@

+//+------------------------------------------------------------------+
+//|                                             RangeBreakout_M3.mq5 |
+//|                                  Copyright 2023, Gemini AI Asst. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#property copyright "Gemini AI"
+#property link      "https://www.mql5.com"
+#property version   "1.00"
+#property strict
+//--- Include Standard Library for easier trade execution
+#include <Trade\Trade.mqh>
+//+------------------------------------------------------------------+
+//| Inputs                                                           |
+//+------------------------------------------------------------------+
+input group "Risk Management"
+input double   InpRiskPercent    = 1.0;      // Risk per trade (% of Balance)
+input int      InpRewardRatio    = 10;       // Reward Ratio (TP = 10 * Risk)
+input group "Time Settings"
+input int      InpRangeStartHour = 22;       // Range Start Hour (UTC equivalent)
+input int      InpRangeEndHour   = 0;        // Range End Hour (0 = Midnight)
+input int      InpBrokerOffset   = 0;        // Broker Time Offset from UTC (e.g., if Broker is UTC+2, put 2)
+input group "System"
+input ulong    InpMagicNum       = 123456;   // Magic Number
+//+------------------------------------------------------------------+
+//| Global Variables                                                 |
+//+------------------------------------------------------------------+
+CTrade         trade;
+datetime       lastBarTime       = 0;
+bool           tradeTakenToday   = false;
+int            lastTradeDay      = -1;
+// Structure to hold Range Data
+struct RangeData {
+   double   HHR;        // Highest High of Range
+   double   LLR;        // Lowest Low of Range
+   datetime timeHHR;    // Time of HHR (EP)
+   datetime timeLLR;    // Time of LLR (EP)
+   bool     isValid;    // Is range calculated?
+};
+RangeData currentRange;
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit()
+{
+   trade.SetExpertMagicNumber(InpMagicNum);
+   // Ensure we are allowed to trade
+   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
+      Print("Warning: AutoTrading is disabled in Terminal.");
+   return(INIT_SUCCEEDED);
+}
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick()
+{
+   // 1. Check for New Bar on M3 Timeframe
+   // We strictly use M3 per instructions
+   datetime currentBarTime = iTime(_Symbol, PERIOD_M3, 0);
+   if(currentBarTime == lastBarTime) return; // Wait for candle close
+   lastBarTime = currentBarTime;
+   // 2. Reset Daily Flags
+   MqlDateTime dt;
+   TimeCurrent(dt);
+   if(lastTradeDay != dt.day) {
+      tradeTakenToday = false;
+      lastTradeDay = dt.day;
+      currentRange.isValid = false; // Reset range for the new day
+   }
+   // 3. One Trade Per Day Logic
+   if(tradeTakenToday) return;
+   // 4. Calculate Range if not yet done and time is past 00:00
+   // We need to define the 22:00 - 00:00 window of the *previous* session
+   if(!currentRange.isValid) {
+      CalculateRange();
+   }
+   // 5. If Range is valid, Check for Breakout Logic
+   if(currentRange.isValid) {
+      CheckBreakoutSignal();
+   }
+}
+//+------------------------------------------------------------------+
+//| Function to Calculate HHR and LLR (22:00 - 00:00)                |
+//+------------------------------------------------------------------+
+void CalculateRange()
+{
+   MqlDateTime dt;
+   TimeCurrent(dt);
+   // Determine the correct start and end time for the range
+   // The range is 22:00 (Previous Day) to 00:00 (Today)
+   // Adjusted for Broker Offset
+   int startHour = InpRangeStartHour + InpBrokerOffset;
+   int endHour   = InpRangeEndHour + InpBrokerOffset;
+   // Handle hour overflow (e.g., 22 + 2 = 24 -> 00)
+   if(startHour >= 24) startHour -= 24;
+   if(endHour >= 24) endHour -= 24;
+   // We need the range from yesterday's 22:00 to today's 00:00
+   datetime timeEnd   = StringToTime(StringFormat("%04d.%02d.%02d %02d:00", dt.year, dt.mon, dt.day, endHour));
+   datetime timeStart = timeEnd - (2 * 3600); // Subtract 2 hours (22 to 00 is 2 hours)
+   // Check if we have passed the range end time
+   if(TimeCurrent() < timeEnd) return; // Wait until range closes
+   // Get Bars inside the range
+   MqlRates rates[];
+   ArraySetAsSeries(rates, true);
+   // Get data from M3 timeframe
+   int copied = CopyRates(_Symbol, PERIOD_M3, timeStart, timeEnd, rates);
+   if(copied > 0) {
+      double highest = -DBL_MAX;
+      double lowest  = DBL_MAX;
+      datetime tHigh = 0;
+      datetime tLow  = 0;
+      for(int i=0; i<copied; i++) {
+         if(rates[i].high > highest) {
+            highest = rates[i].high;
+            tHigh   = rates[i].time;
+         }
+         if(rates[i].low < lowest) {
+            lowest = rates[i].low;
+            tLow   = rates[i].time;
+         }
+      }
+      currentRange.HHR = highest;
+      currentRange.LLR = lowest;
+      currentRange.timeHHR = tHigh;
+      currentRange.timeLLR = tLow;
+      currentRange.isValid = true;
+      // Print("Range Calculated: HHR=", currentRange.HHR, " LLR=", currentRange.LLR);
+   }
+}
+//+------------------------------------------------------------------+
+//| Function to Check Breakout & Validation                          |
+//+------------------------------------------------------------------+
+void CheckBreakoutSignal()
+{
+   // Get the Breakout Candle (BCC) - Index 1 (Closed Candle)
+   MqlRates bcc[];
+   ArraySetAsSeries(bcc, true);
+   if(CopyRates(_Symbol, PERIOD_M3, 1, 1, bcc) != 1) return;
+   double bccClose = bcc[0].close;
+   double bccHigh  = bcc[0].high;
+   double bccLow   = bcc[0].low;
+   datetime bccTime = bcc[0].time;
+   // --- BUY LOGIC ---
+   if(bccClose > currentRange.HHR) {
+      // Filter: Check candles from EP (timeHHR) until BCC
+      // Ensure wicks haven't touched HHR in between
+      if(IsPathClear(currentRange.timeHHR, bccTime, currentRange.HHR, true)) {
+         double sl = bccLow;
+         double riskDist = bccClose - sl;
+         // Safety check for zero distance
+         if(riskDist <= 0) return;
+         double tp = bccClose + (riskDist * InpRewardRatio);
+         double lotSize = CalculateLotSize(MathAbs(bccClose - sl));
+         if(trade.Buy(lotSize, _Symbol, bccClose, sl, tp, "Range Breakout Buy")) {
+            tradeTakenToday = true;
+         }
+      }
+   }
+   // --- SELL LOGIC ---
+   else if(bccClose < currentRange.LLR) {
+      // Filter: Check candles from EP (timeLLR) until BCC
+      // Ensure wicks haven't touched LLR in between
+      if(IsPathClear(currentRange.timeLLR, bccTime, currentRange.LLR, false)) {
+         double sl = bccHigh;
+         double riskDist = sl - bccClose;
+         if(riskDist <= 0) return;
+         double tp = bccClose - (riskDist * InpRewardRatio);
+         double lotSize = CalculateLotSize(MathAbs(sl - bccClose));
+         if(trade.Sell(lotSize, _Symbol, bccClose, sl, tp, "Range Breakout Sell")) {
+            tradeTakenToday = true;
+         }
+      }
+   }
+}
+//+------------------------------------------------------------------+
+//| Filter: Verify no touches between EP and BCC                     |
+//+------------------------------------------------------------------+
+bool IsPathClear(datetime startTime, datetime endTime, double level, bool isBuy)
+{
+   // We need candles BETWEEN startTime and endTime (exclusive of start, exclusive of end)
+   // Logic: Get bars from Start to End.
+   MqlRates rates[];
+   ArraySetAsSeries(rates, true);
+   // Copy rates from start time to end time
+   int count = CopyRates(_Symbol, PERIOD_M3, startTime, endTime, rates);
+   // Iterate, skipping the first (which matches startTime/EP) and last (which is BCC - handled by logic)
+   // Note: CopyRates with start/end includes the bars that contain those times.
+   // Because Array is Series, index 0 is the bar AT endTime (The Breakout Candle).
+   // Index [count-1] is the bar AT startTime (The EP).
+   for(int i = 1; i < count - 1; i++) {
+      if(isBuy) {
+         // For Buy: No High should have touched HHR
+         if(rates[i].high >= level) return false;
+      } else {
+         // For Sell: No Low should have touched LLR
+         if(rates[i].low <= level) return false;
+      }
+   }
+   return true;
+}
+//+------------------------------------------------------------------+
+//| Risk Management: Calculate Lots based on 1% Risk                 |
+//+------------------------------------------------------------------+
+double CalculateLotSize(double slDistancePrice)
+{
+   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+   double riskMoney = balance * (InpRiskPercent / 100.0);
+   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
+   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
+   if(tickSize == 0 || tickValue == 0 || slDistancePrice == 0) return 0.01; // Safety
+   double slPoints = slDistancePrice / tickSize;
+   double lotSize = riskMoney / (slPoints * tickValue);
+   // Normalize Lot Size
+   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
+   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
+   double stepLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
+   lotSize = MathFloor(lotSize / stepLot) * stepLot;
+   if(lotSize < minLot) lotSize = minLot;
+   if(lotSize > maxLot) lotSize = maxLot;
+   return lotSize;
+}
+//+------------------------------------------------------------------+

MQL5 Folder/Dec29_6-8 range/v2.c++ ADDED Viewed

	@@ -0,0 +1,284 @@

+//+------------------------------------------------------------------+
+//|                                     RangeBreakout_Visual_M3.mq5  |
+//|                                  Copyright 2023, Gemini AI Asst. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#property copyright "Gemini AI"
+#property link      "https://www.mql5.com"
+#property version   "1.10"
+#property strict
+//--- Include Standard Library for easier trade execution
+#include <Trade\Trade.mqh>
+//+------------------------------------------------------------------+
+//| Inputs                                                           |
+//+------------------------------------------------------------------+
+input group "Risk Management"
+input double   InpRiskPercent    = 1.0;      // Risk per trade (% of Balance)
+input int      InpRewardRatio    = 10;       // Reward Ratio (TP = 10 * Risk)
+input group "Time Settings"
+input int      InpRangeStartHour = 22;       // Range Start Hour (UTC equivalent)
+input int      InpRangeEndHour   = 0;        // Range End Hour (0 = Midnight)
+input int      InpBrokerOffset   = 0;        // Broker Time Offset from UTC
+input group "Visuals"
+input bool     InpDrawRange      = true;     // Draw Range Box on Chart
+input color    InpBoxColor       = clrLavender; // Color of the Range Box
+input group "System"
+input ulong    InpMagicNum       = 123456;   // Magic Number
+//+------------------------------------------------------------------+
+//| Global Variables                                                 |
+//+------------------------------------------------------------------+
+CTrade         trade;
+datetime       lastBarTime       = 0;
+bool           tradeTakenToday   = false;
+int            lastTradeDay      = -1;
+string         rangeObjName      = "Range_Box_Visual";
+// Structure to hold Range Data
+struct RangeData {
+   double   HHR;        // Highest High of Range
+   double   LLR;        // Lowest Low of Range
+   datetime timeHHR;    // Time of HHR (EP)
+   datetime timeLLR;    // Time of LLR (EP)
+   bool     isValid;    // Is range calculated?
+};
+RangeData currentRange;
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit()
+{
+   trade.SetExpertMagicNumber(InpMagicNum);
+   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
+      Print("Warning: AutoTrading is disabled in Terminal.");
+   return(INIT_SUCCEEDED);
+}
+//+------------------------------------------------------------------+
+//| Expert deinitialization function                                 |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason)
+{
+   // Cleanup drawing objects when EA is removed
+   if(ObjectFind(0, rangeObjName) >= 0) {
+      ObjectDelete(0, rangeObjName);
+   }
+}
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick()
+{
+   datetime currentBarTime = iTime(_Symbol, PERIOD_M3, 0);
+   if(currentBarTime == lastBarTime) return; // Wait for candle close
+   lastBarTime = currentBarTime;
+   // Reset Daily Flags
+   MqlDateTime dt;
+   TimeCurrent(dt);
+   if(lastTradeDay != dt.day) {
+      tradeTakenToday = false;
+      lastTradeDay = dt.day;
+      currentRange.isValid = false;
+      // Optional: Delete yesterday's box to keep chart clean
+      if(ObjectFind(0, rangeObjName) >= 0) ObjectDelete(0, rangeObjName);
+   }
+   if(tradeTakenToday) return;
+   // Calculate Range if not yet done
+   if(!currentRange.isValid) {
+      CalculateRange();
+   }
+   if(currentRange.isValid) {
+      CheckBreakoutSignal();
+   }
+}
+//+------------------------------------------------------------------+
+//| Function to Calculate HHR and LLR                                |
+//+------------------------------------------------------------------+
+void CalculateRange()
+{
+   MqlDateTime dt;
+   TimeCurrent(dt);
+   int startHour = InpRangeStartHour + InpBrokerOffset;
+   int endHour   = InpRangeEndHour + InpBrokerOffset;
+   if(startHour >= 24) startHour -= 24;
+   if(endHour >= 24) endHour -= 24;
+   // Calculate specific time range (Yesterday 22:00 to Today 00:00)
+   datetime timeEnd   = StringToTime(StringFormat("%04d.%02d.%02d %02d:00", dt.year, dt.mon, dt.day, endHour));
+   datetime timeStart = timeEnd - (2 * 3600); // 2 hours duration
+   // Check if the current time is actually past the range end
+   if(TimeCurrent() < timeEnd) return;
+   // Get Bars inside the range
+   MqlRates rates[];
+   ArraySetAsSeries(rates, true);
+   int copied = CopyRates(_Symbol, PERIOD_M3, timeStart, timeEnd, rates);
+   if(copied > 0) {
+      double highest = -DBL_MAX;
+      double lowest  = DBL_MAX;
+      datetime tHigh = 0;
+      datetime tLow  = 0;
+      for(int i=0; i<copied; i++) {
+         if(rates[i].high > highest) {
+            highest = rates[i].high;
+            tHigh   = rates[i].time;
+         }
+         if(rates[i].low < lowest) {
+            lowest = rates[i].low;
+            tLow   = rates[i].time;
+         }
+      }
+      currentRange.HHR = highest;
+      currentRange.LLR = lowest;
+      currentRange.timeHHR = tHigh;
+      currentRange.timeLLR = tLow;
+      currentRange.isValid = true;
+      // DRAW THE RANGE
+      if(InpDrawRange) {
+         DrawRangeBox(timeStart, timeEnd, currentRange.HHR, currentRange.LLR);
+      }
+   }
+}
+//+------------------------------------------------------------------+
+//| Function to Draw the Range Box                                   |
+//+------------------------------------------------------------------+
+void DrawRangeBox(datetime t1, datetime t2, double priceHigh, double priceLow)
+{
+   // Delete if exists to update
+   if(ObjectFind(0, rangeObjName) >= 0) ObjectDelete(0, rangeObjName);
+   // Create Rectangle
+   if(ObjectCreate(0, rangeObjName, OBJ_RECTANGLE, 0, t1, priceHigh, t2, priceLow)) {
+      ObjectSetInteger(0, rangeObjName, OBJPROP_COLOR, InpBoxColor);
+      ObjectSetInteger(0, rangeObjName, OBJPROP_FILL, true);      // Fill the box
+      ObjectSetInteger(0, rangeObjName, OBJPROP_BACK, true);      // Put behind candles
+      ObjectSetInteger(0, rangeObjName, OBJPROP_WIDTH, 1);
+      ObjectSetString(0, rangeObjName, OBJPROP_TEXT, "Daily Range");
+   }
+}
+//+------------------------------------------------------------------+
+//| Function to Check Breakout & Validation                          |
+//+------------------------------------------------------------------+
+void CheckBreakoutSignal()
+{
+   MqlRates bcc[];
+   ArraySetAsSeries(bcc, true);
+   if(CopyRates(_Symbol, PERIOD_M3, 1, 1, bcc) != 1) return;
+   double bccClose = bcc[0].close;
+   double bccHigh  = bcc[0].high;
+   double bccLow   = bcc[0].low;
+   datetime bccTime = bcc[0].time;
+   // --- BUY LOGIC ---
+   if(bccClose > currentRange.HHR) {
+      if(IsPathClear(currentRange.timeHHR, bccTime, currentRange.HHR, true)) {
+         double sl = bccLow;
+         double riskDist = bccClose - sl;
+         if(riskDist <= 0) return;
+         double tp = bccClose + (riskDist * InpRewardRatio);
+         double lotSize = CalculateLotSize(MathAbs(bccClose - sl));
+         if(trade.Buy(lotSize, _Symbol, bccClose, sl, tp, "Range Breakout Buy")) {
+            tradeTakenToday = true;
+         }
+      }
+   }
+   // --- SELL LOGIC ---
+   else if(bccClose < currentRange.LLR) {
+      if(IsPathClear(currentRange.timeLLR, bccTime, currentRange.LLR, false)) {
+         double sl = bccHigh;
+         double riskDist = sl - bccClose;
+         if(riskDist <= 0) return;
+         double tp = bccClose - (riskDist * InpRewardRatio);
+         double lotSize = CalculateLotSize(MathAbs(sl - bccClose));
+         if(trade.Sell(lotSize, _Symbol, bccClose, sl, tp, "Range Breakout Sell")) {
+            tradeTakenToday = true;
+         }
+      }
+   }
+}
+//+------------------------------------------------------------------+
+//| Filter: Verify no touches between EP and BCC                     |
+//+------------------------------------------------------------------+
+bool IsPathClear(datetime startTime, datetime endTime, double level, bool isBuy)
+{
+   MqlRates rates[];
+   ArraySetAsSeries(rates, true);
+   int count = CopyRates(_Symbol, PERIOD_M3, startTime, endTime, rates);
+   // Loop excludes start (EP) and end (BCC)
+   for(int i = 1; i < count - 1; i++) {
+      if(isBuy) {
+         if(rates[i].high >= level) return false;
+      } else {
+         if(rates[i].low <= level) return false;
+      }
+   }
+   return true;
+}
+//+------------------------------------------------------------------+
+//| Risk Management                                                  |
+//+------------------------------------------------------------------+
+double CalculateLotSize(double slDistancePrice)
+{
+   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+   double riskMoney = balance * (InpRiskPercent / 100.0);
+   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
+   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
+   if(tickSize == 0 || tickValue == 0 || slDistancePrice == 0) return 0.01;
+   double slPoints = slDistancePrice / tickSize;
+   double lotSize = riskMoney / (slPoints * tickValue);
+   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
+   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
+   double stepLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
+   lotSize = MathFloor(lotSize / stepLot) * stepLot;
+   if(lotSize < minLot) lotSize = minLot;
+   if(lotSize > maxLot) lotSize = maxLot;
+   return lotSize;
+}
+//+------------------------------------------------------------------+

MQL5 Folder/Developing POC/developing POC line.ipynb ADDED Viewed

	@@ -0,0 +1,34 @@

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fdbde53e",
+   "metadata": {},
+   "source": [
+    "This error is from the toolbox of MT5: {} it has a CSV format of \"Description, File, Line, Column,\" columns with their corresponding rows.  But I only want you to care about what is written in the Description and Line because that's the 'error' it wants to depict. Then, after that, revise the previous code you've given me based on that 'Description' withthe  corresponding 'Line' error specification statements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f2371cf",
+   "metadata": {},
+   "source": [
+    "This error is from the toolbox of MT5: {\n",
+    "} It has a CSV format of \"Description, File, Line, Column,\" columns with their corresponding rows.  But I only want you to care about what is written in the Description and Line because that's the 'error' it wants to depict. Then, after that, revise the previous code you've given me based on that 'Description' with the corresponding 'Line' error specification statements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c85cb54",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

MQL5 Folder/H3 0 bar redbear bluebull (indicator)/1_version.mq5 ADDED Viewed

	@@ -0,0 +1,86 @@

+#property indicator_chart_window
+#property indicator_buffers 5
+#property indicator_plots   1
+#property indicator_type1   DRAW_COLOR_CANDLES
+#property indicator_label1  "H3 00:00 Candle"
+#property indicator_color1  clrBlue, clrRed
+// =====================
+// BUFFERS
+// =====================
+double OpenBuf[];
+double HighBuf[];
+double LowBuf[];
+double CloseBuf[];
+double ColorBuf[];
+// =====================
+// INIT
+// =====================
+int OnInit()
+{
+   // Chart visual settings
+   ChartSetInteger(0, CHART_SHOW_GRID, false);
+   ChartSetInteger(0, CHART_SHOW_BID_LINE, true);
+   ChartSetInteger(0, CHART_SHOW_ASK_LINE, true);
+   SetIndexBuffer(0, OpenBuf,  INDICATOR_DATA);
+   SetIndexBuffer(1, HighBuf,  INDICATOR_DATA);
+   SetIndexBuffer(2, LowBuf,   INDICATOR_DATA);
+   SetIndexBuffer(3, CloseBuf, INDICATOR_DATA);
+   SetIndexBuffer(4, ColorBuf, INDICATOR_COLOR_INDEX);
+   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, 0);
+   PlotIndexSetInteger(0, PLOT_COLOR_INDEXES, 2);
+   IndicatorSetString(INDICATOR_SHORTNAME, "H3 00:00 Bull/Bear Candle");
+   return(INIT_SUCCEEDED);
+}
+// =====================
+// CALCULATION
+// =====================
+int OnCalculate(
+   const int rates_total,
+   const int prev_calculated,
+   const datetime &time[],
+   const double &open[],
+   const double &high[],
+   const double &low[],
+   const double &close[],
+   const long &tick_volume[],
+   const long &volume[],
+   const int &spread[]
+)
+{
+   if(_Period != PERIOD_H3)
+      return(rates_total);
+   int start = (prev_calculated > 0) ? prev_calculated - 1 : 0;
+   for(int i = start; i < rates_total; i++)
+   {
+      OpenBuf[i]  = open[i];
+      HighBuf[i]  = high[i];
+      LowBuf[i]   = low[i];
+      CloseBuf[i] = close[i];
+      ColorBuf[i] = EMPTY_VALUE;
+      MqlDateTime t;
+      TimeToStruct(time[i], t);
+      // H3 candle starting at 00:00
+      if(t.hour == 0)
+      {
+         if(close[i] > open[i])
+            ColorBuf[i] = 0; // Bullish (Blue)
+         else if(close[i] < open[i])
+            ColorBuf[i] = 1; // Bearish (Red)
+      }
+   }
+   return(rates_total);
+}

MQL5 Folder/H3 0 bar redbear bluebull (indicator)/H3 0 bar redbear bluebull (indicator).ipynb ADDED Viewed

	@@ -0,0 +1,322 @@

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "07883ea1",
+   "metadata": {},
+   "source": [
+    "indicator that makes that 0:00 H3 bullish bar blue and red if bearish"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35195363",
+   "metadata": {},
+   "source": [
+    "#property indicator_chart_window\n",
+    "#property indicator_buffers 5\n",
+    "#property indicator_plots   1\n",
+    "\n",
+    "#property indicator_type1   DRAW_COLOR_CANDLES\n",
+    "#property indicator_label1  \"H3 00:00 Candle\"\n",
+    "#property indicator_color1  clrBlue, clrRed\n",
+    "\n",
+    "// =====================\n",
+    "// BUFFERS\n",
+    "// =====================\n",
+    "double OpenBuf[];\n",
+    "double HighBuf[];\n",
+    "double LowBuf[];\n",
+    "double CloseBuf[];\n",
+    "double ColorBuf[];\n",
+    "\n",
+    "// =====================\n",
+    "// INIT\n",
+    "// =====================\n",
+    "int OnInit()\n",
+    "{\n",
+    "   SetIndexBuffer(0, OpenBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(1, HighBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(2, LowBuf,   INDICATOR_DATA);\n",
+    "   SetIndexBuffer(3, CloseBuf, INDICATOR_DATA);\n",
+    "   SetIndexBuffer(4, ColorBuf, INDICATOR_COLOR_INDEX);\n",
+    "\n",
+    "   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, 0);\n",
+    "   PlotIndexSetInteger(0, PLOT_COLOR_INDEXES, 2);\n",
+    "\n",
+    "   IndicatorSetString(INDICATOR_SHORTNAME, \"H3 00:00 Bull/Bear Candle\");\n",
+    "\n",
+    "   return(INIT_SUCCEEDED);\n",
+    "}\n",
+    "\n",
+    "// =====================\n",
+    "// CALCULATION\n",
+    "// =====================\n",
+    "int OnCalculate(\n",
+    "   const int rates_total,\n",
+    "   const int prev_calculated,\n",
+    "   const datetime &time[],\n",
+    "   const double &open[],\n",
+    "   const double &high[],\n",
+    "   const double &low[],\n",
+    "   const double &close[],\n",
+    "   const long &tick_volume[],\n",
+    "   const long &volume[],\n",
+    "   const int &spread[]\n",
+    ")\n",
+    "{\n",
+    "   // Only valid on H3\n",
+    "   if(_Period != PERIOD_H3)\n",
+    "      return(rates_total);\n",
+    "\n",
+    "   int start = (prev_calculated > 0) ? prev_calculated - 1 : 0;\n",
+    "\n",
+    "   for(int i = start; i < rates_total; i++)\n",
+    "   {\n",
+    "      // Copy price data\n",
+    "      OpenBuf[i]  = open[i];\n",
+    "      HighBuf[i]  = high[i];\n",
+    "      LowBuf[i]   = low[i];\n",
+    "      CloseBuf[i] = close[i];\n",
+    "\n",
+    "      ColorBuf[i] = EMPTY_VALUE;\n",
+    "\n",
+    "      MqlDateTime t;\n",
+    "      TimeToStruct(time[i], t);\n",
+    "\n",
+    "      // Check H3 candle starting at 00:00\n",
+    "      if(t.hour == 0 && (t.hour % 3) == 0)\n",
+    "      {\n",
+    "         if(close[i] > open[i])\n",
+    "            ColorBuf[i] = 0; // Blue (bullish)\n",
+    "         else if(close[i] < open[i])\n",
+    "            ColorBuf[i] = 1; // Red (bearish)\n",
+    "      }\n",
+    "   }\n",
+    "\n",
+    "   return(rates_total);\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9dd739c6",
+   "metadata": {},
+   "source": [
+    "remove the grid of the chart\n",
+    "ChartSetInteger(0, CHART_SHOW_GRID, false); in OnInit()"
+   ]
+  },
+  {
+   "attachments": {
+    "image.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "id": "b5503b25",
+   "metadata": {},
+   "source": [
+    "![image.png](attachment:image.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d0611a9f",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#property indicator_chart_window\n",
+    "#property indicator_buffers 5\n",
+    "#property indicator_plots   1\n",
+    "\n",
+    "#property indicator_type1   DRAW_COLOR_CANDLES\n",
+    "#property indicator_label1  \"H3 00:00 Candle\"\n",
+    "#property indicator_color1  clrBlue, clrRed\n",
+    "\n",
+    "// =====================\n",
+    "// BUFFERS\n",
+    "// =====================\n",
+    "double OpenBuf[];\n",
+    "double HighBuf[];\n",
+    "double LowBuf[];\n",
+    "double CloseBuf[];\n",
+    "double ColorBuf[];\n",
+    "\n",
+    "// =====================\n",
+    "// INIT\n",
+    "// =====================\n",
+    "int OnInit()\n",
+    "{\n",
+    "   // Chart visual settings\n",
+    "   ChartSetInteger(0, CHART_SHOW_GRID, false);\n",
+    "   ChartSetInteger(0, CHART_SHOW_BID_LINE, true);\n",
+    "   ChartSetInteger(0, CHART_SHOW_ASK_LINE, true);\n",
+    "\n",
+    "   SetIndexBuffer(0, OpenBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(1, HighBuf,  INDICATOR_DATA);\n",
+    "   SetIndexBuffer(2, LowBuf,   INDICATOR_DATA);\n",
+    "   SetIndexBuffer(3, CloseBuf, INDICATOR_DATA);\n",
+    "   SetIndexBuffer(4, ColorBuf, INDICATOR_COLOR_INDEX);\n",
+    "\n",
+    "   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, 0);\n",
+    "   PlotIndexSetInteger(0, PLOT_COLOR_INDEXES, 2);\n",
+    "\n",
+    "   IndicatorSetString(INDICATOR_SHORTNAME, \"H3 00:00 Bull/Bear Candle\");\n",
+    "\n",
+    "   return(INIT_SUCCEEDED);\n",
+    "}\n",
+    "\n",
+    "// =====================\n",
+    "// CALCULATION\n",
+    "// =====================\n",
+    "int OnCalculate(\n",
+    "   const int rates_total,\n",
+    "   const int prev_calculated,\n",
+    "   const datetime &time[],\n",
+    "   const double &open[],\n",
+    "   const double &high[],\n",
+    "   const double &low[],\n",
+    "   const double &close[],\n",
+    "   const long &tick_volume[],\n",
+    "   const long &volume[],\n",
+    "   const int &spread[]\n",
+    ")\n",
+    "{\n",
+    "   if(_Period != PERIOD_H3)\n",
+    "      return(rates_total);\n",
+    "\n",
+    "   int start = (prev_calculated > 0) ? prev_calculated - 1 : 0;\n",
+    "\n",
+    "   for(int i = start; i < rates_total; i++)\n",
+    "   {\n",
+    "      OpenBuf[i]  = open[i];\n",
+    "      HighBuf[i]  = high[i];\n",
+    "      LowBuf[i]   = low[i];\n",
+    "      CloseBuf[i] = close[i];\n",
+    "\n",
+    "      ColorBuf[i] = EMPTY_VALUE;\n",
+    "\n",
+    "      MqlDateTime t;\n",
+    "      TimeToStruct(time[i], t);\n",
+    "\n",
+    "      // H3 candle starting at 00:00\n",
+    "      if(t.hour == 0)\n",
+    "      {\n",
+    "         if(close[i] > open[i])\n",
+    "            ColorBuf[i] = 0; // Bullish (Blue)\n",
+    "         else if(close[i] < open[i])\n",
+    "            ColorBuf[i] = 1; // Bearish (Red)\n",
+    "      }\n",
+    "   }\n",
+    "\n",
+    "   return(rates_total);\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7186708c",
+   "metadata": {},
+   "source": [
+    "Use MQL5, do not ever mix MT4-style functions in MT5, do not ever use the MT4-style helper, "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db07c1e8",
+   "metadata": {},
+   "source": [
+    "Make an MT5 indicator that draws a box (range size) at the first bar from 0:00 am time, extend this box 4 bars to the right. Use MQL5, do not ever mix MT4-style functions in MT5, do not ever use the MT4-style helper, "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b60c0f99",
+   "metadata": {},
+   "source": [
+    "#property indicator_chart_window\n",
+    "#property indicator_buffers 0\n",
+    "\n",
+    "#include <ChartObjects\\ChartObjectsShapes.mqh>\n",
+    "\n",
+    "input color BoxColor = clrYellow;        // Color of the box\n",
+    "input int BoxWidth = 2;                  // Width of the box border\n",
+    "input int ExtendBars = 4;                // How many bars to extend to the right\n",
+    "\n",
+    "// Global variables\n",
+    "CChartObjectRect box;\n",
+    "datetime lastDate = 0;\n",
+    "\n",
+    "//+------------------------------------------------------------------+\n",
+    "//| Custom indicator iteration function                               |\n",
+    "//+------------------------------------------------------------------+\n",
+    "int OnCalculate(const int rates_total,\n",
+    "                const int prev_calculated,\n",
+    "                const int begin,\n",
+    "                const double &price[])\n",
+    "{\n",
+    "    if(rates_total < 1)\n",
+    "        return(0);\n",
+    "\n",
+    "    // Get the current bar's date (YYYYMMDD)\n",
+    "    datetime barTime = iTime(_Symbol, PERIOD_CURRENT, 0);\n",
+    "    MqlDateTime dt;\n",
+    "    TimeToStruct(barTime, dt);\n",
+    "\n",
+    "    // Only once per new day\n",
+    "    if(dt.hour == 0 && dt.min == 0 && lastDate != dt.day)\n",
+    "    {\n",
+    "        lastDate = dt.day;\n",
+    "\n",
+    "        // Determine high and low of the first bar\n",
+    "        double barHigh = iHigh(_Symbol, PERIOD_CURRENT, 0);\n",
+    "        double barLow  = iLow(_Symbol, PERIOD_CURRENT, 0);\n",
+    "\n",
+    "        // Delete previous box if exists\n",
+    "        if(box.Name() != \"\")\n",
+    "            box.Delete();\n",
+    "\n",
+    "        // Create a new rectangle\n",
+    "        string boxName = \"MidnightBox_\" + IntegerToString(dt.day);\n",
+    "        if(!box.Create(0, boxName, 0, 0, 0))\n",
+    "        {\n",
+    "            Print(\"Failed to create box!\");\n",
+    "            return(prev_calculated);\n",
+    "        }\n",
+    "\n",
+    "        // Set rectangle properties\n",
+    "        box.SetInteger(OBJPROP_COLOR, BoxColor);\n",
+    "        box.SetInteger(OBJPROP_WIDTH, BoxWidth);\n",
+    "        box.SetInteger(OBJPROP_STYLE, STYLE_SOLID);\n",
+    "        box.SetInteger(OBJPROP_RAY_RIGHT, false);\n",
+    "\n",
+    "        // Set coordinates: start from the current bar, extend to the right\n",
+    "        int startBar = 0;\n",
+    "        int endBar = MathMin(rates_total - 1, startBar + ExtendBars);\n",
+    "\n",
+    "        box.SetInteger(OBJPROP_TIME1, iTime(_Symbol, PERIOD_CURRENT, startBar));\n",
+    "        box.SetDouble(OBJPROP_PRICE1, barHigh);\n",
+    "\n",
+    "        box.SetInteger(OBJPROP_TIME2, iTime(_Symbol, PERIOD_CURRENT, endBar));\n",
+    "        box.SetDouble(OBJPROP_PRICE2, barLow);\n",
+    "    }\n",
+    "\n",
+    "    return(rates_total);\n",
+    "}\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

MQL5 Folder/Revised 0-3/1_latestbest.mq5 ADDED Viewed

	@@ -0,0 +1,256 @@

+#property strict
+#include <Trade/Trade.mqh>
+CTrade trade;
+// =====================
+// INPUTS
+// =====================
+input double RiskPercent = 1.0;   // 1% risk per trade
+input int    TimerSec    = 5;     // timer interval in seconds
+// =====================
+// GLOBALS
+// =====================
+string   TradeSymbol;
+datetime lastEntryBarTime   = 0; // track last original entry bar
+datetime lastTrailBarTime   = 0; // track last trailing bar
+bool     originalEntryDone  = false; // flag for original entry per day
+bool     reverseEntryDone   = false; // flag for reverse entry per day
+long     originalEntryType  = -1;    // POSITION_TYPE_BUY or POSITION_TYPE_SELL
+double   initialSL          = 0.0;   // store initial SL
+// =====================
+// INIT
+// =====================
+int OnInit()
+{
+    TradeSymbol = _Symbol;
+    if(!SymbolSelect(TradeSymbol, true))
+        return INIT_FAILED;
+    EventSetTimer(TimerSec);
+    return INIT_SUCCEEDED;
+}
+// =====================
+void OnDeinit(const int reason)
+{
+    EventKillTimer();
+}
+// =====================
+void OnTimer()
+{
+    ResetFlags();      // reset daily flags if new day
+    HandleEntry();
+    HandleReverseEntry();
+    HandleTrailing();
+}
+// ============================================================
+// ORIGINAL ENTRY LOGIC
+// ============================================================
+void HandleEntry()
+{
+    if(PositionSelect(TradeSymbol) || originalEntryDone)
+        return;
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastEntryBarTime)
+        return;
+    lastEntryBarTime = barTime;
+    MqlDateTime t;
+    TimeToStruct(barTime, t);
+    if(t.hour != 0) // only 0:00–3:00 H3 candle
+        return;
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    trade.SetDeviationInPoints(20);
+    trade.SetTypeFillingBySymbol(TradeSymbol);
+    // ---------------- BUY ----------------
+    if(close > open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+        double sl    = low;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Buy(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_BUY;
+            }
+        }
+    }
+    // ---------------- SELL ----------------
+    if(close < open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+        double sl    = high;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Sell(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_SELL;
+            }
+        }
+    }
+}
+// ============================================================
+// REVERSE ENTRY LOGIC (TRIGGERED ON STOPLOSS HIT)
+// ============================================================
+void HandleReverseEntry()
+{
+    if(reverseEntryDone || !originalEntryDone)
+        return;
+    if(!PositionSelect(TradeSymbol))
+    {
+        // Original trade was BUY
+        if(originalEntryType == POSITION_TYPE_BUY)
+        {
+            // Check if stoploss was hit in negative profit
+            double ask = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+            if(initialSL > 0 && ask <= initialSL) // original BUY SL hit
+            {
+                // Reverse SELL
+                double prevHigh = iHigh(TradeSymbol, PERIOD_H3, 2); // previous H3 candle
+                double vol = CalculateRiskVolume(ask, prevHigh);
+                if(vol > 0)
+                {
+                    if(trade.Sell(vol, TradeSymbol, ask, prevHigh, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+        // Original trade was SELL
+        if(originalEntryType == POSITION_TYPE_SELL)
+        {
+            // Check if stoploss was hit in negative profit
+            double bid = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+            if(initialSL > 0 && bid >= initialSL) // original SELL SL hit
+            {
+                // Reverse BUY
+                double prevLow = iLow(TradeSymbol, PERIOD_H3, 2); // previous H3 candle
+                double vol = CalculateRiskVolume(bid, prevLow);
+                if(vol > 0)
+                {
+                    if(trade.Buy(vol, TradeSymbol, bid, prevLow, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+    }
+}
+// ============================================================
+// TRAILING LOGIC (STRICT CLOSED H3 CANDLES ONLY)
+// ============================================================
+void HandleTrailing()
+{
+    if(!PositionSelect(TradeSymbol))
+        return;
+    // Use last closed H3 candle only (index 1)
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastTrailBarTime)
+        return;
+    lastTrailBarTime = barTime;
+    long type = PositionGetInteger(POSITION_TYPE);
+    double currentSL = PositionGetDouble(POSITION_SL);
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    // ---------------- BUY ----------------
+    if(type == POSITION_TYPE_BUY)
+    {
+        if(close > open && low > currentSL)
+            trade.PositionModify(TradeSymbol, low, 0.0);
+    }
+    // ---------------- SELL ----------------
+    if(type == POSITION_TYPE_SELL)
+    {
+        if(close < open && high < currentSL)
+            trade.PositionModify(TradeSymbol, high, 0.0);
+    }
+}
+// ============================================================
+// RISK-BASED LOT CALCULATION
+// ============================================================
+double CalculateRiskVolume(double entry, double stop)
+{
+    double distance = MathAbs(entry - stop);
+    if(distance <= 0)
+        return 0;
+    // spread x 10 rule
+    int spread_points = (int)SymbolInfoInteger(TradeSymbol, SYMBOL_SPREAD);
+    double spread     = spread_points * SymbolInfoDouble(TradeSymbol, SYMBOL_POINT);
+    if(distance < spread * 10)
+        return 0;
+    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+    double riskAmt = balance * (RiskPercent / 100.0);
+    double tickSize  = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_SIZE);
+    double tickValue = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_VALUE);
+    double costPerLot = (distance / tickSize) * tickValue;
+    if(costPerLot <= 0)
+        return 0;
+    double volume = riskAmt / costPerLot;
+    double minLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MIN);
+    double maxLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MAX);
+    double stepLot = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_STEP);
+    volume = MathFloor(volume / stepLot) * stepLot;
+    volume = MathMax(volume, minLot);
+    volume = MathMin(volume, maxLot);
+    return volume;
+}
+// ============================================================
+// DAILY RESET OF FLAGS
+// ============================================================
+void ResetFlags()
+{
+    static datetime lastResetTime = 0;
+    datetime now = TimeCurrent();
+    MqlDateTime t;
+    TimeToStruct(now, t);
+    // Reset once per day at 0:00 H3 candle
+    if(t.hour == 0 && lastResetTime < now - 3600)
+    {
+        originalEntryDone = false;
+        reverseEntryDone  = false;
+        initialSL         = 0.0;
+        originalEntryType = -1;
+        lastResetTime = now;
+    }
+}

MQL5 Folder/Revised 0-3/2_latestbest.mq5 ADDED Viewed

	@@ -0,0 +1,262 @@

+#property strict
+#include <Trade/Trade.mqh>
+CTrade trade;
+// =====================
+// INPUTS
+// =====================
+input double RiskPercent = 1.0;   // 1% risk per trade
+input int    TimerSec    = 5;     // timer interval in seconds
+// =====================
+// GLOBALS
+// =====================
+string   TradeSymbol;
+datetime lastEntryBarTime   = 0; // track last original entry bar
+datetime lastTrailBarTime   = 0; // track last trailing bar
+bool     originalEntryDone  = false; // flag for original entry per day
+bool     reverseEntryDone   = false; // flag for reverse entry per day
+long     originalEntryType  = -1;    // POSITION_TYPE_BUY or POSITION_TYPE_SELL
+double   initialSL          = 0.0;   // store initial SL
+// =====================
+// INIT
+// =====================
+int OnInit()
+{
+    TradeSymbol = _Symbol;
+    if(!SymbolSelect(TradeSymbol, true))
+        return INIT_FAILED;
+    EventSetTimer(TimerSec);
+    return INIT_SUCCEEDED;
+}
+// =====================
+void OnDeinit(const int reason)
+{
+    EventKillTimer();
+}
+// =====================
+void OnTimer()
+{
+    ResetFlags();      // reset daily flags if new day
+    HandleEntry();
+    HandleReverseEntry();
+    HandleTrailing();
+}
+// ============================================================
+// ORIGINAL ENTRY LOGIC
+// ============================================================
+void HandleEntry()
+{
+    if(PositionSelect(TradeSymbol) || originalEntryDone)
+        return;
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastEntryBarTime)
+        return;
+    lastEntryBarTime = barTime;
+    MqlDateTime t;
+    TimeToStruct(barTime, t);
+    if(t.hour != 0) // only 0:00–3:00 H3 candle
+        return;
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    trade.SetDeviationInPoints(20);
+    trade.SetTypeFillingBySymbol(TradeSymbol);
+    // ---------------- BUY ----------------
+    if(close > open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+        double sl    = low;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Buy(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_BUY;
+            }
+        }
+    }
+    // ---------------- SELL ----------------
+    if(close < open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+        double sl    = high;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Sell(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_SELL;
+            }
+        }
+    }
+}
+// ============================================================
+// REVERSE ENTRY LOGIC (TRIGGERED ON STOPLOSS HIT, SL BASED ON PREV CANDLE)
+// ============================================================
+void HandleReverseEntry()
+{
+    if(reverseEntryDone || !originalEntryDone)
+        return;
+    if(!PositionSelect(TradeSymbol))
+    {
+        // Current H3 candle (position = 0)
+        double open0  = iOpen(TradeSymbol, PERIOD_H3, 0);
+        double close0 = iClose(TradeSymbol, PERIOD_H3, 0);
+        double low0   = iLow(TradeSymbol, PERIOD_H3, 0);
+        double high0  = iHigh(TradeSymbol, PERIOD_H3, 0);
+        // Previous candle (position = -1)
+        double lowPrev  = iLow(TradeSymbol, PERIOD_H3, 1);
+        double highPrev = iHigh(TradeSymbol, PERIOD_H3, 1);
+        // Original trade was BUY → Reverse SELL
+        if(originalEntryType == POSITION_TYPE_BUY)
+        {
+            double bid = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+            if(initialSL > 0 && bid <= initialSL) // original BUY SL hit
+            {
+                double sl = highPrev; // SL of reverse SELL = high of previous candle
+                double vol = CalculateRiskVolume(bid, sl);
+                if(vol > 0)
+                {
+                    if(trade.Sell(vol, TradeSymbol, bid, sl, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+        // Original trade was SELL → Reverse BUY
+        if(originalEntryType == POSITION_TYPE_SELL)
+        {
+            double ask = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+            if(initialSL > 0 && ask >= initialSL) // original SELL SL hit
+            {
+                double sl = lowPrev; // SL of reverse BUY = low of previous candle
+                double vol = CalculateRiskVolume(ask, sl);
+                if(vol > 0)
+                {
+                    if(trade.Buy(vol, TradeSymbol, ask, sl, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+    }
+}
+// ============================================================
+// TRAILING LOGIC (STRICT CLOSED H3 CANDLES ONLY)
+// ============================================================
+void HandleTrailing()
+{
+    if(!PositionSelect(TradeSymbol))
+        return;
+    // Use last closed H3 candle only (index 1)
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastTrailBarTime)
+        return;
+    lastTrailBarTime = barTime;
+    long type = PositionGetInteger(POSITION_TYPE);
+    double currentSL = PositionGetDouble(POSITION_SL);
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    // ---------------- BUY ----------------
+    if(type == POSITION_TYPE_BUY)
+    {
+        if(close > open && low > currentSL)
+            trade.PositionModify(TradeSymbol, low, 0.0);
+    }
+    // ---------------- SELL ----------------
+    if(type == POSITION_TYPE_SELL)
+    {
+        if(close < open && high < currentSL)
+            trade.PositionModify(TradeSymbol, high, 0.0);
+    }
+}
+// ============================================================
+// RISK-BASED LOT CALCULATION
+// ============================================================
+double CalculateRiskVolume(double entry, double stop)
+{
+    double distance = MathAbs(entry - stop);
+    if(distance <= 0)
+        return 0;
+    // spread x 10 rule
+    int spread_points = (int)SymbolInfoInteger(TradeSymbol, SYMBOL_SPREAD);
+    double spread     = spread_points * SymbolInfoDouble(TradeSymbol, SYMBOL_POINT);
+    if(distance < spread * 10)
+        return 0;
+    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+    double riskAmt = balance * (RiskPercent / 100.0);
+    double tickSize  = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_SIZE);
+    double tickValue = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_VALUE);
+    double costPerLot = (distance / tickSize) * tickValue;
+    if(costPerLot <= 0)
+        return 0;
+    double volume = riskAmt / costPerLot;
+    double minLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MIN);
+    double maxLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MAX);
+    double stepLot = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_STEP);
+    volume = MathFloor(volume / stepLot) * stepLot;
+    volume = MathMax(volume, minLot);
+    volume = MathMin(volume, maxLot);
+    return volume;
+}
+// ============================================================
+// DAILY RESET OF FLAGS
+// ============================================================
+void ResetFlags()
+{
+    static datetime lastResetTime = 0;
+    datetime now = TimeCurrent();
+    MqlDateTime t;
+    TimeToStruct(now, t);
+    // Reset once per day at 0:00 H3 candle
+    if(t.hour == 0 && lastResetTime < now - 3600)
+    {
+        originalEntryDone = false;
+        reverseEntryDone  = false;
+        initialSL         = 0.0;
+        originalEntryType = -1;
+        lastResetTime = now;
+    }
+}

MQL5 Folder/Revised 0-3/3_latestbest.mw5 ADDED Viewed

	@@ -0,0 +1,297 @@

+#property strict
+#include <Trade/Trade.mqh>
+CTrade trade;
+// =====================
+// INPUTS
+// =====================
+input double RiskPercent = 1.0;   // 1% risk per trade
+input int    TimerSec    = 5;     // timer interval in seconds
+// =====================
+// GLOBALS
+// =====================
+string   TradeSymbol;
+datetime lastEntryBarTime   = 0; // track last original entry bar
+datetime lastTrailBarTime   = 0; // track last trailing bar
+bool     originalEntryDone  = false; // flag for original entry per day
+bool     originalEntryLoss  = false; // true if original entry closed at loss
+bool     reverseEntryDone   = false; // flag for reverse entry per day
+long     originalEntryType  = -1;    // POSITION_TYPE_BUY or POSITION_TYPE_SELL
+double   initialSL          = 0.0;   // store initial SL
+ulong    originalTicket     = 0;     // ticket of original entry
+// =====================
+// INIT
+// =====================
+int OnInit()
+{
+    TradeSymbol = _Symbol;
+    if(!SymbolSelect(TradeSymbol, true))
+        return INIT_FAILED;
+    EventSetTimer(TimerSec);
+    return INIT_SUCCEEDED;
+}
+// =====================
+void OnDeinit(const int reason)
+{
+    EventKillTimer();
+}
+// =====================
+void OnTimer()
+{
+    ResetFlags();      // reset daily flags if new day
+    HandleEntry();
+    HandleReverseEntry();
+    HandleTrailing();
+    CheckOriginalTradeProfit();
+}
+// ============================================================
+// ORIGINAL ENTRY LOGIC
+// ============================================================
+void HandleEntry()
+{
+    if(PositionSelect(TradeSymbol) || originalEntryDone)
+        return;
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastEntryBarTime)
+        return;
+    lastEntryBarTime = barTime;
+    MqlDateTime t;
+    TimeToStruct(barTime, t);
+    if(t.hour != 0) // only 0:00–3:00 H3 candle
+        return;
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    trade.SetDeviationInPoints(20);
+    trade.SetTypeFillingBySymbol(TradeSymbol);
+    // ---------------- BUY ----------------
+    if(close > open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+        double sl    = low;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Buy(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_BUY;
+                originalTicket = trade.ResultOrder(); // store ticket
+            }
+        }
+    }
+    // ---------------- SELL ----------------
+    if(close < open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+        double sl    = high;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Sell(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_SELL;
+                originalTicket = trade.ResultOrder(); // store ticket
+            }
+        }
+    }
+}
+// ============================================================
+// CHECK IF ORIGINAL TRADE CLOSED IN LOSS OR PROFIT
+// ============================================================
+void CheckOriginalTradeProfit()
+{
+    if(!originalEntryDone || originalTicket == 0)
+        return;
+    // Check if original trade exists
+    if(!PositionSelect(TradeSymbol))
+        return;
+    long type = PositionGetInteger(POSITION_TYPE);
+    double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
+    double closePrice = PositionGetDouble(POSITION_PRICE_CURRENT);
+    double profit = 0.0;
+    if(type == POSITION_TYPE_BUY)
+        profit = closePrice - openPrice;
+    else if(type == POSITION_TYPE_SELL)
+        profit = openPrice - closePrice;
+    if(profit > 0)
+        originalEntryLoss = false; // profitable → reverse-entry disabled
+    else
+        originalEntryLoss = true;  // loss → reverse-entry possible
+}
+// ============================================================
+// REVERSE ENTRY LOGIC (TRIGGERED ON LOSS, SL BASED ON PREV CANDLE)
+// ============================================================
+void HandleReverseEntry()
+{
+    if(reverseEntryDone || !originalEntryDone || !originalEntryLoss)
+        return;
+    if(!PositionSelect(TradeSymbol))
+    {
+        // Current H3 candle (position = 0)
+        double open0  = iOpen(TradeSymbol, PERIOD_H3, 0);
+        double close0 = iClose(TradeSymbol, PERIOD_H3, 0);
+        double low0   = iLow(TradeSymbol, PERIOD_H3, 0);
+        double high0  = iHigh(TradeSymbol, PERIOD_H3, 0);
+        // Previous candle (position = -1)
+        double lowPrev  = iLow(TradeSymbol, PERIOD_H3, 1);
+        double highPrev = iHigh(TradeSymbol, PERIOD_H3, 1);
+        // Original trade was BUY → Reverse SELL
+        if(originalEntryType == POSITION_TYPE_BUY)
+        {
+            double bid = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+            if(initialSL > 0 && bid <= initialSL) // original BUY SL hit
+            {
+                double sl = highPrev; // SL of reverse SELL = high of previous candle
+                double vol = CalculateRiskVolume(bid, sl);
+                if(vol > 0)
+                {
+                    if(trade.Sell(vol, TradeSymbol, bid, sl, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+        // Original trade was SELL → Reverse BUY
+        if(originalEntryType == POSITION_TYPE_SELL)
+        {
+            double ask = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+            if(initialSL > 0 && ask >= initialSL) // original SELL SL hit
+            {
+                double sl = lowPrev; // SL of reverse BUY = low of previous candle
+                double vol = CalculateRiskVolume(ask, sl);
+                if(vol > 0)
+                {
+                    if(trade.Buy(vol, TradeSymbol, ask, sl, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+    }
+}
+// ============================================================
+// TRAILING LOGIC (STRICT CLOSED H3 CANDLES ONLY)
+// ============================================================
+void HandleTrailing()
+{
+    if(!PositionSelect(TradeSymbol))
+        return;
+    // Use last closed H3 candle only (index 1)
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastTrailBarTime)
+        return;
+    lastTrailBarTime = barTime;
+    long type = PositionGetInteger(POSITION_TYPE);
+    double currentSL = PositionGetDouble(POSITION_SL);
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    // ---------------- BUY ----------------
+    if(type == POSITION_TYPE_BUY)
+    {
+        if(close > open && low > currentSL)
+            trade.PositionModify(TradeSymbol, low, 0.0);
+    }
+    // ---------------- SELL ----------------
+    if(type == POSITION_TYPE_SELL)
+    {
+        if(close < open && high < currentSL)
+            trade.PositionModify(TradeSymbol, high, 0.0);
+    }
+}
+// ============================================================
+// RISK-BASED LOT CALCULATION
+// ============================================================
+double CalculateRiskVolume(double entry, double stop)
+{
+    double distance = MathAbs(entry - stop);
+    if(distance <= 0)
+        return 0;
+    // spread x 10 rule
+    int spread_points = (int)SymbolInfoInteger(TradeSymbol, SYMBOL_SPREAD);
+    double spread     = spread_points * SymbolInfoDouble(TradeSymbol, SYMBOL_POINT);
+    if(distance < spread * 10)
+        return 0;
+    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+    double riskAmt = balance * (RiskPercent / 100.0);
+    double tickSize  = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_SIZE);
+    double tickValue = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_VALUE);
+    double costPerLot = (distance / tickSize) * tickValue;
+    if(costPerLot <= 0)
+        return 0;
+    double volume = riskAmt / costPerLot;
+    double minLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MIN);
+    double maxLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MAX);
+    double stepLot = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_STEP);
+    volume = MathFloor(volume / stepLot) * stepLot;
+    volume = MathMax(volume, minLot);
+    volume = MathMin(volume, maxLot);
+    return volume;
+}
+// ============================================================
+// DAILY RESET OF FLAGS
+// ============================================================
+void ResetFlags()
+{
+    static datetime lastResetTime = 0;
+    datetime now = TimeCurrent();
+    MqlDateTime t;
+    TimeToStruct(now, t);
+    // Reset once per day at 0:00 H3 candle
+    if(t.hour == 0 && lastResetTime < now - 3600)
+    {
+        originalEntryDone = false;
+        originalEntryLoss = false;
+        reverseEntryDone  = false;
+        initialSL         = 0.0;
+        originalEntryType = -1;
+        originalTicket    = 0;
+        lastResetTime = now;
+    }
+}

MQL5 Folder/Revised 0-3/4_latestbest.mq5 ADDED Viewed

	@@ -0,0 +1,294 @@

+#property strict
+#include <Trade/Trade.mqh>
+CTrade trade;
+// =====================
+// INPUTS
+// =====================
+input double RiskPercent = 1.0;   // 1% risk per trade
+input int    TimerSec    = 5;     // timer interval in seconds
+// =====================
+// GLOBALS
+// =====================
+string   TradeSymbol;
+datetime lastEntryBarTime   = 0; // track last original entry bar
+datetime lastTrailBarTime   = 0; // track last trailing bar
+bool     originalEntryDone  = false; // flag for original entry per day
+bool     originalEntryLoss  = false; // true if original entry closed at loss
+bool     reverseEntryDone   = false; // flag for reverse entry per day
+long     originalEntryType  = -1;    // POSITION_TYPE_BUY or POSITION_TYPE_SELL
+double   initialSL          = 0.0;   // store initial SL
+ulong    originalTicket     = 0;     // ticket of original entry
+// =====================
+// INIT
+// =====================
+int OnInit()
+{
+    TradeSymbol = _Symbol;
+    if(!SymbolSelect(TradeSymbol, true))
+        return INIT_FAILED;
+    EventSetTimer(TimerSec);
+    return INIT_SUCCEEDED;
+}
+// =====================
+void OnDeinit(const int reason)
+{
+    EventKillTimer();
+}
+// =====================
+void OnTimer()
+{
+    ResetFlags();      // reset daily flags if new day
+    HandleEntry();
+    HandleReverseEntry();
+    HandleTrailing();
+    CheckOriginalTradeProfit();
+}
+// ============================================================
+// ORIGINAL ENTRY LOGIC
+// ============================================================
+void HandleEntry()
+{
+    if(PositionSelect(TradeSymbol) || originalEntryDone)
+        return;
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastEntryBarTime)
+        return;
+    lastEntryBarTime = barTime;
+    MqlDateTime t;
+    TimeToStruct(barTime, t);
+    if(t.hour != 0) // only 0:00–3:00 H3 candle
+        return;
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    trade.SetDeviationInPoints(20);
+    trade.SetTypeFillingBySymbol(TradeSymbol);
+    // ---------------- BUY ----------------
+    if(close > open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+        double sl    = low;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Buy(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_BUY;
+                originalTicket = trade.ResultOrder(); // store ticket
+            }
+        }
+    }
+    // ---------------- SELL ----------------
+    if(close < open)
+    {
+        double entry = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+        double sl    = high;
+        double vol   = CalculateRiskVolume(entry, sl);
+        if(vol > 0)
+        {
+            if(trade.Sell(vol, TradeSymbol, entry, sl, 0.0))
+            {
+                initialSL = sl;
+                originalEntryDone = true;
+                originalEntryType = POSITION_TYPE_SELL;
+                originalTicket = trade.ResultOrder(); // store ticket
+            }
+        }
+    }
+}
+// ============================================================
+// CHECK IF ORIGINAL TRADE CLOSED IN LOSS OR PROFIT
+// ============================================================
+void CheckOriginalTradeProfit()
+{
+    if(!originalEntryDone || originalTicket == 0)
+        return;
+    // Check if original trade exists
+    if(!PositionSelect(TradeSymbol))
+        return;
+    long type = PositionGetInteger(POSITION_TYPE);
+    double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
+    double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
+    double profit = 0.0;
+    if(type == POSITION_TYPE_BUY)
+        profit = currentPrice - openPrice;
+    else if(type == POSITION_TYPE_SELL)
+        profit = openPrice - currentPrice;
+    if(profit > 0)
+        originalEntryLoss = false; // profitable → reverse-entry disabled
+    else
+        originalEntryLoss = true;  // loss → reverse-entry possible
+}
+// ============================================================
+// REVERSE ENTRY LOGIC (IMMEDIATE ON LOSS, SL FROM PREVIOUS CANDLE)
+// ============================================================
+void HandleReverseEntry()
+{
+    if(reverseEntryDone || !originalEntryDone || !originalEntryLoss)
+        return;
+    if(!PositionSelect(TradeSymbol))
+    {
+        // Current H3 candle (position = 0)
+        double open0  = iOpen(TradeSymbol, PERIOD_H3, 0);
+        double close0 = iClose(TradeSymbol, PERIOD_H3, 0);
+        double low0   = iLow(TradeSymbol, PERIOD_H3, 0);
+        double high0  = iHigh(TradeSymbol, PERIOD_H3, 0);
+        // Previous candle (position = -1)
+        double lowPrev  = iLow(TradeSymbol, PERIOD_H3, 1);
+        double highPrev = iHigh(TradeSymbol, PERIOD_H3, 1);
+        // Original trade was BUY → Reverse SELL
+        if(originalEntryType == POSITION_TYPE_BUY)
+        {
+            double bid = SymbolInfoDouble(TradeSymbol, SYMBOL_BID);
+            if(initialSL > 0 && bid <= initialSL) // original BUY SL hit in negative profit
+            {
+                double sl = highPrev; // SL of reverse SELL = high of previous candle
+                double vol = CalculateRiskVolume(bid, sl);
+                if(vol > 0)
+                {
+                    if(trade.Sell(vol, TradeSymbol, bid, sl, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+        // Original trade was SELL → Reverse BUY
+        if(originalEntryType == POSITION_TYPE_SELL)
+        {
+            double ask = SymbolInfoDouble(TradeSymbol, SYMBOL_ASK);
+            if(initialSL > 0 && ask >= initialSL) // original SELL SL hit in negative profit
+            {
+                double sl = lowPrev; // SL of reverse BUY = low of previous candle
+                double vol = CalculateRiskVolume(ask, sl);
+                if(vol > 0)
+                {
+                    if(trade.Buy(vol, TradeSymbol, ask, sl, 0.0))
+                        reverseEntryDone = true;
+                }
+            }
+        }
+    }
+}
+// ============================================================
+// TRAILING LOGIC (STRICT CLOSED H3 CANDLES ONLY)
+// ============================================================
+void HandleTrailing()
+{
+    if(!PositionSelect(TradeSymbol))
+        return;
+    datetime barTime = iTime(TradeSymbol, PERIOD_H3, 1);
+    if(barTime == 0 || barTime == lastTrailBarTime)
+        return;
+    lastTrailBarTime = barTime;
+    long type = PositionGetInteger(POSITION_TYPE);
+    double currentSL = PositionGetDouble(POSITION_SL);
+    double open  = iOpen(TradeSymbol, PERIOD_H3, 1);
+    double close = iClose(TradeSymbol, PERIOD_H3, 1);
+    double low   = iLow(TradeSymbol, PERIOD_H3, 1);
+    double high  = iHigh(TradeSymbol, PERIOD_H3, 1);
+    // ---------------- BUY ----------------
+    if(type == POSITION_TYPE_BUY)
+    {
+        if(close > open && low > currentSL)
+            trade.PositionModify(TradeSymbol, low, 0.0);
+    }
+    // ---------------- SELL ----------------
+    if(type == POSITION_TYPE_SELL)
+    {
+        if(close < open && high < currentSL)
+            trade.PositionModify(TradeSymbol, high, 0.0);
+    }
+}
+// ============================================================
+// RISK-BASED LOT CALCULATION
+// ============================================================
+double CalculateRiskVolume(double entry, double stop)
+{
+    double distance = MathAbs(entry - stop);
+    if(distance <= 0)
+        return 0;
+    int spread_points = (int)SymbolInfoInteger(TradeSymbol, SYMBOL_SPREAD);
+    double spread     = spread_points * SymbolInfoDouble(TradeSymbol, SYMBOL_POINT);
+    if(distance < spread * 10)
+        return 0;
+    double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+    double riskAmt = balance * (RiskPercent / 100.0);
+    double tickSize  = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_SIZE);
+    double tickValue = SymbolInfoDouble(TradeSymbol, SYMBOL_TRADE_TICK_VALUE);
+    double costPerLot = (distance / tickSize) * tickValue;
+    if(costPerLot <= 0)
+        return 0;
+    double volume = riskAmt / costPerLot;
+    double minLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MIN);
+    double maxLot  = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_MAX);
+    double stepLot = SymbolInfoDouble(TradeSymbol, SYMBOL_VOLUME_STEP);
+    volume = MathFloor(volume / stepLot) * stepLot;
+    volume = MathMax(volume, minLot);
+    volume = MathMin(volume, maxLot);
+    return volume;
+}
+// ============================================================
+// DAILY RESET OF FLAGS
+// ============================================================
+void ResetFlags()
+{
+    static datetime lastResetTime = 0;
+    datetime now = TimeCurrent();
+    MqlDateTime t;
+    TimeToStruct(now, t);
+    if(t.hour == 0 && lastResetTime < now - 3600)
+    {
+        originalEntryDone = false;
+        originalEntryLoss = false;
+        reverseEntryDone  = false;
+        initialSL         = 0.0;
+        originalEntryType = -1;
+        originalTicket    = 0;
+        lastResetTime = now;
+    }
+}

MQL5 Folder/Revised 0-3/revised from very begining.ipynb ADDED Viewed

The diff for this file is too large to render. See raw diff