сам код:
//+------------------------------------------------------------------+
//| SmartProEA.mq5 |
//| Adaptive Multi-Symbol EA with Risk Management |
//+------------------------------------------------------------------+
#property copyright «Copyright 2023, Forex Expert»
#property version «2.00»

//--- Input Parameters
input double RiskPercent = 1.0; // Risk per trade (%)
input int StopLoss = 150; // Stop Loss (points)
input int TakeProfit = 300; // Take Profit (points)
input int TrailingStep = 50; // Trailing Step (points)
input int MagicNumber = 9999; // Magic Number
input int FastMAPeriod = 10; // Fast MA Period
input int SlowMAPeriod = 25; // Slow MA Period
input int RSIPeriod = 14; // RSI Period
input double RSIOverbought = 70.0; // RSI Overbought
input double RSIOversold = 30.0; // RSI Oversold
input string SymbolsToTrade = «EURUSD,GBPUSD»; // Trading Symbols
input bool UseTrailingStop = true; // Use Trailing Stop
input bool UseHedgeProtection = false; // Use Hedge Protection

//--- Global Variables
string SymbolArray[];
int FastMAHandle[], SlowMAHandle[], RSIHandle[];
double MinLot[], MaxLot[], LotStep[];

//+------------------------------------------------------------------+
//| Custom functions |
//+------------------------------------------------------------------+
int ArrayIndexOf(const string &array[], const string value)
{
for(int i=0; i<ArraySize(array); i++)
if(array[i] == value) return i;
return -1;
}

string StringTrim(const string str)
//{
// return StringTrimRight(StringTrimLeft(str));
//}

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
// Initialize symbols
ParseSymbols();
int size = ArraySize(SymbolArray);
if(size == 0) return(INIT_PARAMETERS_INCORRECT);
// Initialize indicators for each symbol
ArrayResize(FastMAHandle, size);
ArrayResize(SlowMAHandle, size);
ArrayResize(RSIHandle, size);
ArrayResize(MinLot, size);
ArrayResize(MaxLot, size);
ArrayResize(LotStep, size);

for(int i=0; i<size; i++)
{
SymbolSelect(SymbolArray[i], true);
// Create indicators
FastMAHandle[i] = iMA(SymbolArray[i], PERIOD_CURRENT, FastMAPeriod, 0, MODE_SMA, PRICE_CLOSE);
if(FastMAHandle[i] == INVALID_HANDLE)
{
Print(«Error creating Fast MA for », SymbolArray[i]);
return INIT_FAILED;
}
SlowMAHandle[i] = iMA(SymbolArray[i], PERIOD_CURRENT, SlowMAPeriod, 0, MODE_SMA, PRICE_CLOSE);
if(SlowMAHandle[i] == INVALID_HANDLE)
{
Print(«Error creating Slow MA for », SymbolArray[i]);
return INIT_FAILED;
}
RSIHandle[i] = iRSI(SymbolArray[i], PERIOD_CURRENT, RSIPeriod, PRICE_CLOSE);
if(RSIHandle[i] == INVALID_HANDLE)
{
Print(«Error creating RSI for », SymbolArray[i]);
return INIT_FAILED;
}
// Get lot info
MinLot[i] = SymbolInfoDouble(SymbolArray[i], SYMBOL_VOLUME_MIN);
MaxLot[i] = SymbolInfoDouble(SymbolArray[i], SYMBOL_VOLUME_MAX);
LotStep[i] = SymbolInfoDouble(SymbolArray[i], SYMBOL_VOLUME_STEP);
}
return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
for(int i=0; i<ArraySize(SymbolArray); i++)
{
string symbol = SymbolArray[i];
// Check for existing positions
if(CountPositions(symbol) > 0 && UseTrailingStop)
TrailingStop(symbol);
// Calculate trading signal
int signal = GetTradeSignal(symbol);
// Calculate position size
double lot = CalculateLotSize(symbol);
if(lot <= 0) continue;
// Open position
if(signal != 0) OpenPosition(symbol, signal, lot);
}
}

//+------------------------------------------------------------------+
//| Parse trading symbols from input string |
//+------------------------------------------------------------------+
void ParseSymbols()
{
ushort sep = StringGetCharacter(",",0);
int count = StringSplit(SymbolsToTrade, sep, SymbolArray);
if(count <=0)
{
Print(«No symbols defined»);
return;
}
for(int i=0; i<count; i++)
{
SymbolArray[i] = StringTrim(SymbolArray[i]);
if(!SymbolInfoInteger(SymbolArray[i], SYMBOL_SELECT))
{
Print(«Symbol », SymbolArray[i], " not available");
ArrayRemove(SymbolArray, i, 1);
count--;
i--;
}
}
}

