Manual do HT Code: robôs e indicadores em C# na HTS

O HT Code é onde a sua estratégia vira robô. Você escreve em C#, uma linguagem de programação de verdade, com tipos, classes, listas, funções e bibliotecas próprias, e a HTS cuida do resto: compila, testa no histórico, desenha no gráfico e opera ao vivo na sua conta, com o mesmo código do começo ao fim. Se você já tem um setup que opera na mão, uma planilha que calcula sinais ou um robô escrito em outra plataforma, este é o lugar de trazê-lo.

Por que trazer seus algoritmos para cá

Uma linguagem de verdade, sem amarras de script

C# é a linguagem do .NET, usada em sistemas de banco, jogos e software de mercado no mundo todo. Você organiza a estratégia em classes e funções, guarda estado em listas e dicionários, reaproveita código em bibliotecas suas e escreve a lógica que quiser, do cruzamento de médias ao modelo estatístico.

O mesmo número que você vê no gráfico

São mais de 50 indicadores prontos (médias, bandas, osciladores, tendência, volume, VWAP, Ichimoku, padrões de candle) com a mesma conta do gráfico da HTS. O RSI do seu robô é o RSI da tela, candle a candle: o que você enxerga é o que o robô decide.

Backtest que respeita o candle por dentro

O backtest roda no seu PC, sobre os candles do ativo, com slippage, corretagem, posição máxima e as regras da automação. Se o robô decide no meio do candle, o motor anda dentro de cada candle pela "lupa" de 1 minuto, na ordem provável de máxima e mínima, e confere stop e alvo ponto a ponto. O otimizador testa faixas de parâmetros e faz walk-forward (otimiza num trecho e confere no seguinte), para separar estratégia boa de estratégia ajustada ao passado.

Do teste para a conta sem reescrever nada

O código que passou no backtest é o mesmo que opera ao vivo, no Simulador ou na sua conta real, pelo HTS desktop. Você escolhe o ativo, o tempo gráfico e as regras da automação, liga, e acompanha cada ordem, o resultado do dia e o diário do robô.

Decida no fechamento ou no negócio

O robô pode decidir no fechamento de cada candle ou a cada negócio da bolsa, assim que a condição bater. Ao vivo, ele lê o book, a agressão de compra e venda e os últimos negócios: dá para escrever estratégia de fluxo, não só de candle.

Vários tempos e ativos na mesma estratégia

Um robô de 5 minutos pode confirmar a tendência no gráfico de 60 minutos e olhar o dólar enquanto opera o índice. Basta declarar a série que ele usa.

Robôs e indicadores, na mesma linguagem

Você programa os dois: robôs que operam sozinhos e indicadores que desenham no gráfico. O indicador aparece em "Meus indicadores", com linhas, histogramas, bandas preenchidas, marcas, candles pintados e tabela, e com os parâmetros editáveis como qualquer estudo. Muitas vezes o caminho é esse: primeiro o indicador mostra o sinal no gráfico, depois o mesmo raciocínio vira robô.

Proteção que trabalha por você

Seu robô opera com uma rede de segurança. Stop, alvo e as regras de risco que você escolhe (horário, meta e limite de perda do dia) são vigiados pela plataforma o tempo todo, mesmo se o código falhar. Você foca na estratégia; a disciplina fica garantida.

Comece por aqui

1. No terminal, abra HT Code (menu Automações). O "+" cria um código novo, em branco. A aba Exemplos, ao lado

do Explorador, tem dezenas de robôs e indicadores prontos para ler e copiar.

1. Dê um nome, escreva (ou cole) o código e clique em Compilar. Os problemas aparecem sublinhados no texto e na

lista "Problemas".

1. Robô (código que manda ordem): Backtest roda no histórico, no seu PC. Indicador (código que só desenha):

Rodar desenha no gráfico ao lado.

1. Para operar de verdade: em Meus robôs (menu Automações) crie uma automação (robô, conta, ativo e tempo gráfico),

escolha as regras e ligue. O robô roda no seu HTS desktop; se o desktop fecha, o robô para e a posição fica.

A categoria do código é automática: quem chama Buy, Sell, ClosePosition, StopLoss ou TakeProfit é robô; quem não chama é indicador; um código sem classe que herde de Robot é biblioteca (código compartilhado, que entra em todos os outros).

Nos exemplos deste manual, um trecho só com comandos roda dentro do OnBarClose; um trecho com campos ou override fica dentro da classe do robô. Todos compilam como estão.

Como um robô é feito

Todo robô é uma classe que herda de Robot. Dentro dela há três partes, sempre nesta ordem de leitura:

Não precisa escrever using: a API do robô (HTS.Robots e HTS.Robots.Indicators) e o básico do C# (System, System.Linq, System.Collections.Generic) já vêm prontos em todo código. O código começa direto na classe.

O esqueleto de um robô

Um robô completo de cruzamento de preço com a média, com stop e alvo, cabe em poucas linhas:

