Axiom of volatility development.

DarkerthanDarc · May 15, 2025 at 1:09 AM

LionsWarthogsMillions said:
I genuinely want to see this clown become rich and successful one day as a trader of the market.

I just don't understand or care what he is doing though
More...

It's looking more and more like hè suffered some shrapnel wounds during Service

"Exchange pricing is formed by an algorithm and the assertion that the market is capable of reacting to trading volume, news background, political and economic situation, etc. has no basis.

All key news comes out at the same time and it is the work of the algorithm, the combination of patterns formed by that time by instruments trading that forms both the news background and the political-economic situation in the world, accordingly this information is partially reflected in the trading volume."

Resto · May 15, 2025 at 1:16 AM

My opinion about your successful traders can be read here https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-46
characteristics of my trading systems.
TS "Development of volatility over time"
Does not require any special knowledge.
Usage:
Time frame: special
Trading instruments:
Stock market, futures, indices, crypto exchange instruments, etc.
Efficient for medium-term and long-term trading
Entry-exit error 2-5 days
Allows you to actively reduce - increase your position in medium-term and long-term trading.
can be read here
https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-50
----------------------------------------------------------------------------------------------------
TS "Building a pattern in time"
Does not require any special knowledge
Time frame: any
Trading instruments:
stock market, futures, indices, crypto exchange instruments, etc.
Efficient on any time frame
Entry-exit error: depending on the selected working time frame up to 2 hours.
-------------------------------------------------------------------------------------------------
TS "Cyclicity of the trading instrument"
Does not require any special knowledge
Time frame: any
Trading instruments:
stock market, futures, indices, crypto exchange instruments, etc.
Efficient on any time frame
Entry-exit error: depending on the selected working time frame up to 1 hour
----------------------------------------------------------------------------------------------
The combined use of these trading systems allows you to determine entry and exit points when conducting trading operations with an accuracy of up to a minute and know the duration of the market movement at any time interval.
Each of these systems requires special characteristics of trading terminals.
For example, the TS "Cyclicity of market movement" will not be able to work in the tradingview.com terminal.
Even in the most professional premium version for this trading platform, the history depth for a minute chart is only 40,000 bars, and for a minute chart, the history depth for a monthly interval is more than 43,000 bars
Ninja Trader terminal is not suitable for working with my algorithms at all

I will repeat once again, I will communicate only with professional programmers, idiots who comment on my posts and pretend to be programmers are of no interest to me

Gentlemen, in this post I said that I will conduct public trading and any interested programmer can get access to online trading
https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-37
As you can see, I started trading with $5,000 Thursday at 1:26 AM
You can see the current account status here
https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-68
32 239$ this is not a bad result for this period of time

I suggest you take an interview to gain access to my online trading operations and verify the effectiveness of this trading system.

Gentlemen, I remind you that if your programmer passes my interview, I will pay you as $70,000. The payment will be made to your crypto wallet in any coin of your choice.

I recommend looking at the content on this page
This will be funny

https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-59

https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-62

https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-65

https://www.elitetrader.com/et/threads/axiom-of-volatility-development.384397/page-68

Resto · May 15, 2025 at 1:44 AM

This is my ignore list and as a practicing trader with 20 years of trading experience I can say the following. If you send these people to ignore as I did, then your profit will only increase. Their opinions will give you nothing but losses

I can say with confidence that all of them will not show even 10% of the efficiency that I am showing you in this thread even in a year.

DarkerthanDarc · May 15, 2025 at 1:50 AM

Resto said:
This is my ignore list and as a practicing trader with 20 years of trading experience I can say the following. If you send these people to ignore as I did, then your profit will only increase. Their opinions will give you nothing but losses

I can say with confidence that all of them will not show even 10% of the efficiency that I am showing you in this thread even in a year.
More...

How good is that I'm betting 80% of those people don't even know who this Whacko is

P.S. no @vztrdr ???

LionsWarthogsMillions · May 15, 2025 at 1:53 AM

Resto said:
all of them will not show even 10% of the efficiency that I am showing
More...

High yield hydrogen plutonium refinement trading.
That's the way it should be. That's the way it should be. That's right,,..,.
RestoResto

Resto · May 15, 2025 at 2:27 AM

Gentlemen, this is an example of trading on currency pairs

Here the margin requirements are lower than on crypto and therefore $2000 can be earned in just 5 minutes

Resto · May 15, 2025 at 3:12 AM

Give me at least one reason why I should listen to the opinions of all sorts of idiots if they don't understand anything about my topic.