//+------------------------------------------------------------------+
//| Calculate position size with risk management |
//+------------------------------------------------------------------+
double CalculateLotSize(const string symbol)
{
if(StopLoss <= 0)
{
Print(«StopLoss must be >0»);
return 0.0;
}
double balance = AccountInfoDouble(ACCOUNT_BALANCE);
double riskAmount = balance * (RiskPercent / 100.0);
double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
if(tickValue == 0 || point == 0)
{
Print(«Error calculating lot for », symbol);
return 0.0;
}
double lot = riskAmount / (StopLoss * point * tickValue);
return NormalizeLotSize(symbol, lot);
}

//+------------------------------------------------------------------+
//| Normalize lot size |
//+------------------------------------------------------------------+
double NormalizeLotSize(const string symbol, double lot)
{
int index = ArrayIndexOf(SymbolArray, symbol);
if(index == -1) return 0.0;
lot = MathMax(lot, MinLot[index]);
lot = MathMin(lot, MaxLot[index]);
lot = NormalizeDouble(lot / LotStep[index], 0) * LotStep[index];
return lot;
}

//+------------------------------------------------------------------+
//| Generate trading signal |
//+------------------------------------------------------------------+
int GetTradeSignal(const string symbol)
{
int index = ArrayIndexOf(SymbolArray, symbol);
if(index == -1) return 0;

double fastMA[2], slowMA[2], rsi[2];
if(CopyBuffer(FastMAHandle[index], 0, 0, 2, fastMA) != 2) return 0;
if(CopyBuffer(SlowMAHandle[index], 0, 0, 2, slowMA) != 2) return 0;
if(CopyBuffer(RSIHandle[index], 0, 0, 2, rsi) != 2) return 0;

// Bullish signal
if(fastMA[1] > slowMA[1] && rsi[1] < RSIOversold)
return ORDER_TYPE_BUY;

// Bearish signal
if(fastMA[1] < slowMA[1] && rsi[1] > RSIOverbought)
return ORDER_TYPE_SELL;

return 0;
}

//+------------------------------------------------------------------+
//| Open position |
//+------------------------------------------------------------------+
void OpenPosition(const string symbol, const int direction, const double lot)
{
MqlTradeRequest request = {0};
MqlTradeResult result = {0};
request.action = TRADE_ACTION_DEAL;
request.symbol = symbol;
request.volume = lot;
request.type = (ENUM_ORDER_TYPE)direction;
request.price = (direction == ORDER_TYPE_BUY)?
SymbolInfoDouble(symbol, SYMBOL_ASK):
SymbolInfoDouble(symbol, SYMBOL_BID);
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
// Calculate SL/TP
if(StopLoss > 0)
request.sl = (direction == ORDER_TYPE_BUY)?
request.price — StopLoss * point:
request.price + StopLoss * point;
if(TakeProfit > 0)
request.tp = (direction == ORDER_TYPE_BUY)?
request.price + TakeProfit * point:
request.price — TakeProfit * point;
request.deviation = 5;
request.magic = MagicNumber;
if(!OrderSend(request, result))
Print(«OrderSend error: », GetLastError());
}

//+------------------------------------------------------------------+
//| Trailing stop management |
//+------------------------------------------------------------------+
void TrailingStop(const string symbol)
{
double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
for(int i=PositionsTotal()-1; i>=0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket == 0) continue;
if(PositionSelectByTicket(ticket) &&
PositionGetString(POSITION_SYMBOL) == symbol &&
PositionGetInteger(POSITION_MAGIC) == MagicNumber)
{
double currentSL = PositionGetDouble(POSITION_SL);
ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
double newSL = 0.0;
double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
if(type == POSITION_TYPE_BUY)
{
newSL = currentPrice — TrailingStep * point;
if(newSL > currentSL) ModifySL(ticket, newSL);
}
else
{
newSL = currentPrice + TrailingStep * point;
if(newSL < currentSL) ModifySL(ticket, newSL);
}
}
}
}

//+------------------------------------------------------------------+
//| Modify stop loss |
//+------------------------------------------------------------------+
void ModifySL(const ulong ticket, const double sl)
{
MqlTradeRequest request = {0};
MqlTradeResult result = {0};
if(!PositionSelectByTicket(ticket)) return;
request.action = TRADE_ACTION_SLTP;
request.position = ticket;
request.sl = sl;
request.tp = PositionGetDouble(POSITION_TP);
if(!OrderSend(request, result))
Print(«ModifySL error: », GetLastError());
}

//+------------------------------------------------------------------+
//| Count open positions |
//+------------------------------------------------------------------+
int CountPositions(const string symbol)
{
int count = 0;
for(int i=PositionsTotal()-1; i>=0; i--)
{
ulong ticket = PositionGetTicket(i);
if(ticket == 0) continue;
if(PositionSelectByTicket(ticket) &&
PositionGetString(POSITION_SYMBOL) == symbol &&
PositionGetInteger(POSITION_MAGIC) == MagicNumber)
count++;
}
return count;
}
//+------------------------------------------------------------------+

ошибки: