Qualquer pergunta de novato, de modo a não desorganizar o fórum. Profissionais, não passem por aqui. Em nenhum lugar sem você - 6. - página 1096
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Olá!
Como você pode determinar se uma posição é fechada na TP? Não acho que OrderClosePrice()==OrderTakeProfit() seria correto de usar.
No comentário da ordem procure [tp] se houver...
No comentário do pedido procure [tp] se houver um.
Olá Profi.
ajudar a corrigir o erro no indicador.....
indicador está funcionando.
O sinal é acionado na barra 0.
Mas quando outros carrapatos são recebidos na barra atual, ele aciona novamente e dá novos sinais.
Preciso que ele coloque este sinal em um círculo no lugar do preço do evento atual quando Vender ou Comprar - evento ocorre, e nenhum outro evento foi processado neste bar aberto.
Eu quero evitar novos sinais e círculos nesta barra.
________________________
Entendo que você vai dizer que é um absurdo, são sinais falsos, etc., mas isto é exatamente o que eu preciso.
Eu sei que deveria criar uma bandeira, um marcador, etc. - mas não tenho tempo para estudar a língua eu mesmo.
_________________________
Eu ficaria muito grato se você pudesse adicionar tal bandeira ao arquivo anexo e marcar as linhas adicionadas com a cor.....
Obrigado, e espero que alguém responda
Dá um par de erros, não consegue consertar. O que há de errado aqui?
//+------------------------------------------------------------------+Por favor, ajude-me a negociar nas notícias. Estou precisando de um EA que tem duas funções principais.
A primeira função: fazerpedidos pendentes com um determinado TP e SL, em um determinado momento e a um determinado nível de preço.
A segunda função: manter as ordens pendentes em paralelo com o preço. Significa movê-los junto com o preço (é tão incômodo fazer isso manualmente). Em um determinado momento, no momento da publicação da notícia, temos que parar esta ação e esperar até que o preço toque um dos pedidos. A segunda ordem é imediatamente apagada depois disso.
Mais uma vez:
2 minutos antes da divulgação da notícia, colocar duas ordens de parada opostas a uma distância de 10 pontos do preço, ativar imediatamente a função de mover-se paralelamente ao preço, 2 minutos de movimento junto com o preço, uma ordem foge do preço, a segunda alcança o preço. No comunicado à imprensa, você deve desativar a função de movimento de ordens pendentes e depois esperar pela quebra de uma das ordens. A segunda ordem é eliminada imediatamente após a quebra da primeira.
Variáveis variáveis que são alteradas nas propriedades de uma EA (aproximadamente como imagino, não sei qual é a realização na realidade)
TP - 600 (por padrão)
Trall - 300 (padrão)
SL - 100 (padrão)
Pips - 100 (distância do preço por padrão)
Slippage - 100 (slippage em pips por padrão)
Lote - 0,1
Risco - 10 // por cento (bem, isto não é necessário, se necessário perguntarei mais tarde)
TimeNews1On - true (use as células abaixo para entrar no tempo, false - o conselheiro não as comercializa)
TimeNewsHour - hora (hora de divulgação da notícia 1)
TimeNewsMin - minutos (hora de divulgação da notícia 1)
TimeNews2On - falso (por padrão)
TimeNewsHour - horas (hora de divulgação da notícia 2)
TimeNewsMin - minutos (hora de divulgação da notícia 2)
TimeNews3On - falso
TimeNewsHour - horas (hora de divulgação da notícia 3)
TimeNewsMin - minutos (hora da divulgação da notícia 3)
TimeNews4On - falso
TimeNewsHour - horas (hora de divulgação da notícia 4)
TimeNewsMin - minutos (hora da divulgação da notícia 4)
TimeNews5On - falso
TimeNewsHour - horas (hora de divulgação da notícia 5)
TimeNewsMin - minutos (hora da divulgação da notícia 5)
Insta, cinco dígitos.
Estou fazendo tudo isso manualmente, é muito difícil, e agora não tenho tempo para elaborar as notícias, quero colocar o Expert Advisor de manhã ou à noite em pares, onde haverá notícias naquele dia, para que todos eles se resolvam.
--------------------------------------
Se você conhece um especialista assim, por favor, compartilhe.
Agradecemos antecipadamente!
Voltemos ao seu código fonte. Experimente assim:
int OnInit()
{
se (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
nulo OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
nulo OnTick()
{
se (CountTrades() == 0) // O número de pedidos deve ser zero
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) > PriceOpenLastHistOrder(OP_SELLL))
// Se o último comércio estiver perdendo, o mesmo é aberto, mas com lote maior
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder()*Multiplier, 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// se o lucro do último comércio for igual a zero, o mesmo comércio será aberto
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder(), 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) < PriceOpenLastHistOrder(OP_SELLL))
|| CountHistTrades() == 0)// Se a última operação for lucrativa, abrir ordem
{
se (GlobalVariableGet("AllowNewOrders") > 0)retornar;
if (SignalBuy() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
se (bilhete>0) GlobalVariableSet("AllowNewOrders", 0);
}
if (SignalSell() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
se (bilhete>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
Não chequei, porque não entendo como múltiplas cópias de uma EA com um limite total de 1 ordem determinarão em qual símbolo (depois de uma série lucrativa) é melhor começar a comercializar?
Por favor, ajude a comercializar no noticiário. Realmente precisa de uma EA que deve ter duas funções principais.
Primeira função: colocarpedidos pendentes com um determinado TP e SL, em um determinado nível de tempo a partir do preço.
A segunda função: manter as ordens pendentes em paralelo com o preço. Isso significa movê-los junto com o preço (é tão incômodo fazê-lo manualmente). Em um determinado momento, no momento da publicação da notícia, temos que parar esta ação e esperar até que o preço toque um dos pedidos. A segunda ordem é imediatamente apagada depois disso.
Mais uma vez:
2 minutos antes da divulgação da notícia, colocar duas ordens de parada opostas a uma distância de 10 pontos do preço, ativar imediatamente a função de mover-se paralelamente ao preço, 2 minutos de movimento junto com o preço, uma ordem foge do preço, a segunda alcança o preço. No comunicado à imprensa, você deve desativar a função de movimento de ordens pendentes e depois esperar pela quebra de uma das ordens. O segundo será apagado imediatamente após a quebra do primeiro.
Se você conhece ou já conheceu tais conselheiros, por favor, compartilhe
Agradecemos antecipadamente!
Posso enviar-lhe o código para leitura de notícias de um arquivo, pode vir a ser útil. Uma vez por semana, você observa o calendário econômico e insere os dados na pasta de arquivos_with_terminal\MQL4\Files\novosti.txt das notícias que você deve prestar atenção, o assessor pode ser ativado mesmo antes das notícias (você pode usar este assessor para acompanhar o início, por exemplo, da sessão americana - caso haja um forte movimento). Eu não terminei o código comercial porque fui seriamente "enganado" algumas vezes pela notícia :))) A última versão fez seis pedidos (3 de compra + 3 de venda) a diferentes distâncias com diferentes Take Profit. De qualquer forma, meu código de notícias funciona, mas tenho que melhorar meu código comercial.
#propriedade rigorosa
input string NewsFilename = "novosti.txt"; // Nome do arquivo de texto contendo as notícias
entrada em MinutosAntes = 5; // Quantos minutos antes da publicação de notícias devem ser feitos os pedidos
entrada em MinutosDepois1 = 15; // quantos minutos após o comunicado à imprensa remover ordens do 1º grupo
entrada em MinutosApós 2 = 30; // quantos minutos após o comunicado à imprensa removem os pedidos do Grupo 2
entrada em MinutosApós 3 = 30; // quantos minutos após a divulgação da notícia remover os pedidos do Grupo 3
input int PriceIndent1 = 15; // Indentido do preço em pontos
input int PriceIndent2 = 5; // Passo atrás em relação ao TakeProfit anterior em pontos
input int TakeProfit1 = 40; // Tamanho TakeProfit para o 1º grupo em pontos
input int TakeProfit2 = 60; // Tamanho TakeProfit para o 2º grupo em pontos
input int TakeProfit3 = 100; // Tamanho TakeProfit para o 3º grupo em pontos
entrada no StopLoss = 20; // tamanho do StopLoss para todos os pedidos em pontos
duplo multiplicador de entrada1 = 1,0; // Coeficiente para o lote de ordem do 2º grupo
multiplicador duplo de entrada2 = 2,0; // coeficiente para os lotes de ordem do 3º grupo
input int MaximalRisk = 10; // Risco máximo em porcentagens
//====================================================================================================
data/hora[200]; // Última Hora;
Símbolos de corda[200];
bool NewsPassed[200];
int NewsCount;
//====================================================================================================
int OnInit()
{
// Carregando notícias frescas
if (!LoadNews()) return(INIT_FAILED);
return(INIT_SUCCEED);
}
//====================================================================================================
nulo OnTick()
{
se (!IsTradeAllowed()) retornar;
datetime TestTime = iTime(Symbol(), PERÍODO_H1, 0);
// Atualização de notícias no início de cada dia
se (TimeDay(TestTime) != TimeDay(LastTime))
{
LastTime = Tempo de teste;
se (!LoadNews())
{
Alerta("Erro de atualização de notícias!");
retornar;
}
}
//-------------------------------------------------------------------------------------------------
para (int i = 0; i < NewsCount; i++)
{
// Até o comunicado à imprensa colocar ordens para a descoberta
if (Times[i] > TimeCurrent() && Times[i] - TimeCurrent() <= MinutosAntes de * 60 && !NewsPassed[i])
{
PrintFormat("A hora atual é %s, é hora de definir ordens de moeda - %s", TimeToStr(TimeCurrent(), TIME_DATE|TIME_MINUTES), Symbols[i])
SetupOrders(Símbolos[i];
NewsPassed[i] = verdadeiro;
}
}
//-------------------------------------------------------------------------------------------------
}
//====================================================================================================
bool LoadNews()
{
int Count, Tick = 0;
string Str, Data[40];
ResetLastError();
if (!FileIsExist(NewsFilename, 0))
{
PrintFormat("O arquivo de notícias %s não existe", NewsFilename);
Imprimir ("O arquivo deve estar na pasta MQL4Files, em caso de teste - na pasta do Testador");
retorno(falso);
}
int Handle = FileOpen(NewsFilename, FILE_READ|FILE_SHARE_READ|FILE_TXT);
se (Pega != INVALID_HANDLE)
{
enquanto (!FileIsEnding(Handle))
{
Str = FileReadString(Handle);
Count = StringSplit(String, StringGetChar(" ", 0), Data);
para (int i = 1; i < Contar; i = i + 2)
{
Times[Tick] = StringToTime(Data[0] + " + Data[i]);
Símbolos[Tick] = Dados[i + 1];
Tick++;
}
}
FileClose(Manípulo);
NewsCount = Tick;
para (int i = 0; i < NewsCount; i++)
{
se (Times[i] > TimeCurrent()) NewsPassed[i] = falso;
else NewsPassed[i] = falso;
}
PrintFormat("Número de notícias carregadas - %i.", NewsCount);
retorno(true);
}
PrintFormat("Não é possível abrir o arquivo %s. Código de erro %d.", NewsFilename, GetLastError());
retorno(falso);
}
//====================================================================================================
Encomendas de instalação nulas(string Sym)
{
int Ticket, Dig, Count;
preço duplo, TP, SL, Lote;
data/hora KeepAlive = TimeCurrent() + (MinutosAntes + MinutosApós1) * 60;
SymList[7];
//-------------------------------------------------------------------------------------------------
se (Sym == "AUD")
{
SymList[0] = "AUDCAD"; SymList[1] = "AUDCHF"; SymList[2] = "AUDJPY"; SymList[3] = "AUDNZD";
SymList[4] = "AUDUSD"; SymList[5] = "EURAUD"; SymList[6] = "GBPAUD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "CAD")
{
SymList[0] = "AUDCAD"; SymList[1] = "CADCHF"; SymList[2] = "CADJPY"; SymList[3] = "EURCAD";
SymList[4] = "GBPCAD"; SymList[5] = "NZDCAD"; SymList[6] = "USDCAD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "CHF")
{
SymList[0] = "AUDCHF"; SymList[1] = "CADCHF"; SymList[2] = "EURCHF"; SymList[3] = "GBPCHF";
SymList[4] = "CHFJPY"; SymList[5] = "NZDCHF"; SymList[6] = "USDCHF";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "EUR")
{
SymList[0] = "EURAUD"; SymList[1] = "EURCAD"; SymList[2] = "EURCHF"; SymList[3] = "EURGBP";
SymList[4] = "EURJPY"; SymList[5] = "EURNZD"; SymList[6] = "EURUSD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "GBP")
{
SymList[0] = "EURGBP"; SymList[1] = "GBPAUD"; SymList[2] = "GBPCAD"; SymList[3] = "GBPCHF";
SymList[4] = "GBPJPY"; SymList[5] = "GBPNZD"; SymList[6] = "GBPUSD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "JPY")
{
SymList[0] = "AUDJPY"; SymList[1] = "CADJPY"; SymList[2] = "CHFJPY"; SymList[3] = "EURJPY";
SymList[4] = "GBPJPY"; SymList[5] = "NZDJPY"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "NZD")
{
SymList[0] = "AUDNZD"; SymList[1] = "EURNZD"; SymList[2] = "GBPNZD"; SymList[3] = "NZDCAD";
SymList[4] = "NZDCHF"; SymList[5] = "NZDJPY"; SymList[6] = "NZDUSD";
}
//-------------------------------------------------------------------------------------------------
se (Sym == "USD")
{
SymList[0] = "AUSUSD"; SymList[1] = "EURUSD"; SymList[2] = "GBPUSD"; SymList[3] = "NZDUSD";
SymList[4] = "USDCAD"; SymList[5] = "USDCHF"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
para (int i = 0; i < 7; i++)
{
Contagem = 0;
Dig = int(MarketInfo(SymList[i], MODE_DIGITS));
Lote = NormalizeDuplo(0,01, 2);
//Compra
KeepAlive = TimeCurrent() + (MinutosAntes + MinutosPós1) * 60;
Price = NormalizeDouble(MarketInfo(SymList[i], MODE_ASK) + PriceIndent1 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Price + TakeProfit1 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preço - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutosAntes + MinutosPós2) * 60;
Preço = NormalizeDuplo(TP + PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Price + TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preço - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot * Multiplier1, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutosAntes + MinutosPós3) * 60;
Preço = NormalizeDuplo(TP + PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Price + TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preço - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot*Multiplier2, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, take %f, stop %f, lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier2);
// Vender
KeepAlive = TimeCurrent() + (MinutosAntes + MinutosPós1) * 60;
Price = NormalizeDouble(MarketInfo(SymList[i], MODE_BID) - PriceIndent1 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preço - TakeProfit1 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preço + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutosAntes + MinutosPós2) * 60;
Preço = NormalizeDuplo(TP - PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preço - TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preço + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
if (Ticket > 0) Count++; else PrintFormat("Error creating the order %i, symbol %s, price %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutosAntes + MinutosPós3) * 60;
Preço = NormalizeDuplo(TP - PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preço - TakeProfit3 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preço + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
PrintFormat("Há %i pedidos feitos pelo símbolo %s", SymList[i], Count);0 }
}
O arquivo de notícias tem este aspecto:
15.09.2016 01:45 NZD 04:30 AUD 10:30 CHF 14:00 GBP 15:30 USD
16.09.2016 15:30 USD 17:00 USD
e assim por diante...
Voltemos ao seu código fonte. Experimente assim:
int OnInit()
{
se (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
nulo OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
nulo OnTick()
{
se (CountTrades() == 0) // O número de pedidos deve ser zero
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) > PriceOpenLastHistOrder(OP_SELLL))
// Se o último comércio estiver perdendo, o mesmo é aberto, mas com lote maior
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder()*Multiplier, 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// se o lucro do último comércio for igual a zero, o mesmo comércio será aberto
{
GlobalVariableSet("AllowNewOrders", 0);
Tipo = TypeLastHistOrder();
se (Tipo == OP_BUY) Preço = Perguntar;
se (Tipo == OP_SELL) Preço = Licitação;
Lote = NormalizeDuplo(LotsLastHistOrder(), 2);
bilhete = OrderSend(Symbol(), Type, Lot, Price, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELLL && PriceCloseLastHistOrder(OP_SELLL) < PriceOpenLastHistOrder(OP_SELLL))
|| CountHistTrades() == 0)// Se a última negociação for lucrativa, a ordem é aberta
{
se (GlobalVariableGet("AllowNewOrders") > 0)retornar;
if (SignalBuy() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
se (bilhete>0) GlobalVariableSet("AllowNewOrders", 0);
}
if (SignalSell() && MaxOpenOrders > OrderTotal())
{
bilhete = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
se (bilhete>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
Não chequei, porque não entendo como várias cópias de um EA com um limite total de 1 pedido detectarão em qual símbolo (depois de uma série lucrativa) é melhor começar a comercializar?
Alexander, o bot tem que esperar o número especificado de velas em cada símbolo em uma direção e depois iniciar uma série, ou seja, em que símbolo esta condição é acionada primeiro para aquele símbolo e abrir o primeiro comércio. Ao mesmo tempo, você deve proibir a abertura de uma série para outros símbolos até que a primeira série termine com lucro.
O último código que você deu é um passo à frente - não abre nenhum acordo (ou seja, a proibição está ativa). Eu não entendi por que nenhum. Em anexo, uma captura de tela do registro.
Talvez seja a hora de aprender a inserir código!