how can i make money with my trading system no one in the world can repeat

Resto · May 15, 2025 at 3:17 AM

as you can see, if I hadn't fixed the profit, my profit would have evaporated

Conclusion: I know how the market works down to the minute

Resto · May 15, 2025 at 3:45 AM

Gentlemen, have you seen this indicator?

MarkBrown said:
pay the puppy 50k and he will give you the configuration ranges that you need as inputs to optimize your system that i wrote for you bark bark....

//{code below}

```mql5
//+------------------------------------------------------------------+
//| HarmonicPatternsEA.mq5 |
//| Expert Advisor for Harmonic Patterns in MT5 |
//| Detects Gartley, Bat, Butterfly, Crab, Cypher, AB=CD |
//| Credits: Mark Brown |
//+------------------------------------------------------------------+
#property copyright "Mark Brown"
#property link "https://www.markbrown.com"
#property version "1.00"
#property strict

//--- Inputs for Optimization
input int ZigZagDepth = 12; // ZigZag Depth
input int ZigZagDeviation = 5; // ZigZag Deviation
input int ZigZagBackstep = 3; // ZigZag Backstep
input double FibTolerance = 0.05; // Fibonacci ratio tolerance (e.g., 0.05 = 5%)
input double LotSize = 0.1; // Lot size
input int StopLossPoints = 300; // Stop loss in points
input int TakeProfitPoints = 500; // Take profit in points
input bool UseTrailingStop = true; // Use trailing stop
input int TrailingStopPoints = 200; // Trailing stop points
input bool TradeGartley = true; // Enable Gartley pattern
input bool TradeBat = true; // Enable Bat pattern
input bool TradeButterfly = true; // Enable Butterfly pattern
input bool TradeCrab = true; // Enable Crab pattern
input bool TradeCypher = true; // Enable Cypher pattern
input bool TradeABCD = true; // Enable AB=CD pattern

//--- Global Variables
double ZZBuffer[];
int zigZagHandle;
datetime lastBar;

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
// Initialize ZigZag indicator
zigZagHandle = iCustom(_Symbol, PERIOD_CURRENT, "ZigZag", ZigZagDepth, ZigZagDeviation, ZigZagBackstep);
if(zigZagHandle == INVALID_HANDLE)
{
Print("Failed to initialize ZigZag indicator");
return(INIT_FAILED);
}

ArraySetAsSeries(ZZBuffer, true);
return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
IndicatorRelease(zigZagHandle);
}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
// Check for new bar
datetime currentBar = iTime(_Symbol, PERIOD_CURRENT, 0);
if(currentBar == lastBar) return;
lastBar = currentBar;

// Copy ZigZag data
if(CopyBuffer(zigZagHandle, 0, 0, 100, ZZBuffer) <= 0)
{
Print("Failed to copy ZigZag buffer");
return;
}

// Find swing points
double points[5];
int timePoints[5];
int count = 0;
for(int i = 1; i < 100 && count < 5; i++)
{
if(ZZBuffer != 0)
{
points[count] = ZZBuffer;
timePoints[count] = i;
count++;
}
}

// Check for patterns if we have 5 points
if(count == 5)
{
double X = points[4];
double A = points[3];
double B = points[2];
double C = points[1];
double D = points[0];
bool isBullish = (D > B); // Bullish if D is above B

// Detect patterns
string pattern = "";
if(TradeGartley && IsGartleyPattern(X, A, B, C, D))
pattern = "Gartley";
else if(TradeBat && IsBatPattern(X, A, B, C, D))
pattern = "Bat";
else if(TradeButterfly && IsButterflyPattern(X, A, B, C, D))
pattern = "Butterfly";
else if(TradeCrab && IsCrabPattern(X, A, B, C, D))
pattern = "Crab";
else if(TradeCypher && IsCypherPattern(X, A, B, C, D))
pattern = "Cypher";
else if(TradeABCD && IsABCDPattern(X, A, B, C, D))
pattern = "AB=CD";

if(pattern != "")
{
// Draw pattern
DrawPattern(pattern, timePoints, points, isBullish);
// Execute trade
if(PositionsTotal() == 0) // Only trade if no open positions
ExecuteTrade(pattern, isBullish, D);
}
}

// Manage trailing stop
if(UseTrailingStop)
ManageTrailingStop();
}

//+------------------------------------------------------------------+
//| Pattern detection functions |
//+------------------------------------------------------------------+
bool IsGartleyPattern(double X, double A, double B, double C, double D)
{
double XA = MathAbs(A - X);
double AB = MathAbs(B - A);
double BC = MathAbs(C - B);
double CD = MathAbs(D - C);
double AD = MathAbs(D - A);

double AB_XA = AB / XA;
double BC_AB = BC / AB;
double CD_BC = CD / BC;
double AD_XA = AD / XA;

return (AB_XA >= 0.618 - FibTolerance && AB_XA <= 0.618 + FibTolerance &&
BC_AB >= 0.382 - FibTolerance && BC_AB <= 0.886 + FibTolerance &&
CD_BC >= 1.272 - FibTolerance && CD_BC <= 1.618 + FibTolerance &&
AD_XA >= 0.786 - FibTolerance && AD_XA <= 0.786 + FibTolerance);
}

bool IsBatPattern(double X, double A, double B, double C, double D)
{
double XA = MathAbs(A - X);
double AB = MathAbs(B - A);
double BC = MathAbs(C - B);
double CD = MathAbs(D - C);
double AD = MathAbs(D - A);

double AB_XA = AB / XA;
double BC_AB = BC / AB;
double CD_BC = CD / BC;
double AD_XA = AD / XA;

return (AB_XA >= 0.382 - FibTolerance && AB_XA <= 0.50 + FibTolerance &&
BC_AB >= 0.382 - FibTolerance && BC_AB <= 0.886 + FibTolerance &&
CD_BC >= 1.618 - FibTolerance && CD_BC <= 2.618 + FibTolerance &&
AD_XA >= 0.886 - FibTolerance && AD_XA <= 0.886 + FibTolerance);
}

bool IsButterflyPattern(double X, double A, double B, double C, double D)
{
double XA = MathAbs(A - X);
double AB = MathAbs(B - A);
double BC = MathAbs(C - B);
double CD = MathAbs(D - C);
double AD = MathAbs(D - A);

double AB_XA = AB / XA;
double BC_AB = BC / AB;
double CD_BC = CD / BC;
double AD_XA = AD / XA;

return (AB_XA >= 0.786 - FibTolerance && AB_XA <= 0.786 + FibTolerance &&
BC_AB >= 0.382 - FibTolerance && BC_AB <= 0.886 + FibTolerance &&
CD_BC >= 1.618 - FibTolerance && CD_BC <= 2.618 + FibTolerance &&
AD_XA >= 1.272 - FibTolerance && AD_XA <= 1.618 + FibTolerance);
}

bool IsCrabPattern(double X, double A, double B, double C, double D)
{
double XA = MathAbs(A - X);
double AB = MathAbs(B - A);
double BC = MathAbs(C - B);
double CD = MathAbs(D - C);
double AD = MathAbs(D - A);

double AB_XA = AB / XA;
double BC_AB = BC / AB;
double CD_BC = CD / BC;
double AD_XA = AD / XA;

return (AB_XA >= 0.382 - FibTolerance && AB_XA <= 0.618 + FibTolerance &&
BC_AB >= 0.382 - FibTolerance && BC_AB <= 0.886 + FibTolerance &&
CD_BC >= 2.24 - FibTolerance && CD_BC <= 3.618 + FibTolerance &&
AD_XA >= 1.618 - FibTolerance && AD_XA <= 1.618 + FibTolerance);
}

bool IsCypherPattern(double X, double A, double B, double C, double D)
{
double XA = MathAbs(A - X);
double AB = MathAbs(B - A);
double BC = MathAbs(C - B);
double CD = MathAbs(D - C);
double AD = MathAbs(D - A);

double AB_XA = AB / XA;
double BC_AB = BC / AB;
double CD_BC = CD / BC;
double AD_XA = AD / XA;

return (AB_XA >= 0.382 - FibTolerance && AB_XA <= 0.618 + FibTolerance &&
BC_AB >= 1.13 - FibTolerance && BC_AB <= 1.414 + FibTolerance &&
CD_BC >= 1.272 - FibTolerance && CD_BC <= 2.0 + FibTolerance &&
AD_XA >= 0.786 - FibTolerance && AD_XA <= 0.786 + FibTolerance);
}

bool IsABCDPattern(double X, double A, double B, double C, double D)
{
double AB = MathAbs(B - A);
double BC = MathAbs(C - B);
double CD = MathAbs(D - C);

double BC_AB = BC / AB;
double CD_BC = CD / BC;
double CD_AB = CD / AB;

return (BC_AB >= 0.618 - FibTolerance && BC_AB <= 0.786 + FibTolerance &&
CD_BC >= 1.272 - FibTolerance && CD_BC <= 1.618 + FibTolerance &&
MathAbs(CD_AB - 1.0) <= FibTolerance); // AB ≈ CD
}

//+------------------------------------------------------------------+
//| Draw pattern on chart |
//+------------------------------------------------------------------+
void DrawPattern(string pattern, int &timePoints[], double &points[], bool isBullish)
{
string objName = pattern + "_" + TimeToString(TimeCurrent(), TIME_MINUTES);
ObjectCreate(0, objName, OBJ_FIBO, 0, iTime(_Symbol, PERIOD_CURRENT, timePoints[4]), points[4], iTime(_Symbol, PERIOD_CURRENT, timePoints[0]), points[0]);
ObjectSetInteger(0, objName, OBJPROP_COLOR, isBullish ? clrBlue : clrRed);
ObjectSetInteger(0, objName, OBJPROP_STYLE, STYLE_SOLID);
ObjectSetInteger(0, objName, OBJPROP_WIDTH, 2);
ObjectSetString(0, objName, OBJPROP_TEXT, pattern + (isBullish ? " Bullish" : " Bearish"));
}

//+------------------------------------------------------------------+
//| Execute trade |
//+------------------------------------------------------------------+
void ExecuteTrade(string pattern, bool isBullish, double entryPrice)
{
MqlTradeRequest request = {0};
MqlTradeResult result = {0};

request.action = TRADE_ACTION_DEAL;
request.symbol = _Symbol;
request.volume = LotSize;
request.type = isBullish ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
request.price = entryPrice;
request.sl = isBullish ? entryPrice - StopLossPoints * _Point : entryPrice + StopLossPoints * _Point;
request.tp = isBullish ? entryPrice + TakeProfitPoints * _Point : entryPrice - TakeProfitPoints * _Point;
request.deviation = 10;
request.magic = 123456;
request.comment = pattern + " Trade";

if(!OrderSend(request, result))
Print("Trade failed: ", GetLastError());
else
Print("Trade opened: ", pattern, ", ", isBullish ? "Bullish" : "Bearish", " at ", entryPrice);
}

//+------------------------------------------------------------------+
//| Manage trailing stop |
//+------------------------------------------------------------------+
void ManageTrailingStop()
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i);
if(PositionSelectByTicket(ticket))
{
double sl = PositionGetDouble(POSITION_SL);
double tp = PositionGetDouble(POSITION_TP);
double currentPrice = PositionGetDouble(POSITION_TYPE) == POSITION_TYPE_BUY ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double entryPrice = PositionGetDouble(POSITION_PRICE_OPEN);

MqlTradeRequest request = {0};
MqlTradeResult result = {0};

if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
{
double newSL = currentPrice - TrailingStopPoints * _Point;
if(newSL > sl && newSL > entryPrice)
{
request.action = TRADE_ACTION_SLTP;
request.position = ticket;
request.sl = NormalizeDouble(newSL, _Digits);
request.tp = tp;
if(!OrderSend(request, result))
Print("Trailing stop failed: ", GetLastError());
}
}
else // POSITION_TYPE_SELL
{
double newSL = currentPrice + TrailingStopPoints * _Point;
if(newSL < sl && newSL < entryPrice)
{
request.action = TRADE_ACTION_SLTP;
request.position = ticket;
request.sl = NormalizeDouble(newSL, _Digits);
request.tp = tp;
if(!OrderSend(request, result))
Print("Trailing stop failed: ", GetLastError());
}
}
}
}
}
```

