5621DE9E/mql5
1
0
Fourche 0
bifurqué depuis masterofpuppets/mql5
Code Demandes d'ajout Activité
mql5/Experts/Scalper.mq5
MasterOfPuppets 716a1b7343 correct OnTradeTransaction()
2026-02-11 03:50:34 +03:00

766 lignes
54 Kio
MQL5
Brut Lien permanent Annotations Historique

//+------------------------------------------------------------------+
//| Scalper.mq5 |
//| Copyright 2026, MasterOfPuppets |
//| https://forge.mql5.io/masterofpuppets/mql5 |
//+------------------------------------------------------------------+
#include <Generic\LinkedList.mqh>
#include <Generic\HashMap.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\Trade.mqh>
#property copyright "Copyright 2026, MasterOfPuppets"
#property link "https://forge.mql5.io/masterofpuppets/mql5"
#property version "1.00"
//+------------------------------------------------------------------+
//| Classes |
//+------------------------------------------------------------------+
class Indexes
{
public:
int data[];
Indexes() { ArrayFree(data); }
~Indexes() { ArrayFree(data); }
};
//+------------------------------------------------------------------+
//| Enums |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Key to Action enum |
//| ASCII codes for keys |
//| https://www.w3.org/2002/09/tests/keys.html |
//+------------------------------------------------------------------+
enum Action
{
BUY = 'B',
CLOSE_ALL_POSITIONS = 'Q',
CLOSE_EXPERT_POSITIONS = 'C',
DEFEND_ALL_POSITIONS = 'F',
DEFEND_EXPERT_POSITIONS = 'D',
EXIT_SCALPER = 'E',
REVERSE_ALL_POSITIONS = 'R',
REVERSE_EXPERT_POSITIONS = 'A',
SELL = 'S',
UNKNOWN = -1
};
enum ActionKey
{
A = 'A',
B = 'B',
C = 'C',
D = 'D',
E = 'E',
F = 'F',
G = 'G',
H = 'H',
I = 'I',
J = 'J',
K = 'K',
L = 'L',
M = 'M',
N = 'N',
O = 'O',
P = 'P',
Q = 'Q',
R = 'R',
S = 'S',
T = 'T',
U = 'U',
V = 'V',
W = 'W',
X = 'X',
Y = 'Y',
Z = 'Z',
_1 = '1',
_2 = '2',
_3 = '3',
_4 = '4',
_5 = '5',
_6 = '6',
_7 = '7',
_8 = '8',
_9 = '9',
_0 = '0'
};
//+------------------------------------------------------------------+
//| Inputs |
//+------------------------------------------------------------------+
input double CONTRACTS = 0.01;
input int INDENT_SIZE = 144;
input int LAST_PROFITS_SIZE = 10;
input double STOP_LOSS = 7.0;
input string SOUND_FILE_NAME = "ok.wav";
input double TAKE_PROFIT = 0.0;
input group "Action keys"
input ActionKey buyActionKey = B; // BUY
input ActionKey closeAllPositionsActionKey = Q; // CLOSE_ALL_POSITIONS
input ActionKey closeExpertPositionsActionKey = C; // CLOSE_EXPERT_POSITIONS
input ActionKey defendAllPositionsActionKey = F; // DEFEND_ALL_POSITIONS
input ActionKey defendExpertPositionsActionKey = D; // DEFEND_EXPERT_POSITIONS
input ActionKey exitScalperActionKey = E; // EXIT_SCALPER
input ActionKey reverseAllPositionsActionKey = R; // REVERSE_ALL_POSITIONS
input ActionKey reverseExpertPositionsActionKey = A; // REVERSE_EXPERT_POSITIONS
input ActionKey sellActionKey = S; // SELL
//+------------------------------------------------------------------+
//| Constants |
//+------------------------------------------------------------------+
const string INDENT_FORMAT = StringFormat("%%%is\n", INDENT_SIZE);
const ulong MAGIC = 1234567;
const string MESSAGE_BUY = "BUY ";
const string MESSAGE_SELL = "SELL ";
//+------------------------------------------------------------------+
//| Interfaces |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Modifier interface |
//+------------------------------------------------------------------+
interface Modifier
{
void Modify();
};
//+------------------------------------------------------------------+
//| Structs |
//+------------------------------------------------------------------+
struct LastProfit
{
string message;
double profit;
string suffix;
};
//+------------------------------------------------------------------+
//| Variables |
//+------------------------------------------------------------------+
CHashMap<long, int> actions;
CHashMap<long, string> actionNames;
CHashMap<int, Indexes*> keyToIndexesMap;
string lastProfit;
LastProfit lastProfits[];
CPositionInfo positionInfo;
CSymbolInfo symbolInfo;
double totalLastProfit;
CTrade trade;
//+------------------------------------------------------------------+
//| ChartEvent function |
//+------------------------------------------------------------------+
void OnChartEvent(const int32_t id, const long &lparam, const double &dparam, const string &sparam)
{
if(id != CHARTEVENT_KEYDOWN)
{
return;
}
int action;
actions.TryGetValue(lparam, action);
switch(action)
{
case Action::BUY:
case Action::SELL:
Deal(action);
break;
case Action::CLOSE_ALL_POSITIONS:
CloseAllPositions();
break;
case Action::CLOSE_EXPERT_POSITIONS:
CloseExpertPositions();
break;
case Action::DEFEND_ALL_POSITIONS:
DefendAllPositions();
break;
case Action::DEFEND_EXPERT_POSITIONS:
DefendExpertPositions();
break;
case Action::EXIT_SCALPER:
ExpertRemove();
PlaySound(SOUND_FILE_NAME);
break;
case Action::REVERSE_ALL_POSITIONS:
ReverseAllPositions();
break;
case Action::REVERSE_EXPERT_POSITIONS:
ReverseExpertPositions();
break;
}
}
//+------------------------------------------------------------------+
//| Deal function |
//+------------------------------------------------------------------+
void Deal(int action)
{
ENUM_ORDER_TYPE orderType;
double price;
double deltaStopLoss;
double deltaTakeProfit;
symbolInfo.RefreshRates();
switch(action)
{
case Action::BUY:
orderType = ENUM_ORDER_TYPE::ORDER_TYPE_BUY;
price = symbolInfo.Ask();
deltaStopLoss = -STOP_LOSS;
deltaTakeProfit = TAKE_PROFIT;
break;
case Action::SELL:
orderType = ENUM_ORDER_TYPE::ORDER_TYPE_SELL;
price = symbolInfo.Bid();
deltaStopLoss = STOP_LOSS;
deltaTakeProfit = -TAKE_PROFIT;
break;
default:
return;
}
Print(EnumToString((Action) action));
double stopLoss = IsZero(STOP_LOSS) ? 0.0 : symbolInfo.NormalizePrice(price + deltaStopLoss);
double takeProfit = IsZero(TAKE_PROFIT) ? 0.0 : symbolInfo.NormalizePrice(price + deltaTakeProfit);
trade.PositionOpen(_Symbol, orderType, CONTRACTS, price, stopLoss, takeProfit);
PlaySound(SOUND_FILE_NAME);
}
//+------------------------------------------------------------------+
//| ClosePositionModifier Modifier class |
//+------------------------------------------------------------------+
class ClosePositionModifier : public Modifier
{
private:
bool m_withExpert;
public:
ClosePositionModifier(bool withExpert = false)
{
m_withExpert = withExpert;
}
void Modify()
{
if(m_withExpert && positionInfo.Magic() != MAGIC)
{
return;
}
trade.PositionClose(positionInfo.Ticket());
string message;
switch(positionInfo.PositionType())
{
case ENUM_POSITION_TYPE::POSITION_TYPE_BUY:
message = MESSAGE_BUY;
break;
case ENUM_POSITION_TYPE::POSITION_TYPE_SELL:
message = MESSAGE_SELL;
break;
}
LastProfit lastProfitStruct;
lastProfitStruct.message = message;
lastProfitStruct.profit = positionInfo.Profit();
AddLastProfit(lastProfitStruct);
CalculateTotalLastProfit();
SetLastProfit();
}
};
//+------------------------------------------------------------------+
//| Add last profit function |
//+------------------------------------------------------------------+
void AddLastProfit(LastProfit &lastProfitStruct)
{
if(lastProfits.Size() == LAST_PROFITS_SIZE)
{
ArrayRemove(lastProfits, 0, 1);
}
ArrayResize(lastProfits, lastProfits.Size() + 1);
lastProfits[lastProfits.Size() - 1] = lastProfitStruct;
}
//+------------------------------------------------------------------+
//| Calculate total last profit function |
//+------------------------------------------------------------------+
void CalculateTotalLastProfit()
{
totalLastProfit = 0.0;
for(int i = 0; i < (int) lastProfits.Size(); i++)
{
totalLastProfit += lastProfits[i].profit;
}
}
//+------------------------------------------------------------------+
//| Set last profit function |
//+------------------------------------------------------------------+
void SetLastProfit()
{
lastProfit = "\n";
for(int i = 0; i < (int) lastProfits.Size(); i++)
{
lastProfit += StringFormat(INDENT_FORMAT,
lastProfits[i].message + lastProfits[i].suffix + DoubleToString(lastProfits[i].profit, 2));
}
lastProfit += StringFormat(INDENT_FORMAT, DoubleToString(totalLastProfit, 2));
}
//+------------------------------------------------------------------+
//| Close all positions function |
//+------------------------------------------------------------------+
void CloseAllPositions()
{
ClosePositionModifier closePositionModifier;
Modify(EnumToString(Action::CLOSE_ALL_POSITIONS), &closePositionModifier);
}
//+------------------------------------------------------------------+
//| Close expert positions function |
//+------------------------------------------------------------------+
void CloseExpertPositions()
{
ClosePositionModifier closePositionModifier(true);
Modify(EnumToString(Action::CLOSE_EXPERT_POSITIONS), &closePositionModifier);
}
//+------------------------------------------------------------------+
//| DefendModifier Modifier class |
//+------------------------------------------------------------------+
class DefendModifier : public Modifier
{
private:
bool m_withExpert;
public:
DefendModifier(bool withExpert = false)
{
this.m_withExpert = withExpert;
}
void Modify()
{
if(m_withExpert && positionInfo.Magic() != MAGIC)
{
return;
}
double deltaStopLoss = 0.0;
switch(positionInfo.PositionType())
{
case ENUM_POSITION_TYPE::POSITION_TYPE_BUY:
deltaStopLoss = STOP_LOSS;
break;
case ENUM_POSITION_TYPE::POSITION_TYPE_SELL:
deltaStopLoss = -STOP_LOSS;
break;
}
trade.PositionModify(positionInfo.Ticket(),
symbolInfo.NormalizePrice(positionInfo.StopLoss() + deltaStopLoss),
positionInfo.TakeProfit());
}
};
//+------------------------------------------------------------------+
//| Defend all positions function |
//+------------------------------------------------------------------+
void DefendAllPositions()
{
DefendModifier defendModifier;
Modify(EnumToString(Action::DEFEND_ALL_POSITIONS), &defendModifier);
}
//+------------------------------------------------------------------+
//| Defend expert positions function |
//+------------------------------------------------------------------+
void DefendExpertPositions()
{
DefendModifier defendModifier(true);
Modify(EnumToString(Action::DEFEND_EXPERT_POSITIONS), &defendModifier);
}
//+------------------------------------------------------------------+
//| Modify function |
//+------------------------------------------------------------------+
void Modify(string message, Modifier* modifier)
{
Print(message);
ModifyPositions(modifier);
PlaySound(SOUND_FILE_NAME);
}
//+------------------------------------------------------------------+
//| Modify positions function |
//+------------------------------------------------------------------+
void ModifyPositions(Modifier* modifier)
{
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(positionInfo.SelectByIndex(i))
{
modifier.Modify();
}
}
}
//+------------------------------------------------------------------+
//| Reverse all positions function |
//+------------------------------------------------------------------+
void ReverseAllPositions()
{
ReversePositions(true);
}
//+------------------------------------------------------------------+
//| Reverse expert positions function |
//+------------------------------------------------------------------+
void ReverseExpertPositions()
{
ReversePositions(false);
}
//+------------------------------------------------------------------+
//| Reverse positions function |
//+------------------------------------------------------------------+
void ReversePositions(bool allPositions)
{
Action action;
if(allPositions)
{
action = Action::REVERSE_ALL_POSITIONS;
}
else
{
action = Action::REVERSE_EXPERT_POSITIONS;
}
Print(EnumToString(action));
if(positionInfo.SelectByIndex(0))
{
switch(positionInfo.PositionType())
{
case ENUM_POSITION_TYPE::POSITION_TYPE_BUY:
action = Action::SELL;
break;
case ENUM_POSITION_TYPE::POSITION_TYPE_SELL:
action = Action::BUY;
break;
}
}
if(allPositions)
{
CloseAllPositions();
}
else
{
CloseExpertPositions();
}
if(action != Action::UNKNOWN)
{
Deal(action);
}
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
EventKillTimer();
}
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
if(!symbolInfo.Name(_Symbol))
{
return(INIT_FAILED);
}
if(!IsKeysCorrect())
{
return(INIT_PARAMETERS_INCORRECT);
}
EventSetTimer(1);
trade.SetExpertMagicNumber(MAGIC);
InitActions();
InitActionNames();
InitLastProfits();
Print(Usage());
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Is keys correct function |
//+------------------------------------------------------------------+
bool IsKeysCorrect()
{
string names[9];
names[0] = EnumToString(Action::BUY);
names[1] = EnumToString(Action::CLOSE_ALL_POSITIONS);
names[2] = EnumToString(Action::CLOSE_EXPERT_POSITIONS);
names[3] = EnumToString(Action::DEFEND_ALL_POSITIONS);
names[4] = EnumToString(Action::DEFEND_EXPERT_POSITIONS);
names[5] = EnumToString(Action::EXIT_SCALPER);
names[6] = EnumToString(Action::REVERSE_ALL_POSITIONS);
names[7] = EnumToString(Action::REVERSE_EXPERT_POSITIONS);
names[8] = EnumToString(Action::SELL);
AddIndexesToMap(buyActionKey, 0);
AddIndexesToMap(closeAllPositionsActionKey, 1);
AddIndexesToMap(closeExpertPositionsActionKey, 2);
AddIndexesToMap(defendAllPositionsActionKey, 3);
AddIndexesToMap(defendExpertPositionsActionKey, 4);
AddIndexesToMap(exitScalperActionKey, 5);
AddIndexesToMap(reverseAllPositionsActionKey, 6);
AddIndexesToMap(reverseExpertPositionsActionKey, 7);
AddIndexesToMap(sellActionKey, 8);
string error;
int keys[];
Indexes* indexes[];
keyToIndexesMap.CopyTo(keys, indexes);
for(int i = 0; i < (int) keys.Size(); i++)
{
int key = keys[i];
if(indexes[i].data.Size() > 1)
{
string mappedActionNames;
for(int j = 0; j < (int) indexes[i].data.Size(); j++)
{
if(j > 0)
{
mappedActionNames += ", ";
}
mappedActionNames += names[indexes[i].data[j]];
}
error += StringFormat("Error: duplicated key [%s] for %s\n", CharToString((uchar) key), mappedActionNames);
}
}
ClearMemory();
if(error.Length() > 0)
{
Alert(error);
return false;
}
return true;
}
//+------------------------------------------------------------------+
//| Add indexes to map function |
//+------------------------------------------------------------------+
void AddIndexesToMap(int key, int index)
{
Indexes* indexes;
if(!keyToIndexesMap.TryGetValue(key, indexes))
{
indexes = new Indexes();
keyToIndexesMap.Add(key, indexes);
}
int size = (int) indexes.data.Size();
ArrayResize(indexes.data, size + 1);
indexes.data[size] = index;
}
//+------------------------------------------------------------------+
//| Clear memory function |
//+------------------------------------------------------------------+
void ClearMemory()
{
if(keyToIndexesMap.Count() > 0)
{
int keys[];
Indexes* indexes[];
keyToIndexesMap.CopyTo(keys, indexes);
for(int i = 0; i < (int) indexes.Size(); i++)
{
if(CheckPointer(indexes[i]) == POINTER_DYNAMIC)
{
delete indexes[i];
}
}
}
keyToIndexesMap.Clear();
}
//+------------------------------------------------------------------+
//| Actions initialization function |
//+------------------------------------------------------------------+
void InitActions()
{
actions.Add(buyActionKey, Action::BUY);
actions.Add(closeAllPositionsActionKey, Action::CLOSE_ALL_POSITIONS);
actions.Add(closeExpertPositionsActionKey, Action::CLOSE_EXPERT_POSITIONS);
actions.Add(defendAllPositionsActionKey, Action::DEFEND_ALL_POSITIONS);
actions.Add(defendExpertPositionsActionKey, Action::DEFEND_EXPERT_POSITIONS);
actions.Add(exitScalperActionKey, Action::EXIT_SCALPER);
actions.Add(reverseAllPositionsActionKey, Action::REVERSE_ALL_POSITIONS);
actions.Add(reverseExpertPositionsActionKey, Action::REVERSE_EXPERT_POSITIONS);
actions.Add(sellActionKey, Action::SELL);
}
//+------------------------------------------------------------------+
//| Action names initialization function |
//+------------------------------------------------------------------+
void InitActionNames()
{
actionNames.Add(buyActionKey, EnumToString(Action::BUY));
actionNames.Add(closeAllPositionsActionKey, EnumToString(Action::CLOSE_ALL_POSITIONS));
actionNames.Add(closeExpertPositionsActionKey, EnumToString(Action::CLOSE_EXPERT_POSITIONS));
actionNames.Add(defendAllPositionsActionKey, EnumToString(Action::DEFEND_ALL_POSITIONS));
actionNames.Add(defendExpertPositionsActionKey, EnumToString(Action::DEFEND_EXPERT_POSITIONS));
actionNames.Add(exitScalperActionKey, EnumToString(Action::EXIT_SCALPER));
actionNames.Add(reverseAllPositionsActionKey, EnumToString(Action::REVERSE_ALL_POSITIONS));
actionNames.Add(reverseExpertPositionsActionKey, EnumToString(Action::REVERSE_EXPERT_POSITIONS));
actionNames.Add(sellActionKey, EnumToString(Action::SELL));
}
//+------------------------------------------------------------------+
//| Last profits initialization function |
//+------------------------------------------------------------------+
void InitLastProfits()
{
datetime now = TimeCurrent();
datetime yesterday = now - 86400; // PERIOD_D1 * 60
HistorySelect(yesterday, now);
int lastProfitIndex = 0;
LastProfit historyLastProfits[];
for(int i = HistoryDealsTotal() - 1; i >= 0; i--)
{
if(lastProfitIndex >= LAST_PROFITS_SIZE)
{
break;
}
ulong dealTicket = HistoryDealGetTicket(i);
double dealProfit = HistoryDealGetDouble(dealTicket, DEAL_PROFIT);
if(IsZero(dealProfit))
{
continue;
}
long dealReason = HistoryDealGetInteger(dealTicket, DEAL_REASON);
if(dealReason == DEAL_REASON_CLIENT || dealReason == DEAL_REASON_EXPERT || DEAL_REASON_MOBILE
|| dealReason == DEAL_REASON_SL || dealReason == DEAL_REASON_TP || DEAL_REASON_WEB)
{
LastProfit lastProfitStruct;
lastProfitStruct.message = GetMessage(dealTicket);
lastProfitStruct.profit = dealProfit;
lastProfitStruct.suffix = GetSuffix(dealReason);
ArrayResize(historyLastProfits, historyLastProfits.Size() + 1);
historyLastProfits[lastProfitIndex] = lastProfitStruct;
lastProfitIndex++;
}
}
for(int i = (int) historyLastProfits.Size() - 1; i >= 0; i--)
{
AddLastProfit(historyLastProfits[i]);
}
CalculateTotalLastProfit();
SetLastProfit();
}
//+------------------------------------------------------------------+
//| Get message function |
//+------------------------------------------------------------------+
string GetMessage(ulong dealTicket)
{
switch((int) HistoryDealGetInteger(dealTicket, DEAL_TYPE))
{
case ENUM_DEAL_TYPE::DEAL_TYPE_BUY:
return MESSAGE_SELL;
case ENUM_DEAL_TYPE::DEAL_TYPE_SELL:
return MESSAGE_BUY;
}
return "";
}
//+------------------------------------------------------------------+
//| Get suffix function |
//+------------------------------------------------------------------+
string GetSuffix(long dealReason)
{
if(dealReason == DEAL_REASON_SL)
{
return "(stop loss) ";
}
if(dealReason == DEAL_REASON_TP)
{
return "(take profit) ";
}
return "";
}
//+------------------------------------------------------------------+
//| Timer function |
//+------------------------------------------------------------------+
void OnTimer()
{
string comment = StringFormat(INDENT_FORMAT, TimeToString(TimeLocal(), TIME_MINUTES | TIME_SECONDS));
comment += lastProfit;
comment += Usage();
Comment(comment);
}
//+------------------------------------------------------------------+
//| Trade transaction function |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
if(trans.type != TRADE_TRANSACTION_DEAL_ADD)
{
return;
}
ulong dealTicket = trans.deal;
if(!HistoryDealSelect(dealTicket))
{
return;
}
long dealReason = HistoryDealGetInteger(dealTicket, DEAL_REASON);
if(dealReason == DEAL_REASON_SL || dealReason == DEAL_REASON_TP)
{
LastProfit lastProfitStruct;
lastProfitStruct.message = GetMessage(dealTicket);
lastProfitStruct.profit = HistoryDealGetDouble(dealTicket, DEAL_PROFIT);
lastProfitStruct.suffix = GetSuffix(dealReason);
AddLastProfit(lastProfitStruct);
CalculateTotalLastProfit();
SetLastProfit();
}
PlaySound(SOUND_FILE_NAME);
}
//+------------------------------------------------------------------+
//| Usage function |
//+------------------------------------------------------------------+
string Usage()
{
return Usage(buyActionKey)
+ Usage(closeAllPositionsActionKey) + Usage(closeExpertPositionsActionKey)
+ Usage(defendAllPositionsActionKey) + Usage(defendExpertPositionsActionKey)
+ Usage(exitScalperActionKey)
+ Usage(reverseAllPositionsActionKey) + Usage(reverseExpertPositionsActionKey)
+ Usage(sellActionKey);
}
//+------------------------------------------------------------------+
//| Action usage function |
//+------------------------------------------------------------------+
string Usage(ActionKey actionKey)
{
string actionName;
actionNames.TryGetValue(actionKey, actionName);
return StringFormat("[%c] %s\n", actionKey, actionName);
}
//+------------------------------------------------------------------+
//| Is zero function |
//+------------------------------------------------------------------+
bool IsZero(double value)
{
return MathAbs(value) < DBL_EPSILON ? true : false;
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| ToDo |
//| - pending order |
//| - trailing stop |
//| - objects Drag'n'Drp |
//| - error processing |
//+------------------------------------------------------------------+
Voir Git blame Copier le lien permanent