1public class MeuRobo : Robot2{3    [Parameter("Período", Min = 2, Max = 200)] public int Periodo = 20;45    private Sma media = null!;67    public override void OnStart()        // uma vez, antes do primeiro candle: crie os indicadores aqui8    {9        media = new Sma(Periodo);10    }1112    public override void OnBarClose()   // a cada candle FECHADO: é aqui que o robô decide13    {14        media.Update(Current);15        if (!media.IsReady) return;16        Plot("Média", media.Value);17        if (Position.IsFlat && Current.Close > media.Value) { Buy(1); StopLoss(150); TakeProfit(300); }18        else if (Position.IsLong && Current.Close < media.Value) ClosePosition();19    }2021    public override void OnStop() { }   // uma vez, no fim (ou quando a automação é desligada)22}

Linha a linha:

• [Parameter("Período")] transforma Periodo num campo da tela, com mínimo e máximo.
• private Sma media é a variável que guarda a média móvel entre um candle e outro.
• OnStart cria a média uma vez só; OnBarClose a avança com o candle que fechou (Current).
• IsReady diz que a média já tem candles suficientes; antes disso, o robô espera.
• Plot desenha a média no gráfico do backtest; Buy(1) compra um contrato a mercado, e StopLoss(150) e

TakeProfit(300) põem stop e alvo a 150 e 300 pontos do preço médio.

Como o robô roda

O motor entrega o histórico ao robô candle a candle, do mais antigo ao mais recente, e chama OnBarClose uma vez para cada candle fechado. Quando o histórico acaba, ao vivo, o robô continua do mesmo jeito: cada candle que fecha é mais uma chamada. Por isso o mesmo código serve para o backtest e para a conta.

Dentro de cada chamada, o robô enxerga o candle que acabou de fechar e todo o passado até ele, nunca o futuro:

Para decidir no meio do candle, implemente também OnTick: ao vivo, ele roda a cada negócio da bolsa; no backtest, em cada ponto da lupa de 1 minuto. A mesma chamada pode mandar várias ordens a mercado (até 20); elas saem em sequência, cada uma conferida pela posição que as anteriores deixam.

O que o motor faz por você

• Stop e alvo de verdade: o motor confere o toque a cada negócio (e, no backtest, em cada ponto de dentro do

candle), mesmo que o seu código não esteja rodando naquele instante.

• Sem mão dobrada: ao vivo, a entrada pedida numa chamada seguinte espera a anterior chegar à posição; sair e

reduzir passam sempre.

• Regras da automação acima do código: horário, leilão, meta e stop do dia, perdas seguidas, número de operações e

posição máxima valem sempre.

• Código isolado: o robô não acessa internet, arquivos nem o relógio do PC. Tudo o que ele sabe vem do mercado e

tudo o que ele pede passa pelo motor, por isso o backtest e a conta se comportam igual.

Fim do pregão. A última barra do dia chega com o mercado fechado, e nada executa nela. A entrada pedida é recusada (AoOrdemRecusada, FORA_DO_HORARIO, "O pregão de 29/10 já fechou..."). A saída fica guardada e vai ao mercado na abertura do pregão seguinte, uma vez só, nunca maior que a posição daquele momento; recusada de novo com o mercado fechado, o motor manda outra vez enquanto houver posição, com a espera crescendo de 5 s a 30 s. O Zerar guardado não fecha uma posição que virou de lado durante a noite. O mesmo vale para o que o robô pedir depois do fechamento e para a zeragem pela regra. O toque do stop ou do alvo com o mercado fechado não sai: a posição dorme com a proteção, e na abertura quem decide é o preço. Se ele continua além do stop ou do alvo, sai por ele; se voltou, não sai e a proteção segue. Um negócio isolado de noite não é toque. Pendente pedida com o pregão fechado é recusada. Ao vivo, a penúltima barra pode fechar já depois do fim do pregão, no primeiro negócio do leilão de fechamento, e segue as mesmas regras; no backtest ela executa normalmente. Se o mercado for dado por fechado e continuar negociando (mais de 10 min depois, com 2 negócios em até 60 s), o motor volta a operar no mesmo dia. O backtest faz igual: a entrada na última barra é recusada e a saída executa na abertura seguinte, com o escorregamento; se a abertura cruzar o stop ou o alvo, sai por ele. Com "Zerar no fim do pregão" ligado, o backtest zera no fechamento dessa barra, como sempre. Não vale no tempo D, cuja barra só fecha com o primeiro negócio do dia seguinte, nem em ativo de 24 h, que não tem fim de pregão. Se o HTS for fechado antes da abertura, a saída guardada não vai: confira a posição. Num HTS desktop anterior ao host de robôs 1.2.0, a última barra só chega com o primeiro negócio do dia seguinte: atualize o HTS.

Posição atrasada. Se a posição demorar mais de 30 s a mostrar uma execução, o stop, o Zerar e a zeragem pela regra não vendem de novo o que já foi vendido: a saída não sai até a posição mostrar, ou por até 2 min, com um aviso no diário. Se a posição atrasar mais que isso (cerca de 2 min e meio no total), a saída pode vender de novo: confira a posição. A entrada em lote e a stop ou limitada do robô que reduz voltam quando a posição mostrar a entrada.

Os eventos do robô

Início do robô

Uma vez, antes do primeiro candle. É onde se criam os indicadores.

1private Ema rapida = null!;2public override void OnStart() { rapida = new Ema(9); }

Fechamento do candle

A cada candle FECHADO. Obrigatório: é onde o robô decide.

1public override void OnBarClose()2{3    if (Position.IsFlat && Current.IsBullish) Buy(1);4}

A cada negócio

A cada negócio, para entrar no meio do candle assim que a condição bater. No backtest, o motor anda dentro de cada candle pela "lupa" de 1m (abertura, máxima e mínima na ordem provável, fechamento) e chama aqui em cada ponto; a lupa cobre até 50 mil minutos, e antes disso cada candle vira 4 pontos (o backtest avisa).

1public override void OnTick(Tick tick)2{3    if (Position.IsFlat && CurrentDay is Bar dia && tick.Price > dia.High) Buy(1);4}

A cada mudança do book

A cada mudança do book. Só ao vivo (não há book histórico no backtest).

1public override void OnBook(Book book)2{3    if (book.BestBid is BookLevel compra && book.BestAsk is BookLevel venda && compra.Quantity > 3 * venda.Quantity)4        Log("comprador pesado no topo do book");5}

Fim do robô

Uma vez, no fim do backtest ou quando a automação é desligada.

1public override void OnStop() { Log($"Fim: {Trades.Count} operações"); }

Estado do pregão

O estado do pregão do ativo: aberto, em leilão ou fechado (no backtest, desconhecido).

1if (Session == SessionState.Auction) return; // não decide em leilão

Ordens, posição, stop e alvo

Compra e venda a mercado

Ordem a mercado de n contratos. No backtest executa no fechamento do candle (ou no ponto da lupa, em OnTick) com o slippage configurado; ao vivo, vai para a sua conta.

1if (Position.IsFlat && Current.Close > Current.Open) Buy(1);

Zerar a posição

Zera a posição que existe, a mercado.

1if (Now.HHMM >= 1740 && !Position.IsFlat) ClosePosition();

Posição

A posição líquida: quantidade com sinal e preço médio, com IsFlat, IsLong, IsShort, Contracts e OpenProfit(preco, SymbolInfo) (o resultado aberto em reais).

1if (Position.IsLong && Position.OpenProfit(Current.Close, SymbolInfo) > 300) ClosePosition();

Stop e alvo em pontos

Stop e alvo a essa distância do preço médio; chamar de novo substitui. Sem posição e sem ordem no candle, são recusados.

1if (Position.IsFlat) { Buy(1); StopLoss(150); TakeProfit(300); }

Cancelar stop e alvo

Remove o stop e o alvo do motor.

1if (Position.IsFlat) CancelStops();

Dados do ativo

O ativo do robô: tick, valor do ponto e moeda.

1var reaisPorPonto = SymbolInfo.PointValue * Position.Contracts;2Log($"{SymbolInfo.Symbol}: tick {SymbolInfo.TickSize}, R$ {reaisPorPonto} por ponto na posição");

Ordens pendentes, stop móvel e eventos da ordem

Compra limitada e venda limitada

Ordem limitada. Aceitam nome (até 40 caracteres) e comentario (até 80). Repetir o nome substitui a pendente anterior; sem nome, o motor dá um (limite-1...). Até 20 pendentes por robô.

1if (Position.IsFlat) BuyLimit(1, Current.Low - 50, "pullback");

Stop de compra e stop de venda

Ordem stop: vira a mercado quando o preço toca o gatilho.

1if (Position.IsFlat && CurrentDay is Bar dia) BuyStop(1, dia.High + 5, "rompe-maxima");

Stop limitado de compra e de venda

No gatilho, vira limitada no preço limite. Só no Simulador.

1if (Position.IsFlat) BuyStopLimit(1, Current.High + 10, Current.High + 20, "stop-limite");

Cancelar e alterar pendentes

Mexem nas pendentes; PendingOrders lista as de agora.

1if (PendingOrders.Count > 0 && Now.HHMM >= 1700) CancelAll();2if (!Modify("pullback", Current.Low - 30)) Log("não havia pendente com esse nome");

Pendente que só reduz (entrada com alvo)

Buy(1); SellLimit(1, alvo) é entrada com alvo; se a posição zerar, a pendente cai. Pendentes valem no dia: caem na virada, no teto e no encerramento. No backtest são conferidas a partir do candle seguinte (limite sem slippage, stop com slippage, gap a favor ou contra na abertura).

1if (Position.IsFlat) { Buy(1); SellLimit(1, Current.Close + 300, "alvo"); }

Saída parcial e virada de mão

Zera parte da posição ou vira a mão.

1if (Position.Contracts >= 2 && Position.OpenProfit(Current.Close, SymbolInfo) > 200) ClosePartial(1);

Stop e alvo num preço

Stop e alvo num preço, em vez de distância.

1if (Position.IsLong && PreviousDay is Bar ontem) StopLossAt(ontem.Low);

Stop móvel e break-even

Stop móvel e break-even, cuidados pelo motor (não viram ordem na corretora até tocar).

1if (Position.IsFlat) { Buy(1); StopLoss(150); TrailingStop(100); BreakEven(120, 10); }

Ordem executada

Uma ordem executou. Dá para pôr stop e alvo ali.

1public override void OnFill(Fill fill)2{3    Log($"executou {fill.Side} {fill.Quantity} a {fill.Price:0}");4    if (!Position.IsFlat) { StopLoss(150); TakeProfit(300); }5}

Ordem recusada ou cancelada

A ordem foi recusada ou cancelada. Códigos das pendentes: NOME_INVALIDO, PRECO_INVALIDO, PENDENTES_DEMAIS, STOP_LIMITE_SO_SIMULADOR, SERIE_INDISPONIVEL, SERIE_INVALIDA.

Cada robô envia até 150 ordens por minuto, e cada Modify conta como uma. Acima disso, a entrada e o Modify de uma entrada são recusados com TAXA_EXCEDIDA (a ordem modificada fica como estava). Saídas, cancelamentos e o Modify de um stop ou alvo que só reduz a posição sempre passam.

Na conta real MT5, a saída nunca aumenta a posição na corretora. Se ela tem menos que a carteira do robô, a saída vende só o que há e avisa. Zerada ou do outro lado, a saída é recusada com LIQUIDO_NAO_COBRE: confira a posição. SAIDA_EM_VOO quer dizer que outra saída do mesmo ativo ainda está a caminho. O stop continua valendo e o motor tenta de novo.

1public override void OnOrderRejected(PendingOrder order, string code, string message)2{3    Log($"recusada: {code} {message}", LogLevel.Warning);4}

Outros tempos, outros ativos e o fluxo

Outro tempo gráfico ou outro ativo

Declare na classe [UsesSeries("15m")] (mesmo ativo, outro tempo) ou [UsesSeries("WDOFUT", "5m")] (outro ativo) e leia com CandlesOf: os candles fechados, o mais antigo primeiro. Tempos: os temporais do gráfico, em minutos (1m a 1439m: 2m, 10m, 45m...), em horas (2h, 3h, 4h...) ou D; "120m" e "2h" são a mesma série. Séries atemporais (Renko, Range...) ainda não. Até 4 séries e 2 ativos extras. No backtest só o mesmo ativo, num tempo múltiplo do teste (num teste atemporal, nenhum), montado como no gráfico: 5m, 15m, 30m e 60m alinhados ao relógio; os outros contando do início do pregão (45m = três de 15m, a partir da abertura). Com o teste num tempo que o banco não guarda (2m, 10m, 45m...), um minuto sem negócio desloca a contagem: a série feita de uma base maior que a do teste (2m pedindo 30m) só sai quando toda barra do teste cabe nos baldes dela; senão fica vazia, com o motivo na recusa.

1[UsesSeries("15m")]2public class FiltroDe15 : Robot3{4    public override void OnBarClose()5    {6        var c15 = CandlesOf("15m");7        if (c15.Count > 0 && c15[^1].IsBullish && Position.IsFlat) Buy(1);8    }9}

Negócios recentes, agressão e ajuste

Só ao vivo: os últimos negócios (até 500), a agressão de compra e venda desde que o robô ligou e o ajuste do dia nos futuros.

1if (Aggression.Delta > 500 && Position.IsFlat) Buy(1);2if (Settlement is double ajuste && Current.Close < ajuste) Log("abaixo do ajuste");

Regras da automação (a tela, não o código)

Na automação a pessoa escolhe: início, não abrir depois de, zerar às, esperar N minutos da abertura, pausar no leilão, meta do dia, stop diário, perdas seguidas, operações por dia e posição máxima. Quem vigia é o motor. Regra nunca bloqueia saída: zerar, reduzir, stop e alvo passam sempre. Encerrado o dia, só saída até o próximo pregão.

Regras escolhidas na tela

As regras escolhidas na tela, só para ler.

1if (Rules.FlattenAt is int zera && Now.HHMM >= zera - 5) return; // perto de zerar, não entra

Situação do dia

O dia já encerrou, por quê, quantas entradas hoje e quantas perdas seguidas.

1if (StoppedForDay) { Log($"parado: {StopReason}"); return; }2if (EntriesToday >= 3 || ConsecutiveLosses >= 2) return;

Tempo e calendário da B3

Hora e dia do pregão

O robô não lê relógio: Now é o momento do evento em Brasília (no candle, o FIM dele; no negócio, a hora dele) e Today é o pregão. Now.HHMM dá 1740 às 17:40.

1if (Now.HHMM < 915 || Now.HHMM >= 1730) return;2if (Today.Weekday == Weekday.Friday && Now.Hour >= 16) return;

Gráficos atemporais

Nos gráficos atemporais (Renko, Range, Pontos, Ponto e figura, negócios, volume) a barra não tem duração fixa: SecondsPerCandle é 0. As barras são montadas dos candles de 1 minuto, então a hora tem precisão de minuto: Current.Time é o minuto em que a barra FECHOU (não o começo dela) e Current.End é o fim desse minuto (é ele o Now do fechamento). As que fecham no mesmo minuto ficam 1 segundo uma depois da outra, e a última vai até o fim do minuto. Por isso End - Time não diz quanto a barra levou para se formar; o tempo entre duas barras é a diferença entre os End delas, com precisão de minuto. MinutesSinceOpen conta do minuto em que fechou a primeira barra de hoje. No backtest, a ordem a mercado de uma barra atemporal executa no fechamento do minuto em que ela fechou (o preço de verdade, não o fechamento desenhado do tijolo ou da coluna), e o stop, o alvo e as pendentes são conferidos pelos candles de 1 minuto de dentro dela e pelos que sobram do pregão depois da última barra; o OnTick anda por esses mesmos candles de 1 minuto.

1if (SecondsPerCandle == 0 && Candles.Count > 1)2{3    var desdeAAnterior = Current.End - Candles[^2].End; // segundos entre os fechamentos, com precisão de minuto4    if (desdeAAnterior < 60 && Current.IsBullish) Log("fechou no mesmo minuto da anterior");5}

Os gráficos atemporais recomeçam a cada pregão, no 1º negócio do dia: as barras de um dia saem só dos candles de 1 minuto daquele dia. O Renko e o Renko ATR começam na abertura do 1º candle, o ATR recomeça junto, nenhuma barra atravessa a noite e o gap da abertura não vira tijolo. A barra que ainda estava em formação no fim do dia (Pontos, Range, Ponto e figura, negócios, volume) fecha ali, mais curta; o Renko não tem barra em formação. Ao vivo, ela fecha quando o mercado encerra o pregão. É isso que faz o gráfico, o backtest e o robô ao vivo darem as mesmas barras em todo pregão inteiro, com histórico de qualquer tamanho. O 1º pregão de cada histórico baixado fica de fora, porque pode vir cortado; num ativo novo, com um ou dois pregões de histórico, tudo fica. O backtest atemporal cobre os pregões que o histórico de 1 minuto ainda guarda (uma janela que anda: os mais antigos saem), menos esse 1º.

Isso vale para o tempo gráfico do robô. O indicador Renko que você cria no código com new Renko(...) é outro: ele anda nos candles que recebe, sem recomeçar a cada pregão.

Ao vivo, o Now nunca volta: a barra que chega depois de um negócio mais novo (os tijolos que fecharam no mesmo minuto; a última barra do pregão de um tempo como 45m ou 2h, que só fecha com o primeiro candle do pregão seguinte) fica com a hora desse negócio. A barra de um pregão que já passou entra em Candles e chama o OnBarClose (os indicadores andam nela), mas o motor não confere o stop e o alvo pela faixa dela, e as regras ("zerar às", janela) são as da hora de agora.

Ao vivo, num gráfico atemporal, o stop, o alvo, o stop móvel, o break-even e a MEP/MEN são conferidos só pelos negócios: a mínima e a máxima da barra (no Ponto e figura, a coluna inteira; no Renko, o tijolo) têm preços de antes da entrada e não disparam nada. O negócio que chega enquanto a ordem anterior ainda não voltou é conferido assim que ela volta. Se o feed de negócios cair, a proteção espera o próximo negócio.

Ao vivo, num gráfico de tempo (1m, 5m, 60m, D...), o stop, o alvo, o stop móvel, o break-even e a MEP/MEN são conferidos a cada negócio e também pela mínima e pela máxima da barra que fechou. A faixa da barra pega o toque que chegou enquanto a ordem anterior ainda não tinha voltado e o que o feed de negócios perdeu. Ela só vale para a proteção que já existia quando a barra começou. Se a proteção começar ou mudar no meio da barra (a entrada com stop ou alvo, um stop ou um alvo novo, um passo do stop móvel), o fechamento dela confere só os negócios que chegaram depois disso: a mínima e a máxima de antes não disparam nada nem puxam o stop móvel, e o toque na proteção de antes que chegou com a ordem anterior ainda sem voltar também não conta mais. A MEP/MEN de uma entrada sem stop nem alvo segue pela barra inteira. Na barra seguinte, a faixa inteira volta a valer. No backtest é o mesmo: a ordem a mercado executa no fechamento da barra e o stop dela vale a partir da barra seguinte; com OnTick, a partir do ponto seguinte da lupa.

A entrada pedida no OnBarClose da última barra de um pregão que já passou, quando ela só chega no pregão seguinte (mais de 1 h depois do fim dela), é recusada com FORA_DO_HORARIO e o motivo no diário; a saída passa. Não vale para o gráfico D (o D de ontem sempre fecha com o primeiro negócio de hoje: é o sinal para a abertura, como no backtest) nem para a virada da meia-noite de um mercado de 24 h.

Calendário da B3

Feriados, vencimentos e dias úteis da B3.

1var du = B3Calendar.BusinessDaysToExpiration(SymbolInfo.Symbol, Today);2if (du is <= 1) return; // não opera na véspera do vencimento

Dia, dia anterior, semana e mês

Abertura, máxima, mínima, fechamento e volume do período.

1if (PreviousDay is Bar ontem && Current.Close > ontem.High && Position.IsFlat) Buy(1);

Minutos desde a abertura

Minutos desde o primeiro candle do dia.

1if (MinutesSinceOpen is < 15) return; // espera 15 minutos de pregão

Séries e números

Candles como séries

Os candles como séries: [0] é agora, [1] o candle anterior (como close[1]).

1if (Closes[0] > Closes[1] && Closes[1] > Closes[2]) Log("três fechamentos subindo");

Média, soma, máxima e outras contas de série

Valem para qualquer série (candles, indicadores, as suas): Average(n), Sum(n), StdDev(n), Highest(n) e Lowest(n) (valor e há quantos candles), Rising(n), Falling(n), Change(n), Percentile(n, p), Correlation(outra, n).

1var maior = Highs.Highest(20);2if (Current.Close > maior.Value && Volumes[0] > Volumes.Average(20)) Buy(1);

Série própria

Uma série sua, um valor por candle (Add).

1private readonly Series amplitude = new();2public override void OnBarClose()3{4    amplitude.Add(Current.Range);5    if (amplitude.Count >= 10 && Current.Range > 2 * amplitude.Average(10)) Log("candle largo");6}

Série de sim ou não

Série de sim/não: BarsSince() (há quantos candles foi) e ValueWhen(serie).

1private readonly BoolSeries subiu = new();2public override void OnBarClose()3{4    subiu.Add(Current.IsBullish);5    if (subiu.BarsSince() is > 5) Log("6 candles sem alta");6}

Valor inválido (NaN)

O aquecimento dos indicadores é NaN: Na diz se não é número e Nz troca por um padrão.

1var variacao = Nz(Closes.Change(5), 0);

Cruzamento para cima e para baixo

Cruzamento neste candle, entre duas séries ou entre uma série e um nível.

1private Sma curta = null!, longa = null!;2public override void OnStart() { curta = new Sma(9); longa = new Sma(21); }3public override void OnBarClose()4{5    curta.Update(Current); longa.Update(Current);6    if (Crossed.Above(curta, longa) && Position.IsFlat) Buy(1);7}

Indicadores

Como usar um indicador

Crie em OnStart e avance em OnBarClose com Update(Current) (o candle) ou Update(valor) (um número). Value é o de agora, Previous o do candle anterior, IsReady diz que saiu do aquecimento. A conta é a mesma do gráfico da HTS. Indicador com várias saídas expõe cada uma (Upper, Lower, Signal...) e o histórico com ...Ago(n). A lista completa, com um exemplo de cada, está na referência no fim deste manual.

1private Bollinger bb = null!;2public override void OnStart() { bb = new Bollinger(20, 2); }3public override void OnBarClose()4{5    bb.Update(Current.Close);6    if (!bb.IsReady) return;7    if (Position.IsFlat && Current.Close < bb.Lower) Buy(1);8    else if (Position.IsLong && Current.Close > bb.Value) ClosePosition();9}

O gráfico

Desenhar uma série

Desenha um valor da série nome neste candle: linha, histograma, pontos, área, degrau, cruz ou colunas. Plot(nome, valor, cor) pinta só este ponto (cor por valor).

1Plot("Amplitude", Current.Range, PlotStyle.Histogram);2Plot("Fechamento", Current.Close, Current.IsBullish ? "#22c55e" : "#ef4444");

Aparência padrão da série

A aparência padrão da série; a pessoa ainda troca na "Aparência".

1StylePlot("Fechamento", "#f59e0b", 2);

Preencher entre duas séries

Preenche entre duas séries, com cor própria (com transparência, ex.: rgba(...)).

1Plot("Máxima", Current.High);2Plot("Mínima", Current.Low);3FillBetween("Máxima", "Mínima", "rgba(120,120,255,0.1)");

Linha horizontal

Uma linha horizontal fixa.

1HLine(70, "#888888", "sobrecompra");

Pintar o candle e o fundo

Pinta o candle ou o fundo deste candle.

1if (Current.Range > 300) PaintCandle("#f59e0b");2if (Now.HHMM < 930) BackgroundColor("rgba(255,255,255,0.04)");

Marca no candle

Seta, ponto ou texto acima ou abaixo do candle.

1if (Current.IsBullish) Mark("C", MarkerPosition.Below, MarkerShape.Arrow, "#22c55e");

Linha e caixa

Linha ou caixa entre dois pontos (candles atrás, valor).

1if (Candles.Count > 10) DrawLine(10, Candles[^11].Close, 0, Current.Close, "#ffffff");

Tabela no painel

Uma célula fixa no canto do painel.

1Table(0, 0, $"Fechamento {Current.Close:0}");

Indicador sobre o preço

Na classe do indicador, põe as séries sobre o preço; sem ele, o indicador ganha um painel próprio. Cores: "#rrggbb" (ou #rgb, #rrggbbaa, rgba(...)). Limites: 16 séries, 5.000 marcas, 500 desenhos, 50 níveis.

1[Overlay]2public class MediaNoPreco : Robot3{4    private Sma media = null!;5    public override void OnStart() { media = new Sma(20); }6    public override void OnBarClose() { media.Update(Current); if (media.IsReady) Plot("Média", media.Value); }7}

Parâmetros

Parâmetro editável

Em um campo público, torna o valor editável na tela (automação, backtest e gráfico). Tipos: int, double, bool, string e qualquer enum seu (vira lista). No atributo: Min, Max, Step, Group, Description, Options (string vira lista) e Format (Time para int HHMM; Color, Symbol, Timeframe para string). Valor fora da faixa é erro na tela, nunca ajuste calado.

1[Parameter("Contratos", Min = 1, Max = 10, Group = "Risco")] public int Contratos = 1;2[Parameter("Zerar às", Format = ParameterFormat.Time)] public int ZerarAs = 1740;3[Parameter("Lado", Options = new[] { "Compra", "Venda" })] public string Lado = "Compra";

Registros e alertas

Registro no diário

Vai para o diário do backtest e da automação; com LogLevel muda a cor.

1Log($"fechou em {Current.Close:0}");2Log("perto do stop diário", LogLevel.Warning);

Alerta

Chama a atenção na hora: toast, bipe e o sino de Avisos no HTS, e uma seta no gráfico quando é indicador.

1if (Current.Range > 500) Alert("candle de mais de 500 pontos");

Resultado e operações

Resultado da automação

O resultado da automação: Day (realizado de hoje), Open (aberto), DayWithOpen (o que a meta e o stop diário olham), Total, DayDrawdown e DayRunup. O robô não lê o saldo da conta.

1if (Pnl.DayWithOpen <= -500 && !Position.IsFlat) ClosePosition();

Operações fechadas

As operações fechadas, com entrada, saída, contratos, resultado, Points, Mfe e Mae (maior excursão a favor e contra).

1if (LastTrade is Trade t && t.Profit < 0) Log($"última perdeu {t.Points:0} pontos");2var ganhosHoje = TradesToday.Count(x => x.Profit > 0);

Ganhos e perdas seguidos

Ganhos e perdas seguidos, hoje.

1var contratos = ConsecutiveLosses >= 2 ? 1 : 2;2if (Position.IsFlat && Current.IsBullish) Buy(contratos);

Bibliotecas

Código compartilhado

Um código sem robô dentro (só classes, structs, enums). Compile-a; a partir daí ela entra em todo robô e indicador seu na próxima compilação deles. Um problema dentro da biblioteca aparece na lista com o nome dela.

1public static class Risco2{3    public static int Contratos(double perdaMaxima, double stopEmPontos, double valorDoPonto) =>4        Math.Max(1, (int)(perdaMaxima / (stopEmPontos * valorDoPonto)));5}

O que o código não pode usar

Arquivo, rede, reflexão, threads, processos, relógio (DateTime), aleatório, Console, unsafe, dynamic, extern. O compilador recusa com a linha e explica a troca (DateTime → Now, por exemplo). Cada chamada do robô ao vivo tem um limite de tempo (5 s): um laço infinito para o robô, não a plataforma.

Backtest

Escolha ativo, tempo gráfico e dias; patrimônio, slippage em ticks, corretagem por contrato, posição máxima, zerar no fim do dia e as mesmas regras da automação. O resultado traz métricas (líquido, acerto, payoff, fator de lucro, drawdown máximo), a curva, a lista de trades com MEP/MEN, as execuções, o diário e as recusas do motor. O backtest roda no HTS desktop (precisa do .NET do HTS, instalado uma vez).

Exemplos

O código de cada exemplo está na aba Exemplos do HT Code: abra, leia e use "Copiar código" para levar o código (ou partes dele) para o seu. Todos compilam e rodam como estão.

Primeiros passos

• Cruzamento de médias com stop e alvo — O robô mais simples que vale a pena: compra quando a média curta cruza a longa para cima, vende quando cruza para baixo, sempre com stop e alvo em pontos. Só opera dentro do horário e zera no fim do dia pela regra da automação.
• Uma biblioteca compartilhada e o robô que a usa (dois códigos) — A biblioteca é um código sem robô dentro (vai para "Bibliotecas" no explorador). Compilada, entra em todo robô e indicador seu na próxima compilação deles. Aqui os dois aparecem juntos só para facilitar a leitura; no HT Code a biblioteca é um código e o robô é outro.
• Compra no candle de alta forte, com stop e alvo — O primeiro robô de verdade: quando o candle fecha de alta com corpo grande (força compradora), compra a mercado e já deixa stop e alvo em pontos. Ensina a ler o candle atual (Current), o anterior (CandleAgo) e a conferir se está zerado antes de entrar.
• Janela de horário e número de contratos como parâmetros — Opera só entre o início e o fim escolhidos (horário de Brasília) e zera tudo no "zerar às", sem depender da regra da automação. A entrada é simples (rompe a máxima ou a mínima do candle anterior); o foco é mostrar parâmetros de horário (Format = Time), Now.Between, Now.HHMM e o limite de entradas por dia (EntriesToday).
• Indicador mínimo que plota uma média no gráfico — Um indicador é um código que não manda ordem: só calcula e desenha. Com [Overlay], a linha fica sobre o preço (sem [Overlay], ganha um painel próprio embaixo). Ensina o ciclo básico: criar no OnStart, alimentar com Update no OnBarClose, esperar o aquecimento (IsReady) e plotar com cor e espessura.
• Stop e alvo pelo preço executado, no OnFill, com Log — Em vez de stop e alvo em pontos logo depois do Buy, o robô espera a execução chegar (OnFill) e calcula stop e alvo a partir do PREÇO EXECUTADO (StopLossAt/TakeProfitAt). Ensina a dar nome à ordem, a distinguir a entrada da saída pelo nome e pela origem (Source) e a registrar tudo no Log.

Tendência e médias

• Cruzamento de médias com filtro de ADX — Cruzamento de médias sozinho apanha muito no lateral. Aqui ele só vale quando o ADX mostra tendência (acima do mínimo) e o DI+ ou o DI- confirma o lado. Ensina a combinar dois indicadores: um que dá o sinal e outro que filtra quando o sinal merece confiança.
• SuperTrend seguindo a tendência (sempre posicionado) — O SuperTrend troca de lado quando o preço fecha além da banda de ATR. O robô fica comprado na alta e vendido na baixa, virando a mão (Reverse) na troca. Ensina FlippedNow/IsUptrend, a virada de mão e a usar a própria linha do indicador como stop (StopLossAt), que anda junto a cada candle.
• HiLo Activator com saída parcial — O HiLo compara o fechamento com a média das máximas e das mínimas: fechou acima, tendência de alta; abaixo, de baixa. O robô entra na virada com 2 contratos, realiza metade (ClosePartial) quando anda o alvo parcial e deixa o resto correr até o HiLo virar. Ensina saída em duas etapas e a medir os pontos a favor pelo preço médio.
• SAR parabólico com stop no próprio SAR — Entra na virada do SAR a favor de uma média longa (só compra acima dela, só vende abaixo) e usa o ponto do SAR como stop móvel: a cada candle o stop sobe (ou desce) junto. Ensina a mover o stop por preço com StopLossAt e a filtrar o sinal de virada pelo lado da tendência maior.
• Ichimoku, compra acima da nuvem — Compra quando a Tenkan cruza a Kijun para cima com o preço acima da nuvem (tendência de alta confirmada) e vende no espelho abaixo dela. Sai quando o preço volta para dentro da nuvem. Ensina as linhas do Ichimoku (a nuvem de hoje foi projetada 26 candles atrás), o preenchimento entre duas séries (FillBetween) e a saída por condição.
• Pullback na EMA em tendência, com KAMA contra a lateralidade — Em tendência, o preço costuma voltar à média e seguir. O robô compra quando a mínima toca a EMA e o candle fecha de volta acima dela. A KAMA (média adaptativa, quase parada no lateral) serve de filtro: se ela andou pouco nos últimos candles, o mercado está de lado e o robô não entra. Ensina filtro de lateralidade pela inclinação de uma média.

Rompimentos e canais

• Rompimento da máxima da abertura, com horário e calendário — Espera os primeiros minutos do pregão, marca a máxima e a mínima desse trecho e compra o rompimento. Mostra o uso de Now/Today, MinutesSinceOpen, B3Calendar (não opera na véspera de vencimento) e as séries dos candles.
• Canal de Donchian 20 (a regra das tartarugas) — Compra quando o fechamento passa da máxima dos últimos 20 candles e vende quando perde a mínima. A saída é pelo canal curto do lado oposto (10 candles): sem alvo fixo, deixa a tendência correr. Ensina a comparar com o canal do candle ANTERIOR (UpperAgo/LowerAgo), senão o candle de agora nunca rompe a própria máxima.
• Bollinger squeeze e rompimento — Volatilidade baixa costuma anteceder movimento forte. O robô guarda a largura das bandas numa série própria (Series) e marca "aperto" quando ela é a menor dos últimos N candles. Depois de um aperto, compra o fechamento acima da banda superior (ou vende abaixo da inferior). Ensina a criar uma série sua e a usar Lowest/BarsSince sobre ela.
• Rompimento da máxima e da mínima do dia anterior — A máxima e a mínima de ontem são níveis que todo mundo olha. O robô compra o primeiro fechamento acima da máxima de ontem e vende o primeiro abaixo da mínima, no máximo uma vez por lado no dia. Ensina PreviousDay (o candle diário de ontem montado a partir do histórico), o controle "uma vez por dia" com Today e HLine para marcar os níveis.
• Opening range com BuyStop e SellStop pendentes — Marca a máxima e a mínima dos primeiros minutos do pregão e, ao fim desse trecho, deixa uma compra stop acima e uma venda stop abaixo, uma única vez no dia. A que executar cancela a outra e ganha stop no lado oposto da faixa. Pendente que não executou até o meio-dia é cancelada. Ensina ordens pendentes com nome, OnFill e Cancel por horário.
• Rompimento do canal de Keltner com stop pelo ATR — Compra o fechamento acima da banda superior do Keltner e vende abaixo da inferior. Stop e alvo não são fixos: valem um múltiplo do ATR do momento, arredondado ao tick de 5 pontos do WIN. Em dia agitado o stop abre, em dia calmo fecha. Ensina risco proporcional à volatilidade e a limitar o stop entre um mínimo e um máximo.

Reversão e osciladores

• IFR com as regras da automação, resultado do dia e alerta — Compra IFR sobrevendido e vende sobrecomprado. Lê as regras da automação (não entra perto do "zerar às"), o resultado do dia (para de abrir depois de 2 perdas seguidas por conta própria) e avisa com Alert quando entra.
• Bollinger, volta para a média — Quando o candle fecha fora da banda e o seguinte fecha de volta para dentro, o robô aposta na volta à média: o alvo não é fixo, é a linha do meio da banda, que anda a cada candle. Ensina a ler as bandas do candle anterior (LowerAgo, UpperAgo) e a sair por condição, deixando o stop em pontos só como proteção.
• Estocástico cruzando em zona extrema — Compra quando a linha %K cruza a %D para cima com as duas abaixo de 20 e vende no espelho, acima de 80. Ensina a cruzar duas linhas do MESMO indicador (K e D, com o valor do candle anterior em [1] e DAgo(1)) e a exigir que o cruzamento aconteça dentro da zona: cruzar no meio do caminho não vale.
• Williams %R a favor da tendência — Reversão curta dentro da tendência maior: com o preço acima da média de 50, compra quando o %R sai de baixo de −80 (correção acabando); abaixo da média, vende quando sai de cima de −20. Ensina a combinar um oscilador (que vai de −100 a 0) com um filtro de tendência e a proteger o lucro com BreakEven (stop vai para a entrada depois de andar a favor).
• CCI voltando de −100 e de +100 — Compra quando o CCI volta para cima de −100 e vende quando volta para baixo de +100; a saída é o CCI cruzar o zero (a "volta" terminou), com stop em pontos por segurança. Ensina a sair pelo próprio indicador e a limitar o número de entradas por dia (EntriesToday), coisa que todo robô de reversão precisa em dia de tendência forte.
• Divergência de IFR no fundo — O preço faz um fundo mais baixo que o anterior, mas o IFR faz um fundo mais alto: a venda está perdendo força. O robô acha os fundos com Swings (um fundo só é confirmado alguns candles depois, quando o preço já subiu dos dois lados) e lê o IFR no candle do fundo com ifr[atraso]. Ensina a guardar o "fundo anterior" e comparar dois pontos no tempo.

Fluxo: negócio, agressão e book

• Ao vivo, por negócio e book (só no HTS desktop) — OnBook só chama ao vivo; OnTick chama ao vivo e, no backtest, em cada ponto da lupa de 1m (negócio sintético, sem agressor: aqui o robô não entra no backtest). Compra quando o book mostra mais compra do que venda nos 3 primeiros níveis e o último negócio foi agressão de compra; sai no stop/alvo do motor. A entrada da chamada seguinte espera a anterior chegar à posição: o motor garante.
• Saldo de agressão do candle como gatilho (só ao vivo) — Aggression soma a agressão desde que o robô ligou; guardando o saldo no começo de cada candle, a diferença no fechamento é o saldo DAQUELE candle. Compra quando o candle fecha de alta com saldo de compra acima do mínimo e vende no espelho. No backtest a agressão é sempre zero: o robô roda, mas não entra (o candle não diz quem agrediu).
• Desequilíbrio do book, com spread fechado (só ao vivo) — Lê o book em OnBook de dois jeitos: só o melhor nível (BestBid × BestAsk) e a soma dos 3 primeiros. Entra no OnTick quando os dois apontam o mesmo lado e o spread está fechado: spread aberto (mais que N ticks) é mercado sem liquidez, e aí não entra. No backtest não existe book: o robô roda sem entrar.
• Lotes grandes em sequência (só ao vivo) — Conta negócios grandes (lote acima de N) agredindo o mesmo lado, um atrás do outro, dentro de poucos segundos: é o "player" entrando. Um lote grande do lado contrário zera a contagem. Ensina a guardar estado entre chamadas do OnTick e a usar o horário do negócio (TimeMs). No backtest a quantidade vem 0 e o agressor desconhecido: nunca conta.
• VWAP do dia com confirmação da agressão — Compra quando o preço volta para cima da VWAP do dia e vende quando perde a VWAP; ao vivo, só entra se o saldo de agressão do candle confirmar o lado. Sem agressão (backtest), cai para a confirmação pelo próprio candle. Ensina a escrever um robô que funciona nos dois mundos: o fluxo melhora o sinal quando existe, e o sinal não depende dele.
• Tape reading pela velocidade dos negócios (só ao vivo) — Conta em RecentTicks quantos negócios saíram no último minuto e para onde o preço foi nesse minuto. Mercado acelerando (muito mais negócios que o normal) e andando para um lado: entra a favor. Ensina a percorrer RecentTicks do mais novo para o mais antigo e a parar no corte de tempo. No backtest RecentTicks vem vazio: o robô roda sem entrar.
• Absorção: muita agressão e o preço não anda (só ao vivo) — Se o vendedor agride forte num candle e mesmo assim o preço não cai (candle pequeno, fechando no terço de cima), tem alguém grande comprando no limite: a venda foi absorvida. O robô compra (e vende no espelho). Ensina a cruzar o fluxo com a forma do candle e a comparar com a amplitude média. No backtest não há agressão: o robô roda sem entrar.

Quant e estatística

• Z-score do preço (reversão à média) — O z-score mede quantos desvios-padrão o fechamento está longe da média: z = (preço − média) / desvio. Abaixo de −2 o preço está "esticado" para baixo; o robô compra quando o z volta a subir e sai quando chega a zero (a média). Ensina Closes.Average e Closes.StdDev e a guardar o próprio indicador numa Series para comparar com o candle anterior.
• Regime de volatilidade (só opera no meio da distribuição) — Guarda o ATR de cada candle numa Series e calcula, sobre os últimos 200, os percentis 30 e 80. Mercado parado demais (abaixo do 30) não paga o stop; nervoso demais (acima do 80) violina. Fora dessa faixa o cruzamento de médias é ignorado. Ensina Percentile como filtro de regime, que serve para qualquer estratégia.
• Momentum de séries temporais — Fica do lado do retorno dos últimos N candles: retorno positivo, comprado; negativo, vendido. Para não virar a mão a cada ruído, o retorno é dividido pela volatilidade (HistoricalVolatility) e só conta quando passa de um limiar. Ensina PercentChange, HistoricalVolatility e Reverse (vira a posição numa ordem só).
• Regressão linear com R² como filtro — Ajusta uma reta aos últimos N fechamentos. A inclinação (Slope) diz a direção, em pontos por candle; o R² (0 a 1) diz quanto a reta explica o preço: perto de 1 é tendência limpa, perto de 0 é bagunça. Só opera com R² alto, comprando o recuo até a reta na alta e vendendo o repique na baixa. Ensina LinearRegression, Slope, R2 e Forecast.
• Correlação WIN × WDO — Índice e dólar costumam andar em sentidos opostos. O robô lê o WDO de 5m com [UsesSeries], calcula a correlação dos retornos dos dois e, com correlação bem negativa, só compra WIN se o dólar caiu no candle (e vende se subiu). No backtest a tela manda o WDO pronto (as barras do gráfico); sem candles do dólar (sem histórico no período, ou no começo do pregão), o robô avisa uma vez e opera sem o filtro. Ensina Correlation e Series.
• Rompimento por percentil 95 da amplitude — Um candle "fora da curva" é o que tem amplitude maior que 95% dos últimos 200. Quando ele aparece fechando perto da ponta (máxima na alta, mínima na baixa), o robô entra a favor. Ensina a calcular o percentil ANTES de incluir o candle atual (senão ele se compara consigo mesmo) e a usar a própria amplitude como medida do stop.
• Quantidade de contratos pela volatilidade — O risco em reais por operação é fixo; o que muda é o tamanho. Contratos = risco ÷ (stop em pontos × valor do ponto), com o stop em múltiplos do ATR: mercado calmo, stop curto e mais contratos; nervoso, stop longo e menos contratos. Ensina SymbolInfo.PointValue (WIN: R$ 0,20 por ponto), arredondamento e Shifted (máxima dos candles ANTERIORES).

Rastreadores de preço e alertas

• Aviso de nova máxima e nova mínima do dia — Indicador que vigia o pregão: desenha a máxima e a mínima do dia em degrau e, quando um candle fecha renovando uma delas, marca o candle e avisa com Alert. Só avisa a máxima que ficou de pé por alguns candles (em tendência, não avisa a cada candle). Ensina a guardar estado por dia (zerando na virada), CurrentDay e contadores entre candles.
• Preço tocando os pivôs do dia anterior — Calcula os pivôs clássicos com a máxima, a mínima e o fechamento de ontem (PreviousDay + Pivots.Classic) e marca o candle que encosta em um deles, com uma tolerância em pontos. Cada nível só avisa uma vez por dia. Ensina a ler o dia anterior agregado e a evitar avisos repetidos guardando o que já tocou.
• Gap de abertura contra o fechamento de ontem — No primeiro candle do dia compara a abertura com o fechamento do dia anterior. Gap maior que o mínimo vira marca, alerta e uma caixa (DrawBox) do tamanho do gap; depois acompanha se o gap foi fechado no mesmo dia. Ensina IsFirstCandleOfDay, PreviousDay e desenho entre dois pontos.
• Candle de volume anormal — Painel próprio com o volume em colunas e a linha de corte (média + N desvios-padrão dos últimos candles). O candle cujo volume passa do corte é pintado no gráfico de preço e ganha uma marca. Ensina a ler a série Volumes por posição (Volumes[1] = candle anterior), cor por valor e o cuidado de comparar com a janela ANTERIOR ao candle.
• Distância do VWAP em desvios — Painel próprio que mostra quantos desvios-padrão o fechamento está longe do VWAP do dia (um "z-score" do VWAP). Pinta o fundo quando passa de ±2 e avisa quando o preço volta de lá. Ensina Vwap (zera sozinho a cada pregão), StdDev alimentado com a diferença preço − VWAP e HLine para as faixas de referência.
• Padrões de candle marcados no gráfico — Procura martelo, estrela cadente, engolfo de alta e engolfo de baixa (Patterns, com a mesma régua do catálogo do gráfico) e marca cada um com texto e cor. Um filtro opcional só mostra o padrão a favor da média longa. Ensina a chamar Patterns com o índice do candle atual e a montar a lista de achados para uma marca só.
• Painel com o resumo do dia — Uma tabela (Table) no canto do gráfico com abertura, máxima, mínima, amplitude, variação contra o fechamento de ontem, volume e a posição do preço dentro da faixa do dia. Ensina CurrentDay e PreviousDay (agregados prontos), a grade de linhas e colunas da Table e a formatação dos números.

Gestão de risco e ordens

• Rompimento com ordens pendentes, alvo limitado e stop móvel — Ordens completas: em vez de comprar a mercado no fechamento, o robô deixa uma COMPRA STOP acima do canal e uma VENDA STOP abaixo dele. O nome é único: colocar de novo "rompe-cima" no candle seguinte SUBSTITUI a anterior (o canal anda). Quando uma executa (OnFill), cancela a outra, põe o alvo como ordem LIMITADA (só reduz a posição) e liga o stop móvel e o break-even. Pendente vale no dia: o motor cancela na virada (e avisa em OnOrderCanceled).
• Saída parcial no primeiro alvo e stop no preço de entrada — Entra com vários contratos no cruzamento de médias. Quando a posição anda o primeiro alvo a favor, realiza metade com ClosePartial e leva o stop do resto para o preço médio (StopLossAt): daí em diante a operação não perde. O resto sai no alvo final ou no stop. Ensina Position.OpenPoints, Position.Contracts e a ordem das chamadas numa decisão.
• Stop móvel pela volatilidade (ATR) — Em vez de um stop fixo em pontos, o stop fica a N vezes o ATR do preço e só anda a favor: a cada candle o robô calcula o stop novo e, se for melhor que o atual, move com StopLossAt. Mercado calmo, stop curto; mercado nervoso, stop largo. O stop aparece no gráfico como pontos. Ensina Atr, StopLossAt e o arredondamento ao tick do ativo.
• Stop diário e meta do próprio robô — Além das regras da automação, o robô vigia o resultado do dia em reais (Pnl.DayWithOpen: o realizado mais o aberto). Bateu a perda máxima ou a meta, zera, cancela as pendentes e encerra o dia por conta própria: só volta a operar no pregão seguinte. Ensina Pnl, TradesToday, guardar o dia encerrado e mostrar o placar numa Table.
• Quantidade de contratos pelo risco em reais — O tamanho da mão sai da conta: perda máxima por operação ÷ (stop em pontos × valor do ponto do ativo). Stop curto permite mais contratos, stop longo menos, e a perda em reais fica a mesma. O stop é a mínima do candle de sinal (ou a máxima, na venda). Ensina SymbolInfo.PointValue, o arredondamento para baixo e o limite de contratos.
• Compra limitada que acompanha o preço (Modify) e trata recusa e cancelamento — Em tendência de alta (preço acima da média), deixa uma COMPRA LIMITADA um pouco abaixo da mínima do último candle e, a cada candle, sobe a ordem com Modify em vez de cancelar e mandar outra. A tendência virou: cancela. Executou: stop e alvo. OnOrderCanceled e OnOrderRejected contam o que aconteceu; três recusas no dia param a pendente.

Indicadores no gráfico

• Indicador no gráfico com bandas, preenchimento e cor por valor — Sem automação (não manda ordem): vira estudo em "Meus indicadores". Mostra StylePlot, FillBetween, cor por valor, PaintCandle, BackgroundColor e a tabela (Table) no canto do painel.
• Heikin-Ashi pintando os candles do gráfico — Calcula os candles Heikin-Ashi (médias que suavizam o ruído) e pinta cada candle normal com a cor do Heikin-Ashi: verde em sequência de alta, vermelho em sequência de baixa, e uma cor mais fraca quando o Heikin-Ashi tem sombra contra a tendência (perda de força). Marca a virada de cor. Ensina HeikinAshi, CandleAgo e PaintCandle.
• Renko sobre o gráfico, com marcas de virada — Monta tijolos Renko de tamanho fixo em pontos sobre o fechamento dos candles e desenha o nível do último tijolo em degrau, com a cor do lado. Quando o Renko vira de lado, marca o candle e conta a sequência de tijolos. Ensina Renko (Bricks, NewBricks, FlippedNow, Direction) e a diferença entre o tempo do candle e o "tempo" do tijolo.
• MACD em painel próprio com histograma de quatro cores — Sem [Overlay], o indicador ganha um painel com escala própria. Plota a linha do MACD, a linha de sinal e o histograma colorido pelo sinal E pela força: verde forte subindo, verde fraco caindo, vermelho forte descendo, vermelho fraco voltando. Ensina Macd (Line, Signal, Histogram, HistogramAgo) e o estilo definido pelo primeiro Plot.
• Pivôs do dia (clássico, Fibonacci ou Camarilla) com zona e tabela — Calcula os pivôs com o dia anterior e desenha os sete níveis em degrau (cada dia com os seus), preenche a zona entre S1 e R1 e mostra os valores de hoje numa Table. Ensina a escolher o cálculo por parâmetro (enum), Pivots, FillBetween entre duas séries e por que níveis que mudam por dia vão em Plot (degrau), e não em HLine.
• Canal de regressão linear com preenchimento — Ajusta uma reta aos últimos N fechamentos (mínimos quadrados) e desenha a linha central e as bandas a N erros-padrão, com a área entre elas preenchida. A cor da linha central segue a inclinação, e o candle que fecha fora do canal é pintado. Ensina RegressionChannel (Upper, Lower, Slope), LinearRegression.R2 e FillBetween.

Referência da API

Tudo o que o robô pode usar está aqui; o resto o compilador recusa.

API · Robô e contexto

O robô

A classe-base de todo robô da HTS. Seu robô herda dela, declara os parâmetros com ParameterAttribute e escreve a decisão em OnBarClose (no fechamento de cada candle) e, se quiser entrar no meio do candle assim que a condição bater, em OnTick (a cada negócio). Regras que o motor garante e que o robô não precisa (nem consegue) burlar: uma chamada por evento: candle fechado (OnBarClose) e, se o robô implementar, negócio (OnTick) e book (OnBook). No backtest o OnTick também roda: o motor anda DENTRO de cada candle pelos candles de 1m (abertura, máxima e mínima na ordem provável, fechamento; sem 1m, os 4 pontos do próprio candle) e chama o robô em cada ponto; numa chamada, quantas ordens a mercado o robô quiser (Buy, Sell, ClosePosition, ClosePartial, Reverse), até 20 (a 21ª é recusada: ORDENS_DEMAIS). Elas saem em sequência e cada uma é conferida pela posição que as anteriores deixam: Buy(1); ClosePosition(); compra e zera; entre chamadas, a entrada nova espera a anterior chegar à posição (ao vivo): o robô que compra "enquanto zerado" a cada negócio não dobra a mão. A recusa vem com ORDEM_EM_ANDAMENTO; pendentes (limite, stop, stop-limite): até 20, com nome único, valem no dia; as regras da automação (horário, stop diário, meta, perdas seguidas, operações, posição máxima) são do motor.

1public class CompraNoRompimento : Robot2{3    [Parameter("Stop (pontos)", Min = 50, Max = 1000)] public int Stop = 150;4    public override void OnBarClose()5    {6        // compra quando o candle fecha acima da máxima do anterior7        if (Position.IsFlat && Current.Close > Highs[1]) { Buy(1); StopLoss(Stop); }8    }9}

O contexto do robô

Tudo que o robô sabe e tudo que ele pode fazer chega por aqui. O robô nunca lê relógio, rede ou arquivo: o tempo e o preço são os do evento (o candle que fechou, ou o negócio) e a ordem vai para o motor, que decide o que executar. No backtest e ao vivo os comandos são os mesmos. ORDENS A MERCADO. Uma chamada do robô (OnBarClose, OnTick, OnBook, ou um evento de ordem que chega como chamada nova) pode mandar várias, até 20 (a 21ª é recusada: ORDENS_DEMAIS). Saem em sequência, e cada uma é conferida pela posição que as anteriores deixam (Buy(1); ClosePosition(); compra e zera; ClosePosition, ClosePartial e Reverse contam as ordens já pedidas na chamada). Ao vivo, entre uma chamada e a seguinte a entrada nova espera a anterior chegar à posição (ORDEM_EM_ANDAMENTO): nunca dobra a mão no escuro. Os eventos de ordem (OnFill, OnOrderRejected, OnOrderCanceled) também mandam a mercado; no backtest, no mesmo preço da decisão. Só depois da zeragem do fim do dia não sai ordem a mercado (MERCADO_DEPOIS_DA_DECISAO).

1// Context é o que os atalhos do robô (Candles, Position, Buy...) usam por baixo2Log($"candle {Context.Index + 1} de {Context.Candles.Count}, posição {Context.Position.Quantity}");3if (Context.Position.IsFlat && Context.Current.IsBullish) Context.Buy(1);

API · Candles, séries e mercado

Candle

Um candle fechado. Time é o início do candle em segundos Unix (UTC); a data e a hora em Brasília vêm por Timestamp. End é o fim, quando a barra traz (todos os tempos do gráfico, 01/11/2026).

1// compra no candle de alta que fecha acima da máxima do anterior2if (Candles.Count < 2) return;3var anterior = Candles[Candles.Count - 2];4if (Position.IsFlat && Current.IsBullish && Current.Close > anterior.High) Buy(1);

Negócio

Um negócio do mercado (ao vivo, cada negócio da bolsa; no backtest, um ponto da lupa de 1m). Aggressor é quem agrediu (comprador = Long); Flat = não informado.

1public override void OnTick(Tick tick)2{3    // lote grande comprando a mercado: entra junto4    if (Position.IsFlat && tick.Quantity >= 100 && tick.Aggressor == Side.Long) Buy(1);5}

Nível do book

Um nível do book: preço, quantidade e número de ordens.

1// melhor compra do book (ao vivo)2if (Book.BestBid is BookLevel compra && compra.Quantity >= 500)3    Log($"{compra.Quantity} contratos em {compra.Price} ({compra.Orders} ordens)");

Book de ofertas

O book do ativo como chegou da bolsa: compras (do melhor para o pior) e vendas (do melhor para o pior). Vazio quando ainda não chegou nada. Só leitura: é uma fotografia.

1public override void OnBook(Book book)2{3    // só entra com spread de um tick e mais compradores que vendedores no topo4    if (book.Spread != SymbolInfo.TickSize || book.BestBid is not BookLevel compra || book.BestAsk is not BookLevel venda) return;5    if (Position.IsFlat && compra.Quantity > 2 * venda.Quantity) Buy(1);6}

Período (dia, semana, mês, ano)

Período de agregação dos candles.

1// a semana até agora, a partir da lista de candles2if (Aggregates.UpToCandle(Candles, Candles.Count - 1, Period.Week) is Bar semana)3    Log($"semana: máxima {semana.High}, mínima {semana.Low}");

Barra de um período

Um período inteiro resumido (o dia, a semana, o mês ou o ano), montado dos candles do robô: abertura do primeiro candle, máxima e mínima de todos, fechamento do último, volume somado (o OpenD/HighD/LowD/CloseD do NTSL).

1// rompeu a máxima de ontem: compra2if (PreviousDay is Bar ontem && Position.IsFlat && Current.Close > ontem.High) Buy(1);

Agregação por período

Agregação de candles por período (no fuso de Brasília). Só faz contas sobre a lista de candles; não muda nada.

1// linha na máxima da semana passada2if (Aggregates.Previous(Candles, Candles.Count - 1, Period.Week) is Bar semana)3    HLine(semana.High, "#ffffff", "máxima da semana passada");

Série

Uma série alinhada aos candles: serie[0] é o valor de agora, serie[1] o do candle anterior (como close[1] no Pine). Fora do histórico, NaN. Todo indicador é uma série; o robô cria as suas com Series; os candles aparecem como séries em Closes, Highs etc. Os utilitários (Ta) valem para qualquer uma.

1private static bool SubindoHa3(ISeries s) => s[0] > s[1] && s[1] > s[2];2public override void OnBarClose()3{4    // a mesma função serve para Closes, Highs, um indicador ou uma Series sua5    if (Position.IsFlat && SubindoHa3(Closes) && SubindoHa3(Lows)) Buy(1);6}

Série própria

Uma série que o próprio robô alimenta, um valor por candle (Add em OnBarClose).

1private readonly Series _corpo = new();2public override void OnBarClose()3{4    // corpo do candle duas vezes maior que a média dos últimos 20: alerta5    _corpo.Add(Math.Abs(Current.Close - Current.Open));6    if (_corpo.Count > 20 && _corpo.Value > 2 * _corpo.Average(20)) Alert("candle de força");7}

Série de sim ou não

Uma série de sim/não alinhada aos candles (Add(cruzou) por candle): responde "há quantos candles foi a última vez" (BarsSince) e "qual era o valor de outra série da última vez" (ValueWhen).

1private readonly BoolSeries _rompeu = new();2public override void OnBarClose()3{4    // só compra até 3 candles depois de romper a máxima anterior5    _rompeu.Add(Current.Close > Highs[1]);6    if (Position.IsFlat && _rompeu.BarsSince() is int n && n <= 3 && Current.IsBullish) Buy(1);7}

Candles como série

Os candles vistos como série de um campo (Closes[1]), presos ao índice do candle atual.

1// Closes[0] é o fechamento atual, Closes[1] o do candle anterior2if (Position.IsFlat && Closes[0] > Closes.Average(20) && Closes.Rising(3)) Buy(1);3if (Position.IsLong && Closes[0] < Lows[1]) ClosePosition();

Contas de série

Os utilitários de série (o que o Pine tem em ta.* e math.*); NaN quando falta número.

1// fechou dois desvios abaixo da média de 20: compra (retorno à média)2var media = Ta.Average(Closes, 20);3var desvio = Closes.StdDev(20);4if (Position.IsFlat && Current.Close < media - 2 * desvio) Buy(1);

Valor inválido (NaN)

Números com NaN (o na/nz do Pine): o aquecimento dos indicadores é NaN.

1// no começo do histórico ainda não há 50 candles: a média vem NaN2var media = Closes.Average(50);3if (Num.Na(media)) Log("média de 50 ainda aquecendo");4// Nz troca o NaN por outro valor (aqui, o fechamento)5Plot("Média 50", Num.Nz(media, Current.Close));

API · Posição e ordens

Lado

Lado de uma posição ou de uma ordem.

1// vendido e o candle fechou de alta: sai2if (Position.Side == Side.Short && Current.IsBullish) ClosePosition();

Posição

A posição líquida do robô no ativo (netting, como na B3): uma quantidade com sinal e o preço médio. Quantidade positiva é comprado, negativa é vendido, zero é zerado.

1// comprado com 200 pontos a favor: realiza metade2if (Position.IsLong && Position.Contracts >= 2 && Current.Close - Position.AveragePrice >= 200)3    ClosePartial(Position.Contracts / 2);4Log($"aberto: R$ {Position.OpenProfit(Current.Close, SymbolInfo):0.00}");

Tipo de ordem

O tipo de uma ordem do robô. A mercado executa já; as outras ficam PENDENTES até o preço chegar (no dia).

1// já tem compra limitada no livro: não põe outra2if (PendingOrders.Any(o => o.Type == OrderType.Limit && o.Side == Side.Long)) return;3BuyLimit(1, Current.Low - 50, "pullback");

Ordem pendente

Uma ordem do robô: a pendente que está no livro (PendingOrders) ou a ordem dos eventos OnOrderRejected/OnOrderCanceled. Name é o que o robô deu (ou o automático, "limite-1", "stop-2"...); a ordem a mercado sem nome vem com "". Price é o limite (limitada e stop-limite) e StopPrice o disparo (stop e stop-limite). ReduceOnly: a ordem só diminui a posição que existia quando foi colocada (uma saída); se a posição zerar, ela cai.

1public override void OnOrderCanceled(PendingOrder order, string reason)2{3    // registra qual pendente caiu e por quê4    Log($"{order.Name}: {order.Quantity} a {order.Price ?? order.StopPrice} cancelada ({reason})");5}

Execução

Uma execução de ordem do robô, entregue em OnFill. Source diz quem mandou: "robo" (a mercado), "stop"/"alvo" (a proteção do motor), "limite", "stop_pendente" e "stop_limite" (as pendentes), "regra", "teto_diario", "fim_do_dia", "fim". Name e Comment são os da ordem (vazio sem nome). No backtest o instante é o INÍCIO do candle em que executou (como as execuções do relatório), ou a hora do ponto quando executou na lupa do OnTick; ao vivo, a hora que a corretora informou.

1public override void OnFill(Fill fill)2{3    // a limitada de entrada executou: põe stop e alvo4    if (fill.Source == "limite") { StopLoss(150); TakeProfit(300); }5    Log($"executou {fill.Quantity} a {fill.Price} às {fill.Time.HHMM}");6}

Agressão

A agressão desde que o robô ligou (só ao vivo): contratos negociados com o comprador agredindo (Buy) e com o vendedor agredindo (Sell). Negócio sem agressor informado não conta. No backtest é sempre Zero (o candle não diz quem agrediu).

1// comprador agredindo bem mais que o vendedor (ao vivo)2if (Position.IsFlat && Aggression.Delta > 500) Buy(1);3Log($"compra {Aggression.Buy}, venda {Aggression.Sell}");

Usar outra série

Declara uma série extra que o robô lê com CandlesOf: outro tempo gráfico do mesmo ativo ([UsesSeries("15m")]) ou outro ativo ([UsesSeries("WDOFUT", "5m")]). Tempos: os temporais do gráfico, em minutos (1m a 1439m: 1m, 2m, 5m, 10m, 45m...), em horas (1h a 23h: 2h, 3h, 4h...) ou D; "120m" e "2h" são a mesma série. Séries atemporais (Renko, Range...) ainda não. Até 4 séries e 2 ativos extras por robô. Ao vivo, o robô recebe o histórico e cada candle fechado dessas séries. No backtest (e no indicador do gráfico), a tela manda a série PRONTA, com as barras do gráfico daquele tempo, só as que já fecharam, sempre que o motor não a monta igual dos candles do teste: outro ativo, teste atemporal, tempo que não é múltiplo do tempo do teste e, num teste contado (2m, 10m, 45m...), a série de outra base (2m pedindo 30m). A barra pronta aparece no candle do teste que termina quando ela já terminou (a curta do fim do pregão do mesmo ativo, num teste temporal, no último candle do dia). Outro tempo do MESMO ativo, múltiplo do tempo do teste, é montado dos candles do teste pela regra do gráfico: 5m, 15m, 30m e 60m alinhados ao relógio, como o banco guarda; os outros juntam esses candles contando do início de cada pregão (45m = três de 15m). Sem histórico da série no período do teste (ou com a declaração feita com uma constante, que a tela não lê: escreva o texto), ela fica vazia no backtest, com a recusa SERIE_INDISPONIVEL e o motivo.

1[UsesSeries("60m")]2public class ATendenciaDo60 : Robot3{4    public override void OnBarClose()5    {6        // só compra a favor do último candle de 60 minutos7        var h60 = CandlesOf("60m");8        if (h60.Count > 0 && h60[h60.Count - 1].IsBullish && Position.IsFlat && Current.IsBullish) Buy(1);9    }10}

API · Ativo, tempo e calendário

Dados do ativo

O que o motor precisa saber do contrato para transformar pontos em dinheiro: o tamanho do tick e quanto vale um ponto por contrato. Os números dos futuros da B3 são os mesmos que a plataforma usa no resto do HTS.

1// quanto custa um stop de 150 pontos em 2 contratos deste ativo2var risco = SymbolInfo.ToMoney(150, 2);3Log($"{SymbolInfo.Symbol}: risco de R$ {risco:0.00}");4BuyLimit(2, SymbolInfo.RoundToTick(Current.Low - 0.3 * Current.Range), "pullback");

Dia da semana

Dia da semana, de domingo (0) a sábado (6).

1// sexta-feira zera mais cedo2if (Today.Weekday == Weekday.Friday && Now.HHMM >= 1700) ClosePosition();

Data

Uma data do calendário (sem hora), no horário de Brasília. É o "pregão" de um candle: dois candles com o mesmo Date são do mesmo dia. Compara com <, > e ==.

1// no dia do vencimento do contrato não opera2var vencimento = B3Calendar.Expiration(SymbolInfo.Symbol);3if (vencimento == Today) return;4if (Today.Weekday == Weekday.Monday && Today.Day <= 7) Log("primeira segunda-feira do mês");

Instante

Um instante, mostrado no horário de Brasília (com o horário de verão de 2008 a 2019, para o backtest antigo; sem horário de verão desde 2019). O robô não lê relógio: o instante vem SEMPRE do mercado — o início ou o fim de um candle, a hora de um negócio. Ver Now e Timestamp.

1// zera às 17:50 e não abre antes das 9:152if (Now.HHMM >= 1750) { ClosePosition(); return; }3if (Now.HHMM < 915) return;

Calendário da B3

O calendário de pregão da B3: dias úteis, feriados e vencimentos. Os feriados seguem a regra oficial (Ofício Circular da B3 de cada ano): os nacionais fixos, Carnaval (segunda e terça), Sexta-feira Santa e Corpus Christi (pela Páscoa), Consciência Negra (20/11, desde 2024), e os dias sem sessão de 24/12 e 31/12. Os feriados municipais de São Paulo (25/01, 09/07) têm pregão desde 2022. Quarta-feira de Cinzas tem pregão, a partir das 13h.

1if (!Today.IsBusinessDay) return;2var du = B3Calendar.BusinessDaysBetween(Today, B3Calendar.Expiration("WINZ26")!.Value);3if (du <= 1) { ClosePosition(); return; } // não carregar no dia do vencimento

API · Regras e resultado

Estado do pregão

O estado do pregão do ativo, informado pela bolsa (ao vivo). No backtest é sempre Unknown.

1// em leilão não abre posição2if (Session == SessionState.Auction) return;3if (Position.IsFlat && Current.IsBullish) Buy(1);

Regras da automação

As regras da automação, escolhidas na tela "Meus robôs" e vigiadas pelo MOTOR: o robô lê (Rules), mas não precisa nem consegue burlar. Regra nunca bloqueia saída. Horário em HHMM de Brasília (1740 = 17:40); dinheiro em reais; null = sem a regra. StartTime/NoEntryAfter: a janela de entrada; FlattenAt: zera e encerra o dia; PauseInAuction: não abre com o ativo em leilão; WaitAfterOpen: não abre nos primeiros N minutos do pregão (desde o primeiro candle do dia); DailyTarget/DailyStop: realizado + aberto do dia atinge → zera e encerra o dia; MaxConsecutiveLosses: N fechamentos seguidos com perda → zera e encerra o dia; MaxEntriesPerDay: entradas (a partir de zerada) por dia; MaxPosition: contratos, em módulo.

1// fora da janela de entrada da tela, nem tenta2if (!Rules.CanEnterAt(Now.HHMM) || !Rules.OpeningWaitPassed(MinutesSinceOpen)) return;3var maximo = Rules.MaxPosition ?? 1;4if (Position.Contracts < maximo && Current.IsBullish) Buy(1);

Operação fechada

Uma operação fechada (de zerado a zerado, ou até a virada de mão). Tempos em segundos Unix. Dinheiro pela especificação do contrato; Mfe/Mae são a maior excursão a favor (≥ 0) e contra (≤ 0) enquanto a operação esteve aberta (pela máxima/mínima dos candles no backtest; pelos negócios ao vivo).

1// depois de uma perda, espera o próximo candle de alta para voltar2var ultima = LastTrade;3if (ultima is not null && ultima.Profit < 0 && !Current.IsBullish) return;4if (ultima is not null) Log($"última: {ultima.Points} pontos, R$ {ultima.Profit:0.00}");

Resultado da automação

O resultado da automação, só leitura. Day é o realizado de hoje (no backtest já com corretagem; ao vivo, o realizado do robô na conta); Open é a posição ao preço de agora; Total é o realizado desde o início (do backtest; ao vivo, desde que o robô foi ligado). Drawdown e runup são a maior queda e a maior subida de DayWithOpen no dia, em dinheiro (≥ 0).

1// ganhou R$ 300 no dia (realizado + aberto): zera e para de entrar2if (Pnl.DayWithOpen >= 300) { ClosePosition(); return; }3Log($"dia: R$ {Pnl.Day:0.00}, aberto: R$ {Pnl.Open:0.00}");

API · Gráfico

Estilo do desenho

Como uma série plotada por Plot é desenhada no gráfico. A cor padrão pode vir do código (StylePlot), e o gráfico deixa trocar na "Aparência".

1// volume como histograma e a média dele como linha2Plot("Volume", Current.Volume, PlotStyle.Histogram);3Plot("Volume médio", Volumes.Average(20), PlotStyle.Line);

Posição da marca

Onde a marca fica em relação ao candle.

1// seta verde abaixo do candle que rompeu a máxima anterior2if (Current.Close > Highs[1]) Mark("rompeu", MarkerPosition.Below, MarkerShape.Arrow, "#22c55e");

Forma da marca

A forma da marca: seta apontando para o candle, ponto, ou só o texto.

1// ponto acima de todo candle sem corpo (doji)2if (Math.Abs(Current.Close - Current.Open) <= SymbolInfo.TickSize) Mark("doji", MarkerPosition.Above, MarkerShape.Dot);

Nível do registro

O nível de um registro do robô: Info é o Log de sempre; Alert é o Alert(...), que no HTS vira aviso na tela (toast, som e sino) e marca no gráfico.

1// perto do stop diário: registra como aviso2if (Pnl.DayWithOpen < -200) Log("perto do stop diário", LogLevel.Warning);

Sobre o preço

Na classe do indicador: as séries plotadas vão SOBRE o preço (média, banda, VWAP), na escala do preço. Sem o atributo, o indicador ganha um painel próprio com escala livre (MACD, RSI, oscilador).

1[Overlay]2public class MediaDe20 : Robot3{4    // a média aparece em cima dos candles, na escala do preço5    public override void OnBarClose() => Plot("Média 20", Closes.Average(20));6}

API · Parâmetros

Formato do parâmetro

O formato de um parâmetro de texto ou de hora: diz à tela que campo mostrar e ao motor o que aceitar. Time vale para int (HHMM, 1740 = 17:40; a tela mostra HH:MM); os outros para string.

1[Parameter("Zerar às", Format = ParameterFormat.Time)] public int ZerarAs = 1740;2[Parameter("Cor da média", Format = ParameterFormat.Color)] public string Cor = "#22c55e";3public override void OnBarClose()4{5    if (Now.HHMM >= ZerarAs) ClosePosition();6    Plot("Média 20", Closes.Average(20), Cor);7}

Parâmetro

Marca um campo ou propriedade pública do robô como parâmetro ajustável pela tela, dentro dos limites definidos aqui. Tipos aceitos: int, double, bool, string (texto; com Options vira lista) e qualquer enum seu (lista de opções pelo nome).

1[Parameter("Período da média curta", Min = 2, Max = 200, Step = 1, Group = "Médias")]2public int PeriodoCurto = 9;3public enum Modo { Tendencia, Reversao }4[Parameter("Modo")] public Modo ModoDeOperacao = Modo.Tendencia;5[Parameter("Zerar às", Format = ParameterFormat.Time)] public int ZerarAs = 1740;

API · Indicadores

Amplitude média (ATR)

ATR de Wilder sobre o true range. O aquecimento é a média simples dos primeiros N true ranges e só então entra a suavização recursiva, como no gráfico da HTS: é assim que o número bate com o das outras plataformas. O primeiro candle (sem anterior) conta com true range = máxima − mínima.

1private Atr atr = null!;2private Ema media = null!;3public override void OnStart() { atr = new Atr(14); media = new Ema(21); }4public override void OnBarClose()5{6    atr.Update(Current);7    media.Update(Current.Close);8    // stop de 2 ATRs na entrada9    if (atr.IsReady && Position.IsFlat && Crossed.Above(Closes, media)) { Buy(); StopLoss(2 * atr.Value); }10}

Bandas de Bollinger

Bandas de Bollinger: média simples no meio e bandas a Multiplier desvios-padrão (populacional) de distância. A conta é a do gráfico da HTS: desvio-padrão populacional dos últimos N valores. Value é a média; as bandas ficam em Upper e Lower.

1private Bollinger bandas = null!;2public override void OnStart() { bandas = new Bollinger(20, 2); }3public override void OnBarClose()4{5    bandas.Update(Current.Close);6    if (!bandas.IsReady) return;7    // volta à média: compra abaixo da banda inferior, zera na média8    if (Position.IsFlat && Current.Close < bandas.Lower) Buy();9    else if (Position.IsLong && Current.Close >= bandas.Middle) ClosePosition();10}

Saída de um indicador

Uma saída secundária de indicador (banda, sinal, histograma), com histórico alinhado aos candles.

1private Keltner canal = null!;2public override void OnStart() { canal = new Keltner(20, 10, 2); }3public override void OnBarClose()4{5    canal.Update(Current);6    // a banda superior é uma série: dá para ler o histórico e cruzar7    Output superior = canal.UpperSeries;8    if (Position.IsFlat && Crossed.Above(Closes, superior)) Buy();9}

Canal de Keltner

Canal de Keltner: EMA do fechamento no meio e bandas a Multiplier·ATR, como o Keltner no gráfico. A média (Value) existe desde o primeiro candle; as bandas ficam NaN enquanto o ATR aquece (N − 1 candles do período do ATR).

1private Keltner canal = null!;2public override void OnStart() { canal = new Keltner(20, 10, 2); }3public override void OnBarClose()4{5    canal.Update(Current);6    if (double.IsNaN(canal.Upper)) return;7    // rompimento da banda de cima, com stop na média8    if (Position.IsFlat && Current.Close > canal.Upper) { Buy(); StopLoss(Current.Close - canal.Middle); }9}

Canal de Donchian

Canal de Donchian: a maior máxima e a menor mínima dos últimos N candles (contando o atual) e o meio entre as duas, como o Donchian no gráfico. Value é o Middle. NaN até ter N candles.

1private Donchian canal = null!;2public override void OnStart() { canal = new Donchian(20); }3public override void OnBarClose()4{5    canal.Update(Current);6    // tartaruga: compra no rompimento da máxima dos 20 candles anteriores, sai no meio do canal7    if (Position.IsFlat && Current.Close > canal.UpperAgo(1)) Buy();8    else if (Position.IsLong && Current.Close < canal.Middle) ClosePosition();9}

Envelope de média

Envelope: média simples com bandas a Percent% acima e abaixo, como o Envelope no gráfico. Value é a média. NaN até ter N valores.

1private Envelope envelope = null!;2public override void OnStart() { envelope = new Envelope(20, 0.5); }3public override void OnBarClose()4{5    envelope.Update(Current.Close);6    if (!envelope.IsReady) return;7    // esticou 0,5% acima da média: vende buscando a volta8    if (Position.IsFlat && Current.Close > envelope.Upper) Sell();9    else if (Position.IsShort && Current.Close <= envelope.Middle) ClosePosition();10}

Cruzamento

Cruzamentos entre duas séries (indicador, Series, Closes...), ou entre uma série e um nível fixo. Um cruzamento só existe quando os dois valores (de agora e do candle anterior) são números: no aquecimento a resposta é sempre false.

1private readonly Ema _rapida = new(9);2private readonly Ema _lenta = new(21);3public override void OnBarClose()4{5    _rapida.Update(Current);6    _lenta.Update(Current);7    if (Position.IsFlat && Crossed.Above(_rapida, _lenta)) Buy(1);8    else if (Position.IsLong && Crossed.Below(_rapida, _lenta)) ClosePosition();9}

Heikin-Ashi

Heikin-Ashi: os candles "médios", um por candle de verdade. Fechamento = (A + M + m + F) / 4; abertura = média da abertura e do fechamento do Heikin-Ashi anterior (o primeiro usa (A + F) / 2 do candle real); máxima e mínima incluem a abertura e o fechamento novos. Value é o fechamento HA; o candle inteiro está em Current e o histórico em CandleAgo. O tempo e o volume são os do candle real.

1private HeikinAshi ha = null!;2public override void OnStart() { ha = new HeikinAshi(); }3public override void OnBarClose()4{5    ha.Update(Current);6    // primeiro candle Heikin-Ashi de alta depois de um de baixa: compra7    if (ha.CandleAgo(1) is Candle anterior && ha.IsBullish && anterior.IsBearish && Position.IsFlat) Buy();8    else if (Position.IsLong && !ha.IsBullish) ClosePosition();9}

Tijolo do Renko

Um tijolo do Renko: de onde saiu, até onde foi, o lado e o candle (tempo) em que fechou.

1private Renko renko = null!;2public override void OnStart() { renko = new Renko(100); }3public override void OnBarClose()4{5    renko.Update(Current);6    // o último tijolo fechado: lado e preços7    if (renko.NewBricks > 0 && renko.Last is Brick tijolo)8        Log($"Tijolo {tijolo.Side}: {tijolo.Open} a {tijolo.Close}");9}

Renko

Renko: tijolos de tamanho fixo em pontos sobre o FECHAMENTO dos candles. Um tijolo novo no mesmo sentido precisa andar Size além do topo (ou fundo) do último; a reversão precisa de 2 × tamanho (a regra clássica: o tijolo contrário começa do outro lado do último). Um candle pode fechar vários tijolos (ou nenhum). Value é o fechamento do último tijolo, repetido nos candles sem tijolo novo; NewBricks diz quantos fecharam neste candle.

1private Renko renko = null!;2public override void OnStart() { renko = new Renko(100); }3public override void OnBarClose()4{5    renko.Update(Current);6    // virada do Renko de 100 pontos: segue o lado do tijolo novo7    if (renko.FlippedNow && renko.Direction == Side.Long) { ClosePosition(); Buy(); }8    else if (renko.FlippedNow && renko.Direction == Side.Short) { ClosePosition(); Sell(); }9}

Máxima de N candles

A maior máxima dos últimos N candles (contando o atual). NaN até ter N candles.

1private Highest maxima = null!;2public override void OnStart() { maxima = new Highest(20); }3public override void OnBarClose()4{5    maxima.Update(Current);6    // rompimento: fechou acima da maior máxima dos 20 candles anteriores7    if (Position.IsFlat && Current.Close > maxima[1]) Buy();8}

Mínima de N candles

A menor mínima dos últimos N candles (contando o atual). NaN até ter N candles.

1private Lowest minima = null!;2public override void OnStart() { minima = new Lowest(10); }3public override void OnBarClose()4{5    minima.Update(Current);6    // saída da compra: fechou abaixo da menor mínima dos 10 candles anteriores7    if (Position.IsLong && Current.Close < minima[1]) ClosePosition();8}

Ichimoku

Ichimoku Kinko Hyo: Tenkan (meio da faixa de 9), Kijun (meio da faixa de 26), Senkou A (média das duas) e Senkou B (meio da faixa de 52), as duas últimas desenhadas 26 candles À FRENTE, e Chikou (o fechamento de agora, desenhado 26 candles ATRÁS). Mesma conta do Ichimoku no gráfico; o deslocamento é o período do Kijun, como no sistema original. Para o robô, o que importa é a nuvem SOB O CANDLE ATUAL: SenkouA e SenkouB são os valores calculados 26 candles atrás, que é onde o gráfico os desenha hoje ("preço acima da nuvem" = Close > Math.Max(SenkouA, SenkouB)). SenkouAFuture e SenkouBFuture são os calculados agora, a nuvem daqui a 26 candles. Chikou é o fechamento de agora e CloseAtChikou o fechamento de 26 candles atrás, que é com quem o Chikou se compara no gráfico. Value é o Tenkan.

1private Ichimoku ichi = null!;2public override void OnStart() { ichi = new Ichimoku(9, 26, 52); }3public override void OnBarClose()4{5    ichi.Update(Current);6    // Tenkan cruzou o Kijun para cima com o preço acima da nuvem7    if (Position.IsFlat && Current.Close > ichi.CloudTop && Crossed.Above(ichi, ichi.KijunSeries))8        Buy(1);9}

Indicador (base)

Base dos indicadores: uma série que avança um valor por candle e guarda o histórico, para o robô comparar o valor de agora com o de candles atrás (media[1] é o do candle anterior). Durante o aquecimento o valor é NaN, exatamente como no gráfico da HTS. Todo indicador é uma ISeries: os utilitários de série (Average(n), Highest(n), Rising(n)...) valem para ele.

1private readonly Ema _media = new(21);2public override void OnBarClose()3{4    _media.Update(Current);5    // média pronta e subindo, preço acima dela: compra6    if (_media.IsReady && _media.Value > _media[1] && Current.Close > _media.Value && Position.IsFlat) Buy(1);7}

Indicador de um valor (base)

Indicador alimentado por um valor por candle (por padrão, o fechamento).

1private readonly Sma _mediaDoMeio = new(20);2public override void OnBarClose()3{4    // Update aceita o candle (usa o fechamento) ou qualquer número5    _mediaDoMeio.Update((Current.High + Current.Low) / 2);6    if (_mediaDoMeio.IsReady) Plot("Média do meio", _mediaDoMeio.Value);7}

Média exponencial

Média móvel exponencial com k = 2 / (N + 1). Semeia com o primeiro valor válido e devolve esse valor já no primeiro candle, como a EMA do gráfico da HTS: os primeiros valores carregam o peso da semente. Valor não numérico não avança a média (devolve a anterior).

1private Ema rapida = null!;2private Ema lenta = null!;3public override void OnStart() { rapida = new Ema(9); lenta = new Ema(21); }4public override void OnBarClose()5{6    rapida.Update(Current.Close);7    lenta.Update(Current.Close);8    // cruzamento clássico das médias 9 e 219    if (Crossed.Above(rapida, lenta)) Buy();10    else if (Crossed.Below(rapida, lenta)) Sell();11}

Média móvel simples

Média móvel simples: a média aritmética dos últimos N valores. NaN até ter N valores, e NaN se algum valor da janela não for número (mesma regra do gráfico da HTS).

1private Sma media = null!;2public override void OnStart() { media = new Sma(20); }3public override void OnBarClose()4{5    media.Update(Current.Close);6    // só desenha a média quando o fechamento está acima dela7    if (media.IsReady && Current.Close > media.Value) Plot("Média", media.Value);8}

Média ponderada

Média móvel ponderada (WMA): o candle mais recente pesa N, o anterior N − 1, e assim por diante. NaN até ter N valores e NaN se algum valor da janela não é número (mesma conta do WMA no gráfico).

1private Wma media = null!;2public override void OnStart() { media = new Wma(21); }3public override void OnBarClose()4{5    media.Update(Current.Close);6    // compra quando o fechamento cruza a média para cima7    if (Position.IsFlat && Crossed.Above(Closes, media)) Buy();8}

Média de Hull

Média de Hull (HMA): WMA(√N) de [2·WMA(N/2) − WMA(N)], a conta do HMA no gráfico (N/2 arredondado para baixo, √N arredondado para o inteiro mais próximo). Aquecimento: N + √N − 2 candles de NaN.

1private Hma hull = null!;2public override void OnStart() { hull = new Hma(16); }3public override void OnBarClose()4{5    hull.Update(Current.Close);6    if (!hull.IsReady) return;7    // verde subindo, vermelha caindo8    Plot("Hull", hull.Value, hull.Value > hull.Previous ? "#22c55e" : "#ef4444");9}

Média de Wilder

Média de Wilder (RMA/SMMA, a que roda por dentro do RSI e do ATR): semeia com a média simples dos primeiros N valores e depois avança por (anterior·(N − 1) + valor)/N, como o SMMA no gráfico. NaN nos N − 1 primeiros candles. Valor não numérico devolve a média anterior sem avançar.

1private Rma amplitude = null!;2public override void OnStart() { amplitude = new Rma(14); }3public override void OnBarClose()4{5    // média de Wilder da amplitude dos candles6    amplitude.Update(Current.High - Current.Low);7    if (amplitude.IsReady && Current.Range > 2 * amplitude.Value) Log("Candle esticado: o dobro da amplitude média");8}

Média ponderada por volume

Média ponderada por volume (VWMA): Σ(fechamento·volume)/Σ(volume) nos últimos N candles, como o VWMA no gráfico. Precisa do candle (volume), por isso só tem Update. NaN até ter N candles e quando o volume da janela é zero.

1private Vwma porVolume = null!;2private Sma simples = null!;3public override void OnStart() { porVolume = new Vwma(20); simples = new Sma(20); }4public override void OnBarClose()5{6    porVolume.Update(Current);7    simples.Update(Current.Close);8    // VWMA acima da média simples: o volume está do lado comprador9    if (porVolume.IsReady && simples.IsReady && porVolume.Value > simples.Value) Plot("VWMA", porVolume.Value);10}

Média de Arnaud Legoux (ALMA)

ALMA (Arnaud Legoux): pesos em curva de sino com o centro em offset·(N − 1) e largura N/sigma, como o ALMA no gráfico. NaN até ter N valores.

1private Alma alma = null!;2public override void OnStart() { alma = new Alma(21, 0.85, 6); }3public override void OnBarClose()4{5    alma.Update(Current.Close);6    // zera a compra quando o fechamento perde a ALMA7    if (Position.IsLong && Crossed.Below(Closes, alma)) ClosePosition();8}

Média adaptativa de Kaufman (KAMA)

KAMA (Kaufman): a velocidade da suavização vem da eficiência do movimento (quanto o preço andou em linha reta contra o caminho total nos últimos N candles), entre as EMAs de fastPeriod e slowPeriod. Mesma conta do KAMA no gráfico: NaN nos N primeiros candles (a semente é o fechamento do N-ésimo) e o primeiro valor sai no candle N + 1.

1private Kama kama = null!;2public override void OnStart() { kama = new Kama(10, 2, 30); }3public override void OnBarClose()4{5    kama.Update(Current.Close);6    if (!kama.IsReady) return;7    // KAMA parada = mercado lateral; só compra com ela subindo8    if (Position.IsFlat && kama.Value > kama.Previous && Current.Close > kama.Value) Buy();9}

Média exponencial dupla

DEMA: 2·EMA − EMA(EMA), como o DEMA no gráfico. Tem valor desde o primeiro candle (as EMAs semeiam com o primeiro valor) e converge ao longo dos primeiros candles.

1private Dema rapida = null!;2private Dema lenta = null!;3public override void OnStart() { rapida = new Dema(9); lenta = new Dema(21); }4public override void OnBarClose()5{6    rapida.Update(Current.Close);7    lenta.Update(Current.Close);8    // cruzamento de duas DEMAs9    if (Crossed.Above(rapida, lenta)) Buy();10    else if (Crossed.Below(rapida, lenta)) Sell();11}

Média exponencial tripla

TEMA: 3·EMA − 3·EMA(EMA) + EMA(EMA(EMA)), como o TEMA no gráfico. Valor desde o primeiro candle.

1private Tema tema = null!;2public override void OnStart() { tema = new Tema(20); }3public override void OnBarClose()4{5    tema.Update(Current.Close);6    Plot("TEMA", tema.Value);7    // vende quando o fechamento perde a TEMA8    if (Position.IsFlat && Crossed.Below(Closes, tema)) Sell();9}

TRIX

TRIX: variação percentual (em pontos-base, ×10 000) da EMA tripla de um candle para o outro, como o TRIX no gráfico. NaN só no primeiro candle.

1private Trix trix = null!;2public override void OnStart() { trix = new Trix(15); }3public override void OnBarClose()4{5    trix.Update(Current.Close);6    // TRIX cruzando o zero para cima: a tendência virou de alta7    if (Position.IsFlat && Crossed.Above(trix, 0)) Buy();8    else if (Position.IsLong && Crossed.Below(trix, 0)) ClosePosition();9}

Média T3 de Tillson

T3 (Tillson): seis EMAs encadeadas combinadas pelo fator de volume factor, como o T3 no gráfico. Valor desde o primeiro candle; converge ao longo do aquecimento.

1private T3 t3 = null!;2public override void OnStart() { t3 = new T3(8, 0.7); }3public override void OnBarClose()4{5    t3.Update(Current.Close);6    // compra com o fechamento acima da T3 e a T3 subindo7    if (Position.IsFlat && Current.Close > t3.Value && t3.Value > t3.Previous) Buy();8    Plot("T3", t3.Value);9}

Série deslocada

Uma série vista com deslocamento: Shifted(media, 5)[0] é o valor que media tinha 5 candles atrás (a média "deslocada para a frente" do gráfico, o offset do Pine). Não copia nada: lê a série original na hora, então vale para qualquer indicador ou Series. Deslocamento negativo não existe (seria ler o futuro).

1private Sma media = null!;2private Shifted deslocada = null!;3public override void OnStart() { media = new Sma(20); deslocada = new Shifted(media, 3); }4public override void OnBarClose()5{6    media.Update(Current.Close);7    // compra quando o fechamento cruza a média deslocada 3 candles8    if (Position.IsFlat && Crossed.Above(Closes, deslocada)) Buy();9}

Índice de fluxo de dinheiro (MFI)

MFI (Money Flow Index): o RSI com volume. Fluxo = preço típico × volume; soma dos fluxos dos candles em que o típico subiu contra os em que caiu, nos últimos N candles, de 0 a 100. Mesma conta do MFI no gráfico: a comparação precisa do candle anterior, então o primeiro valor sai no candle N + 1 (N candles de NaN).

1private Mfi mfi = null!;2public override void OnStart() { mfi = new Mfi(14); }3public override void OnBarClose()4{5    mfi.Update(Current);6    // pouco dinheiro entrando (abaixo de 20): compra; excesso (acima de 80): zera7    if (Position.IsFlat && mfi.Value < 20) Buy(1);8    else if (Position.IsLong && mfi.Value > 80) ClosePosition();9}

Oscilador de momento de Chande (CMO)

CMO (Chande): (Σ altas − Σ baixas)/(Σ altas + Σ baixas) × 100 nas últimas N variações, de −100 a 100, sem alisamento, como o CMO no gráfico. Primeiro valor no candle N + 1.

1private Cmo cmo = null!;2public override void OnStart() { cmo = new Cmo(14); }3public override void OnBarClose()4{5    cmo.Update(Current.Close);6    // abaixo de −50 é sobrevenda; acima de +50, sobrecompra7    if (Position.IsFlat && cmo.Value < -50) Buy(1);8    else if (Position.IsLong && cmo.Value > 50) ClosePosition();9}

Taxa de variação (ROC)

ROC: variação percentual entre o valor de agora e o de N candles atrás, como o ROC no gráfico. NaN nos N primeiros candles e quando o valor de referência é zero.

1private Roc roc = null!;2public override void OnStart() { roc = new Roc(12); }3public override void OnBarClose()4{5    roc.Update(Current.Close);6    Plot("ROC %", roc.Value, PlotStyle.Histogram);7    // a variação em 12 candles virou positiva: compra8    if (Position.IsFlat && Crossed.Above(roc, 0)) Buy(1);9}

Momento

Momentum: o valor de agora menos o de N candles atrás, em pontos, como o Momentum no gráfico. NaN nos N primeiros candles.

1private Momentum mom = null!;2public override void OnStart() { mom = new Momentum(10); }3public override void OnBarClose()4{5    mom.Update(Current.Close);6    // momento cruzou o zero: compra para cima, zera para baixo7    if (Position.IsFlat && Crossed.Above(mom, 0)) Buy(1);8    else if (Position.IsLong && Crossed.Below(mom, 0)) ClosePosition();9}

Índice de força verdadeira (TSI)

TSI (True Strength Index): a variação do preço alisada por duas EMAs (longa e depois curta), dividida pelo valor absoluto da variação alisado do mesmo jeito, × 100. Mesma conta do TSI no gráfico: as EMAs semeiam com a primeira variação, então o valor existe desde o segundo candle e converge.

1private Tsi tsi = null!;2public override void OnStart() { tsi = new Tsi(25, 13); }3public override void OnBarClose()4{5    tsi.Update(Current.Close);6    Plot("TSI", tsi.Value);7    // TSI cruzou o zero: compra para cima, zera para baixo8    if (Position.IsFlat && Crossed.Above(tsi, 0)) Buy(1);9    else if (Position.IsLong && Crossed.Below(tsi, 0)) ClosePosition();10}

Oscilador final

Ultimate Oscillator (Larry Williams): pressão compradora (fechamento − mínimo entre a mínima e o fechamento anterior) sobre a amplitude verdadeira, em três janelas combinadas com pesos 4, 2 e 1, de 0 a 100. Mesma conta do Ultimate Oscillator no gráfico. NaN até ter Long candles.

1private UltimateOscillator uo = null!;2public override void OnStart() { uo = new UltimateOscillator(7, 14, 28); }3public override void OnBarClose()4{5    uo.Update(Current);6    // abaixo de 30 é sobrevenda; acima de 70, sobrecompra7    if (Position.IsFlat && uo.Value < 30) Buy(1);8    else if (Position.IsLong && uo.Value > 70) ClosePosition();9}

Níveis de pivô

Os sete níveis de um pivô.

1Bar? ontem = PreviousDay;2if (ontem is not null)3{4    PivotLevels p = Pivots.Classic(ontem.Value);5    // desenha o pivô e a primeira resistência e suporte do dia6    Plot("PP", p.PP);7    Plot("R1", p.R1);8    Plot("S1", p.S1);9}

Pivôs

Pivôs calculados da máxima, mínima e fechamento do período ANTERIOR (o dia de ontem, a semana passada), com as mesmas fórmulas do Pivot do gráfico. Você passa os números (normalmente de PreviousDay, ou Aggregates.Previous(Candles, Candles.Count - 1, Period.Day)).

1Bar? ontem = PreviousDay;2if (ontem is not null)3{4    PivotLevels p = Pivots.Classic(ontem.Value);5    // rompeu a R1 de baixo para cima: compra mirando a R2, stop no pivô6    if (Position.IsFlat && Closes[1] <= p.R1 && Current.Close > p.R1)7    {8        Buy(1);9        TakeProfitAt(p.R2);10        StopLossAt(p.PP);11    }12}

Topos e fundos

Topos e fundos confirmados: o candle cuja máxima supera estritamente a dos Left candles antes e dos Right candles depois é um topo (idem, espelhado, para o fundo), a regra dos fractais do gráfico com lados independentes. A confirmação chega com Right candles de atraso: em HighConfirmedNow o topo é o candle de Right candles atrás, e LastHigh passa a valer o preço dele. Highs e Lows são séries alinhadas ao candle da CONFIRMAÇÃO (o preço do extremo, ou NaN).

1private Swings swings = null!;2public override void OnStart() { swings = new Swings(2, 2); }3public override void OnBarClose()4{5    swings.Update(Current);6    // confirmou um fundo mais alto que o anterior: compra com stop abaixo dele7    if (Position.IsFlat && swings.LowConfirmedNow && swings.LastLow > swings.PreviousLow)8    {9        Buy(1);10        StopLossAt(swings.LastLow - 5);11    }12}

Regressão linear

Regressão linear dos últimos N valores: Value é o valor da reta no candle atual (a LSMA e o canal de regressão do gráfico), Slope é a taxa por candle e R2 o quanto a reta explica, de 0 a 1. Forecast estende a reta para a frente (com 1 é a EPMA). NaN até ter N valores.

1private LinearRegression reg = null!;2public override void OnStart() { reg = new LinearRegression(20); }3public override void OnBarClose()4{5    reg.Update(Current.Close);6    Plot("LSMA", reg.Value);7    // reta subindo e bem ajustada: tendência de alta limpa8    if (Position.IsFlat && reg.Slope > 0 && reg.R2 > 0.7) Buy(1);9}

Canal de regressão

Canal de regressão: a reta de mínimos quadrados no meio (Value) e bandas a Deviations erros-padrão dos resíduos (√(Σ(y − reta)²/(N − 2)), as bandas de erro padrão do gráfico). Precisa de N ≥ 3. NaN até ter N valores.

1private RegressionChannel canal = null!;2public override void OnStart() { canal = new RegressionChannel(50, 2); }3public override void OnBarClose()4{5    canal.Update(Current.Close);6    // fechou abaixo da banda de baixo: compra mirando o meio do canal7    if (Position.IsFlat && Current.Close < canal.Lower) Buy(1);8    else if (Position.IsLong && Current.Close >= canal.Value) ClosePosition();9}

Estocástico

Estocástico: %K é a posição do fechamento na faixa máxima–mínima dos últimos KPeriod candles, alisada por média simples de KSmoothing; %D é a média simples de DPeriod do %K. Cobre o rápido (suavização 1), o lento (3) e o completo. Mesma conta do Estocástico no gráfico: faixa zero é NaN, não 50. Value é o %K; o %D fica em D.

1private Stochastic sto = null!;2public override void OnStart() { sto = new Stochastic(14, 3, 3); }3public override void OnBarClose()4{5    sto.Update(Current);6    // %K cruzou o %D para cima na região de sobrevenda (abaixo de 20)7    if (Position.IsFlat && sto.K < 20 && Crossed.Above(sto, sto.DSeries)) Buy(1);8    else if (Position.IsLong && sto.K > 80) ClosePosition();9}

Estocástico do IFR

Estocástico do RSI: a posição do RSI na própria faixa dos últimos StochasticPeriod valores, alisada como o Estocástico. Mesma conta do Estocástico RSI no gráfico, inclusive o RSI de dentro, que semeia com a média simples das primeiras N variações (diferente de Rsi, que converge de zero): o primeiro RSI sai no candle N + 1. Value é o %K.

1private StochasticRsi srsi = null!;2public override void OnStart() { srsi = new StochasticRsi(14, 14, 3, 3); }3public override void OnBarClose()4{5    srsi.Update(Current);6    // saiu da sobrecompra (%K cruzou 80 para baixo): vende7    if (Position.IsFlat && Crossed.Below(srsi, 80)) Sell(1);8    else if (Position.IsShort && srsi.K < 20) ClosePosition();9}

MACD

MACD: EMA rápida − EMA lenta (Value), a EMA de SignalPeriod dessa diferença (Signal) e a diferença entre as duas (Histogram). Mesma conta do MACD no gráfico: as três EMAs semeiam com o primeiro valor, então há número desde o primeiro candle (zero) e ele converge ao longo do aquecimento.

1private Macd macd = null!;2public override void OnStart() { macd = new Macd(12, 26, 9); }3public override void OnBarClose()4{5    macd.Update(Current.Close);6    Plot("Histograma", macd.Histogram, PlotStyle.Histogram);7    // linha do MACD cruzou a de sinal para cima: compra; para baixo: zera8    if (Position.IsFlat && Crossed.Above(macd, macd.SignalSeries)) Buy(1);9    else if (Position.IsLong && Crossed.Below(macd, macd.SignalSeries)) ClosePosition();10}

Índice de canal de commodities (CCI)

CCI (Lambert): (preço típico − média do típico)/(0,015 · desvio médio absoluto) nos últimos N candles, como CCI no gráfico. NaN até ter N candles e quando o desvio é zero.

1private Cci cci = null!;2public override void OnStart() { cci = new Cci(20); }3public override void OnBarClose()4{5    cci.Update(Current);6    // voltou de baixo de −100: compra; passou de +100: zera7    if (Position.IsFlat && Crossed.Above(cci, -100)) Buy(1);8    else if (Position.IsLong && cci.Value > 100) ClosePosition();9}

Williams %R

Williams %R: (maior máxima − fechamento)/(faixa) × −100 nos últimos N candles, de −100 a 0, como o Williams %R no gráfico. NaN até ter N candles e com faixa zero.

1private WilliamsR wr = null!;2public override void OnStart() { wr = new WilliamsR(14); }3public override void OnBarClose()4{5    wr.Update(Current);6    // abaixo de −80 é sobrevenda; acima de −20, sobrecompra7    if (Position.IsFlat && wr.Value < -80) Buy(1);8    else if (Position.IsLong && wr.Value > -20) ClosePosition();9}

Padrões de candle

Padrões de candle, com os MESMOS critérios do catálogo de padrões do gráfico (régua da TA-Lib): corpo e sombras são medidos contra a média dos 10 candles anteriores ao PRIMEIRO candle do padrão (precisa de pelo menos 5), e a tendência que antecede o padrão separa martelo de enforcado e estrela cadente de martelo invertido (tendência = fechamento do candle anterior ao padrão menos a média dos 5 fechamentos antes dele). Sem contexto suficiente, nenhum padrão casa. Todo método recebe a lista de candles e o índice do ÚLTIMO candle do padrão; sem índice, o último da lista (Patterns.Hammer(Candles, Candles.Count - 1) em OnBarClose).

1// martelo ou engolfo de alta depois de queda: compra com stop e alvo em pontos2if (Position.IsFlat && (Patterns.Hammer(Candles) || Patterns.BullishEngulfing(Candles)))3{4    Buy(1);5    StopLoss(150);6    TakeProfit(300);7}

IFR (RSI)

RSI (IFR) de Wilder, 0 a 100. A conta é a mesma do gráfico da HTS: o primeiro valor é NaN (só fixa o fechamento anterior) e, do segundo em diante, as médias de ganho e perda avançam pela suavização de Wilder partindo de zero. Converge ao longo dos primeiros candles em vez de esperar N candles, por isso o valor existe cedo e ainda "assenta".

1private Rsi rsi = null!;2public override void OnStart() { rsi = new Rsi(14); }3public override void OnBarClose()4{5    rsi.Update(Current.Close);6    // sobrevendido: compra; voltou a sobrecomprado: zera7    if (Position.IsFlat && rsi.Value < 30) Buy(1);8    else if (Position.IsLong && rsi.Value > 70) ClosePosition();9}

Força da tendência (ADX)

ADX de Wilder com as linhas direcionais. Mesma conta do ADX do gráfico: o primeiro candle só fixa o anterior (NaN); no segundo, ATR e DMs são semeados com o próprio valor e o ADX parte de zero; daí em diante tudo avança por suavização de Wilder (α = 1/N). O ADX "assenta" ao longo dos primeiros candles em vez de esperar N candles. Value é o ADX; DiPlus e DiMinus são as direcionais (as do DMI, que usa a mesma semente).

1private Adx adx = null!;2public override void OnStart() { adx = new Adx(14); }3public override void OnBarClose()4{5    adx.Update(Current);6    // só opera com tendência forte (ADX acima de 25), a favor da direcional dominante7    if (Position.IsFlat && adx.Value > 25)8    {9        if (adx.DiPlus > adx.DiMinus) Buy(1);10        else Sell(1);11    }12}

SAR parabólico

SAR parabólico de Wilder, com a conta do SAR parabólico no gráfico: semeia no primeiro candle assumindo alta (SAR na mínima, extremo na máxima); a cada candle avança pelo fator de aceleração, nunca entra na faixa dos dois candles anteriores e, quando é tocado, vira no extremo alcançado. Os primeiros valores são arbitrários por construção. Value é o SAR; IsUptrend diz o lado.

1private ParabolicSar sar = null!;2public override void OnStart() { sar = new ParabolicSar(0.02, 0.2); }3public override void OnBarClose()4{5    sar.Update(Current);6    Plot("SAR", sar.Value, PlotStyle.Points);7    // virou o SAR: zera e entra no lado novo8    if (sar.FlippedNow)9    {10        ClosePosition();11        if (sar.IsUptrend) Buy(1); else Sell(1);12    }13}

SuperTrend

SuperTrend: banda de Multiplier·ATR em volta do meio do candle, travada do lado da tendência (só aperta; afrouxa só quando o fechamento a atravessa, e aí a tendência vira). Mesma conta do SuperTrend no gráfico: NaN enquanto o ATR aquece; começa assumindo alta. Value é a linha (o stop); Direction é +1 em alta e −1 em baixa.

1private SuperTrend st = null!;2public override void OnStart() { st = new SuperTrend(10, 3); }3public override void OnBarClose()4{5    st.Update(Current);6    Plot("SuperTrend", st.Value);7    // virou para alta: compra; virou para baixa: zera a compra8    if (st.FlippedNow && st.IsUptrend && Position.IsFlat) Buy(1);9    else if (st.FlippedNow && !st.IsUptrend && Position.IsLong) ClosePosition();10}

HiLo Activator

HiLo Activator (Gann/Krausz): média das máximas e média das mínimas dos N candles ANTERIORES (sem o atual). Fechou acima da média das máximas: alta, e a linha é a média das mínimas; fechou abaixo da média das mínimas: baixa, e a linha é a média das máximas; entre as duas, vale o lado de antes. Mesma conta do HiLo no gráfico (no primeiro candle entre as médias, o lado mais perto). NaN nos N primeiros candles.

1private HiLo hilo = null!;2public override void OnStart() { hilo = new HiLo(3); }3public override void OnBarClose()4{5    hilo.Update(Current);6    Plot("HiLo", hilo.Value, PlotStyle.Step);7    // o HiLo virou: zera e acompanha o lado novo8    if (hilo.FlippedNow)9    {10        ClosePosition();11        if (hilo.IsUptrend) Buy(1); else Sell(1);12    }13}

Aroon

Aroon: há quantos candles saiu a máxima (Up) e a mínima (Down) dos últimos N, em percentual (100 = agora, 0 = no começo da janela); Value é o oscilador (alta − baixa). Mesma conta do Aroon, Aroon Down e Aroon Oscillator no gráfico: em empate vale o candle mais recente. NaN até ter N candles.

1private Aroon aroon = null!;2public override void OnStart() { aroon = new Aroon(25); }3public override void OnBarClose()4{5    aroon.Update(Current);6    // Aroon Up cruzou o Down para cima: começo de alta7    if (Position.IsFlat && Crossed.Above(aroon.UpSeries, aroon.DownSeries)) Buy(1);8    else if (Position.IsLong && Crossed.Below(aroon.UpSeries, aroon.DownSeries)) ClosePosition();9}

Desvio padrão

Desvio padrão POPULACIONAL dos últimos N valores (divide por N, como o gráfico da HTS e o ta.stdev do Pine). NaN até ter N valores e se algum não é número.

1private StdDev desvio = null!;2private Sma media = null!;3public override void OnStart() { desvio = new StdDev(20); media = new Sma(20); }4public override void OnBarClose()5{6    desvio.Update(Current.Close);7    media.Update(Current.Close);8    // filtro: mercado parado (desvio pequeno) não entra9    if (desvio.IsReady && desvio.Value > 30 && Position.IsFlat && Crossed.Above(Closes, media)) Buy();10}

Volatilidade histórica

Volatilidade histórica: desvio padrão (populacional) dos últimos N log-retornos (ln(fechamento/anterior)), vezes a raiz de Annualization (252 pregões), em percentual. Mesma conta do volatilidade histórica no gráfico. O primeiro candle não tem retorno, então o primeiro valor sai no candle N + 1. Retorno com preço zero ou negativo é NaN e invalida a janela.

1private HistoricalVolatility volatilidade = null!;2public override void OnStart() { volatilidade = new HistoricalVolatility(20, 252); }3public override void OnBarClose()4{5    volatilidade.Update(Current.Close);6    Plot("Vol. histórica %", volatilidade.Value);7    // avisa no log quando a volatilidade passa de 40% ao ano8    if (volatilidade.IsReady && volatilidade.Value > 40) Log("Volatilidade acima de 40% ao ano");9}

Saldo de volume (OBV)

OBV (Granville): soma o volume quando o fechamento sobe, subtrai quando cai, não mexe quando empata. Mesma conta do OBV no gráfico: começa em zero no primeiro candle (o nível não quer dizer nada, só a direção).

1private Obv obv = null!;2private Ema mediaDoObv = null!;3public override void OnStart() { obv = new Obv(); mediaDoObv = new Ema(20); }4public override void OnBarClose()5{6    obv.Update(Current);7    mediaDoObv.Update(obv.Value);8    // o volume confirma a alta: OBV cruza a própria média para cima9    if (Position.IsFlat && Crossed.Above(obv, mediaDoObv)) Buy();10}

Acumulação e distribuição

Linha de acumulação/distribuição (Chaikin): acumula volume × posição do fechamento na faixa do candle (−1 a +1). Mesma conta do linha A/D no gráfico: candle com faixa zero não mexe na linha (repete o valor).

1private AccumulationDistribution ad = null!;2public override void OnStart() { ad = new AccumulationDistribution(); }3public override void OnBarClose()4{5    ad.Update(Current);6    Plot("A/D", ad.Value);7    // divergência: preço caindo e a linha A/D subindo (acumulação)8    if (Current.Close < Closes[5] && ad.Value > ad[5]) Log("Acumulação na queda");9}

Oscilador de Chaikin

Oscilador de Chaikin: EMA rápida − EMA lenta da linha de acumulação/distribuição (o MACD do fluxo). Mesma conta do Chaikin Oscillator no gráfico: valor desde o primeiro candle (zero), convergindo.

1private ChaikinOscillator chaikin = null!;2public override void OnStart() { chaikin = new ChaikinOscillator(3, 10); }3public override void OnBarClose()4{5    chaikin.Update(Current);6    // fluxo virou comprador: oscilador cruza o zero para cima7    if (Position.IsFlat && Crossed.Above(chaikin, 0)) Buy();8    else if (Position.IsLong && Crossed.Below(chaikin, 0)) ClosePosition();9}

Índice de força

Force Index (Elder): EMA de (fechamento − fechamento anterior) × volume. Mesma conta do Force Index no gráfico: NaN no primeiro candle; a EMA semeia com o primeiro produto.

1private ForceIndex forca = null!;2private Ema tendencia = null!;3public override void OnStart() { forca = new ForceIndex(2); tendencia = new Ema(50); }4public override void OnBarClose()5{6    forca.Update(Current);7    tendencia.Update(Current.Close);8    // Elder: tendência de alta e força negativa (correção) = ponto de compra9    if (Position.IsFlat && Current.Close > tendencia.Value && forca.Value < 0) Buy();10}

Tendência preço-volume (PVT)

PVT (Price Volume Trend): acumula volume × variação percentual do fechamento. Mesma conta do PVT no gráfico: NaN no primeiro candle (não há variação); depois parte de zero.

1private Pvt pvt = null!;2private Sma sinal = null!;3public override void OnStart() { pvt = new Pvt(); sinal = new Sma(21); }4public override void OnBarClose()5{6    pvt.Update(Current);7    sinal.Update(pvt.Value);8    Plot("PVT", pvt.Value);9    Plot("Sinal", sinal.Value);10    if (Position.IsLong && Crossed.Below(pvt, sinal)) ClosePosition();11}

Ondas de Weis

Weis Wave: o volume acumulado da onda atual. Não existe no gráfico da HTS; a regra aqui é a clássica de David Weis sem filtro de tamanho: a onda de alta segue enquanto o fechamento não cai abaixo do maior fechamento da onda (menos Reversal pontos, quando informado); quando cai, começa uma onda de baixa naquele candle, com o volume dele, e vice-versa. Fechamento igual continua a onda. A primeira onda tem o lado do primeiro candle (de alta se fechou acima de onde abriu, senão de baixa). Value é o volume da onda com sinal (positivo na alta, negativo na baixa); WaveVolume é o módulo; PreviousWave é o volume (com sinal) da onda que acabou.

1private WeisWave ondas = null!;2public override void OnStart() { ondas = new WeisWave(50); }3public override void OnBarClose()4{5    ondas.Update(Current);6    Plot("Onda", ondas.Value, PlotStyle.Histogram);7    // começou uma onda de alta: mostra quanto volume teve a onda de baixa que acabou8    if (ondas.FlippedNow && ondas.IsUptrend) Log($"Nova onda de alta; a de baixa somou {Math.Abs(ondas.PreviousWave)} contratos");9}

VWAP

VWAP por período: Σ(preço·volume)/Σ(volume) acumulado desde o início do dia, da semana ou do mês, zerando na virada (pela Date em Brasília e PeriodKey). A conta é a do VWAP do gráfico: o preço é o FECHAMENTO do candle (não o preço típico), e o valor existe desde o primeiro candle do período. Com typicalPrice: true a conta usa (máxima + mínima + fechamento)/3, como outras plataformas. Volume zero no período inteiro dá NaN.

1private Vwap vwap = null!;2public override void OnStart() { vwap = new Vwap(Period.Day); }3public override void OnBarClose()4{5    vwap.Update(Current);6    Plot("VWAP", vwap.Value);7    // compra quando o preço retoma o VWAP do dia8    if (Position.IsFlat && Crossed.Above(Closes, vwap)) Buy();9}

VWAP ancorado

VWAP ancorado: acumula desde o candle em que o robô chamou Anchor (um rompimento, a abertura de um evento, um topo). Antes da primeira âncora o valor é NaN. Chame Anchor() ANTES de Update(Current) no mesmo candle para que o candle da âncora entre na conta.

1private Highest maxima = null!;2private AnchoredVwap vwap = null!;3public override void OnStart() { maxima = new Highest(20); vwap = new AnchoredVwap(); }4public override void OnBarClose()5{6    maxima.Update(Current);7    // ancora o VWAP no candle que rompeu a máxima dos 20 anteriores (antes do Update)8    if (Current.Close > maxima[1]) vwap.Anchor();9    vwap.Update(Current);10    if (vwap.IsReady) Plot("VWAP ancorado", vwap.Value);11}