// or tradestation - multicharts code below

// Gartley Pattern Strategy for MultiCharts/TradeStation
// Credits: Mark Brown
// Detects Bullish and Bearish Gartley Patterns and Trades Them
// No Reversal Logic Included

[IntrabarOrderGeneration = False];

Inputs:
// Pattern Detection Parameters
LookbackBars(10), // Bars to look back for pivot detection
FibTolerance(0.05), // Fibonacci ratio tolerance (e.g., 0.05 = 5%)
MinPivotStrength(3), // Minimum bars to confirm pivot
// Trading Parameters
PositionSize(1), // Number of contracts
StopLossPoints(300), // Stop loss in points
TakeProfitPoints(500), // Take profit in points
UseTrailingStop(True), // Enable trailing stop
TrailingStopPoints(200), // Trailing stop in points
// Optional Custom Data Fields (from your data)
Jounce(0), // Custom Jounce value (placeholder)
MP(0), // Custom Market Position (placeholder)
BuyFlag(0), // Custom BuyFlag (placeholder)
// Pattern Enable
TradeBullishGartley(True), // Enable bullish Gartley trades
TradeBearishGartley(True); // Enable bearish Gartley trades

Vars:
// Swing Points
X(0), A(0), B(0), C(0), D(0),
XBar(0), ABar(0), BBar(0), CBar(0), DBar(0),
// Position and Trade Tracking
MyPosition(0), // 0: flat, 1: long, -1: short
EntryPrice(0), // Entry price of current position
TotalProfit(0), // Cumulative profit
TradeCount(0), // Number of trades
LastTradeProfit(0), // Profit from last trade
// Trailing Stop
TrailingStopPrice(0),
// Pattern Detection
PatternDetected(False),
IsBullishPattern(False);

// Function to detect high pivot
Define Function HighPivot(BarOffset, Strength) : Double;
Var: i(0), IsPivot(True), PivotPrice(0);
PivotPrice = High[BarOffset];
For i = 1 To Strength Begin
If High[BarOffset + i] >= PivotPrice Or High[BarOffset - i] >= PivotPrice Then
IsPivot = False;
End;
If IsPivot Then
Return PivotPrice
Else
Return 0;
End;

// Function to detect low pivot
Define Function LowPivot(BarOffset, Strength) : Double;
Var: i(0), IsPivot(True), PivotPrice(0);
PivotPrice = Low[BarOffset];
For i = 1 To Strength Begin
If Low[BarOffset + i] <= PivotPrice Or Low[BarOffset - i] <= PivotPrice Then
IsPivot = False;
End;
If IsPivot Then
Return PivotPrice
Else
Return 0;
End;

// Function to check Gartley pattern ratios
Define Function IsGartleyPattern(X, A, B, C, D, IsBullish) : Bool;
Var: XA(0), AB(0), BC(0), CD(0), AD(0), AB_XA(0), BC_AB(0), CD_BC(0), AD_XA(0);
XA = AbsValue(A - X);
AB = AbsValue(B - A);
BC = AbsValue(C - B);
CD = AbsValue(D - C);
AD = AbsValue(D - A);

If XA = 0 Or AB = 0 Or BC = 0 Or CD = 0 Then
Return False;

AB_XA = AB / XA;
BC_AB = BC / AB;
CD_BC = CD / BC;
AD_XA = AD / XA;

Return (
AB_XA >= 0.618 - FibTolerance And AB_XA <= 0.618 + FibTolerance
And BC_AB >= 0.382 - FibTolerance And BC_AB <= 0.886 + FibTolerance
And CD_BC >= 1.272 - FibTolerance And CD_BC <= 1.618 + FibTolerance
And AD_XA >= 0.786 - FibTolerance And AD_XA <= 0.786 + FibTolerance
And ((IsBullish And D > B) Or (Not IsBullish And D < B))
);
End;

// Main Strategy Logic
If BarStatus(1) = 2 Then Begin
// Reset pattern detection
PatternDetected = False;

// Find swing points (X, A, B, C, D)
Var: i(0), PivotCount(0);
X = 0; A = 0; B = 0; C = 0; D = 0;
XBar = 0; ABar = 0; BBar = 0; CBar = 0; DBar = 0;

For i = 0 To LookbackBars - 1 Begin
If PivotCount < 5 Then Begin
If HighPivot(i, MinPivotStrength) <> 0 Then Begin
If PivotCount = 0 Then Begin
D = HighPivot(i, MinPivotStrength);
DBar = i;
End Else If PivotCount = 2 Then Begin
B = HighPivot(i, MinPivotStrength);
BBar = i;
End Else If PivotCount = 4 Then Begin
X = HighPivot(i, MinPivotStrength);
XBar = i;
End;
PivotCount = PivotCount + 1;
End Else If LowPivot(i, MinPivotStrength) <> 0 Then Begin
If PivotCount = 1 Then Begin
C = LowPivot(i, MinPivotStrength);
CBar = i;
End Else If PivotCount = 3 Then Begin
A = LowPivot(i, MinPivotStrength);
ABar = i;
End;
PivotCount = PivotCount + 1;
End;
End;
End;

// Check for Gartley pattern
If PivotCount >= 5 Then Begin
If TradeBullishGartley And IsGartleyPattern(X, A, B, C, D, True) Then Begin
PatternDetected = True;
IsBullishPattern = True;
Print("Bullish Gartley detected at Bar ", CurrentBar, ", D = ", D);
End Else If TradeBearishGartley And IsGartleyPattern(X, A, B, C, D, False) Then Begin
PatternDetected = True;
IsBullishPattern = False;
Print("Bearish Gartley detected at Bar ", CurrentBar, ", D = ", D);
End;
End;

// Trading Logic
If PatternDetected And MyPosition = 0 Then Begin
If IsBullishPattern Then Begin
Buy ("GartleyLong") PositionSize Contracts Next Bar At D Limit;
MyPosition = 1;
EntryPrice = D;
TradeCount = TradeCount + 1;
TrailingStopPrice = D - TrailingStopPoints * MinMove / PriceScale;
Print("Time: ", Time, ", Buy at ", D);
End Else Begin
SellShort ("GartleyShort") PositionSize Contracts Next Bar At D Limit;
MyPosition = -1;
EntryPrice = D;
TradeCount = TradeCount + 1;
TrailingStopPrice = D + TrailingStopPoints * MinMove / PriceScale;
Print("Time: ", Time, ", Sell Short at ", D);
End;
End;

// Exit Logic
If MyPosition = 1 Then Begin
// Stop Loss
Sell ("LongStop") PositionSize Contracts Next Bar At EntryPrice - StopLossPoints * MinMove / PriceScale Stop;
// Take Profit
Sell ("LongTP") PositionSize Contracts Next Bar At EntryPrice + TakeProfitPoints * MinMove / PriceScale Limit;
// Trailing Stop
If UseTrailingStop And High >= TrailingStopPrice + TrailingStopPoints * MinMove / PriceScale Then
TrailingStopPrice = TrailingStopPrice + TrailingStopPoints * MinMove / PriceScale;
Sell ("LongTrail") PositionSize Contracts Next Bar At TrailingStopPrice Stop;
End Else If MyPosition = -1 Then Begin
// Stop Loss
BuyToCover ("ShortStop") PositionSize Contracts Next Bar At EntryPrice + StopLossPoints * MinMove / PriceScale Stop;
// Take Profit
BuyToCover ("ShortTP") PositionSize Contracts Next Bar At EntryPrice - TakeProfitPoints * MinMove / PriceScale Limit;
// Trailing Stop
If UseTrailingStop And Low <= TrailingStopPrice - TrailingStopPoints * MinMove / PriceScale Then
TrailingStopPrice = TrailingStopPrice - TrailingStopPoints * MinMove / PriceScale;
BuyToCover ("ShortTrail") PositionSize Contracts Next Bar At TrailingStopPrice Stop;
End;

// Position Exit Handling
If MarketPosition <> MyPosition Then Begin
If MyPosition = 1 Then Begin
LastTradeProfit = (Close - EntryPrice) * PositionSize * BigPointValue;
TotalProfit = TotalProfit + LastTradeProfit;
Print("Time: ", Time, ", Exit Long at ", Close, ", Profit: ", LastTradeProfit);
End Else If MyPosition = -1 Then Begin
LastTradeProfit = (EntryPrice - Close) * PositionSize * BigPointValue;
TotalProfit = TotalProfit + LastTradeProfit;
Print("Time: ", Time, ", Exit Short at ", Close, ", Profit: ", LastTradeProfit);
End;
MyPosition = 0;
End;

// Optional: Use Custom Data Fields
If BuyFlag = 1 And MyPosition = 0 And PatternDetected And IsBullishPattern Then Begin
Buy ("BuyFlagLong") PositionSize Contracts Next Bar At Market;
MyPosition = 1;
EntryPrice = Close;
TradeCount = TradeCount + 1;
TrailingStopPrice = Close - TrailingStopPoints * MinMove / PriceScale;
Print("Time: ", Time, ", BuyFlag Entry at ", Close);
End;

// Plot Pattern Points (for visualization)
If PatternDetected Then Begin
Plot1[DBar](D, "PointD", Cyan);
Plot2[CBar](C, "PointC", Yellow);
Plot3[BBar](B, "PointB", Magenta);
Plot4[ABar](A, "PointA", Green);
Plot5[XBar](X, "PointX", Red);
End;

// Output Results
If LastBarOnChart Then Begin
Print("Total Trades: ", TradeCount);
Print("Total Profit: ", TotalProfit);
End;
End;

More...

There are thousands of such codes, and he can shove these codes up his ass, because his work will bring nothing but losses.

Resto · May 15, 2025 at 4:17 AM

You can constantly monitor the market, or you can simply approach the terminal at any time, evaluate the pattern and get such a profit in just 3 minutes.