lar › Vírus › Criando uma estratégia do zero - um guia detalhado. Cliente inteligente ou estúpido? Crie uma estratégia baseada em turnos

Criando uma estratégia do zero - um guia detalhado. Cliente inteligente ou estúpido? Crie uma estratégia baseada em turnos

Parque temático:
Precisaremos de:
ator de construção
menu de sprites
SPRITES DE VÁRIOS BOTÕES, COMO:
srite com a inscrição (construção, construção, construção, etc.)
uma janela que aparece
desenho de construção,
1) nós mesmos adicionaremos o resto
2) a palavra falsificação - criada por mim mesmo, porque precisaremos fingir para corresponder à nossa fonte)
IIVamos começar:
1) crie tudo o que está escrito no ponto I, exceto 1)
Vamos criar uma variável global chamada dinheiro, definir qualquer quantia inicial de dinheiro
Também criaremos um objeto mouse e teclado
Vamos criar um texto, chamá-lo de info, criar um evento Always e criar uma ação nele:
selecione informações na seleção de ação selecione definir texto no texto escreva isto:
"dinheiro: " &(global("dinheiro".
2) adicionar um menu, a principal tarefa do menu não é interferir, mas sim ajudar o jogador a navegar (como pode interferir? - é fácil se você colocar no meio do jogo); antes de fazer o menu, nós criaremos uma nova camada, que chamaremos de menu, em suas proporções (configurações, opções) no item de exibição escrevemos:

vamos adicionar um sprite nele e pegar a imagem do menu que estava nos materiais de pré-produção (ponto I) e colocar nosso menu em um local isolado onde não irá interferir, mas ficará visível na tela
Vamos colocar também um botão feito de materiais de pré-acabamento (ponto I) com a inscrição CONSTRUIR (ou algo parecido)
vamos colocar no menu
Agora vá para o Editor da Folha de Eventos
crie um evento (#blá, blá, blá# - esta é minha mensagem (explicação) para você apenas em vez de blá, blá, blá, haverá meu comentário para você; >> - ação; ll - divisão de janelas por exemplo:

mouse e teclado ll no objeto clicado ll clicado com o botão esquerdo para o objeto #seu botão de menu com a inscrição BUILD (ou algo parecido)##o resto depois (veja o ponto 3)#
3)agora a parte mais difícil(Eu dividi isso em dois pontos para não ser tão complicado),
crie um sprite a partir de materiais de pré-acabamento “uma janela que aparecerá”
então criamos um sprite vazio chamado p1, movemos a janela para fora da tela e colocamos p1 no local onde sua janela deve aparecer quando você pressiona o botão build (ou algo parecido CHVER)
ótimo! Agora vá para o editor de planilhas de eventos
Vamos anotar o evento inacabado até o fim:
O texto definirá o texto como bla-bla-bla)
mouse e teclado ll no objeto clicado ll clicado com o botão esquerdo para o objeto #seu botão de menu rotulado CONSTRUIR (ou algo parecido)#>>
4)A segunda parte da parte mais difícil:
vamos criar um sprite onde será desenhada a imagem da construção (materiais de pré-acabamento), vamos chamá-lo de h1
vamos criar um sprite vazio, chame-o de p2, agora coloque-o no local onde a janela deve abrir,
Vamos criar um sprite, também uma janela (materiais de pré-acabamento), na janela vamos escrever lindamente o nome do prédio, seu custo e descrição (opcional) e chamá-lo de i1
vamos criar outro sprite vazio chamado p3, coloque-o próximo ao p2, apenas para que ele toque p2 apenas com o canto superior esquerdo
Agora vamos criar vários eventos, mas primeiro transformamos o evento anterior em uma nova ação:
mouse e teclado ll no objeto clicado ll clicado com o botão esquerdo para o objeto #o botão do seu menu com a inscrição BUILD (ou algo parecido)#>> sistema criará o objeto relativo ao objeto ll #sua janela# #número da camada sob o nome menu# # X ;Y-não mude# para o objeto p1
>>sistema criará objeto relativo ao objeto ll #sua segunda janela# #número da camada sob o nome menu# #X;Y-não mude# para objeto p2
Também precisamos devolver a ele um evento:
copie o evento e inverta-o
novo evento
mouse&keyboard ll está sobre o objeto ll h1>>sistem ll cria o objeto em relação ao objeto ll i1 #número da camada sob o nome menu# #X;Y-não mude# para o objeto p3
Vamos fazer um sprite com uma construção (use materiais de pré-produção) e chamá-la de casa
Vamos criar uma janela onde nossos edifícios aparecerão quando forem selecionados no menu, chame-a de rlo
eventos:
mouse&keyboard ll no objeto clicado ll clicado com o botão esquerdo em h1>>sistema criará o objeto relativo ao objeto ll casa #número da camada sob o nome menu# #X;Y-não mude# para objeto rlo
>> sistema subtrairá do valor ll #quantidade de dinheiro que deve ser retirada durante a construção#
Agora era impossível construir um evento
Vou lhe contar meu antigo método de proibição (quando terminar de escrever, explorarei outro método que me deixou triste quando me lembrei do mundo do parque temático do jogo)
eventos:
casa ll em colisão com outro objeto ll para casa
>>casa vou destruir
>> sistema subtrairá do valor ll - #o dobro da quantidade de dinheiro que foi retirada durante a construção##nota que você deve colocar - quantidade#
basicamente tudo.
III o que quero dizer:

Fiquei muito chateado com o colapso do meu jogo. Era um jogo de estratégia, e este artigo foi compilado de acordo com seu esquema. Peço que não critiquem muito, escrevi por muito tempo, se encontrar algum erro de fala, escreva e eu irei corrigi-los
e também aqui está o código fonte para seu prazer, olha, em princípio tudo é igual ao que está escrito aqui, só que esta foi uma versão demo do jogo. O principal é não mudar nada, senão vai dar bugs !
use, experimente, verifique, faça o que quiser, está tudo bem para mim

KaMiKaZa:
Todas as expressões de “sistema” devem ser incluídas na tag “Código”.
Então acho que será melhor.
Além disso, parece-me que as capturas de tela não fariam mal aqui. E também o código fonte, para iniciantes.

Parque temático:
Não sei fazer capturas de tela de eventos.

Bem, isso não é necessário.

iamnp:
theme_park , existe um botão especial no teclado - PrintScreen

Parque temático:
Eu sei que algumas pessoas fazem isso de maneira diferente. Além disso, cada um tem seu próprio sprite
e se eu configurar todos esses sprites, poucas pessoas vão entender.
Bem, talvez alguém dê uma vantagem? Não admira que eu estivesse lutando?

burlachenko:
Para que tal lição seja do interesse de qualquer pessoa, ela precisa ser formatada de acordo, mas aqui “de qualquer forma foi”.
E ainda assim, se quiser, um pouco de cada vez, quando tiver tempo, por favor “embeleze”.

Parque temático:
ok, vou voltar da escola e me preparar.
PS. fonte adicionada

Serega Lebedev:

iamnp, para onde vão essas capturas de tela mais tarde?

KaMiKaZa:

Para a área de transferência.
Vá para qualquer editor de texto e execute a operação "Colar" ou pressione Ctrl+V.

Neste artigo, é improvável que aborde algo desconhecido. Todos os cálculos são simples e compreensíveis para quem sabe o que é Ajax. Já escrevi um artigo sobre como combinar um cliente com um servidor em jogos em tempo real (). Neste artigo, abordo os mesmos problemas que se aplicam aos jogos baseados em turnos.

Então, o que é jogo baseado em turnos? A seguinte definição pode ser encontrada na Wikipedia estratégia baseada em turnos - é um gênero de jogos de computador cuja principal característica é que os jogadores se revezam na execução de movimentos, em oposição à estratégia em tempo real. Eu simplificaria um pouco esta definição:

Estratégia passo a passo - é um jogo de estratégia baseado em turnos.
Jogo de estratégia - Este é um gênero de jogos em que a chave para alcançar a vitória é o planejamento e o pensamento estratégico..
Jogo baseado em turnos - é um gênero de jogos cuja principal característica é que os jogadores se revezam nas jogadas.

Os jogos baseados em turnos incluem:

Estratégias baseadas em turnos
Jogos de cartas
Jogos de tabuleiro (xadrez, go, monopólio, etc.)

Observo que os jogos baseados em turnos impõem menos restrições à complexidade do protocolo de interação em comparação com os jogos em tempo real. Nomeadamente, o tempo de reação a um evento específico não desempenha um papel fundamental. O jogador geralmente tem 10 segundos para tomar uma decisão. Mesmo que o ping seja gigantesco, digamos 3 segundos, o jogador ainda tem 7 segundos para pensar. Além disso, o ping pode pular e pular, mas não nos importamos nem um pouco com isso (em jogos em tempo real, essa situação praticamente mata qualquer protocolo).

Normalmente (em 95% dos jogos baseados em turnos) exatamente um jogador toma a decisão a qualquer momento. Consequentemente, o número de pedidos aos quais devemos responder adequadamente é reduzido.

Portanto, ao criar um protocolo, focaremos principalmente na facilidade de sua implementação e suporte. Isso nos permitirá obter mais lucro em menos tempo.

O raciocínio acima é baseado no desenvolvimento de um determinado jogo de cartas em 2 meses.

Cliente inteligente ou estúpido?

Primeiro, vamos decidir o quão “inteligente” nosso cliente pode ser. Estou debatendo se vale a pena duplicar a lógica do aplicativo (regras do jogo) no cliente. Obviamente, o servidor deve ser inteligente para evitar possíveis invasões ao aplicativo. Mas vale a pena ensinar lógica de negócios ao cliente?

Isso depende diretamente de quanto pesa a quantidade total de dados sobre o estado do seu jogo. Se essa quantidade de dados for grande, demorar muito para ser coletada no servidor e transferida para o cliente, então faz sentido implementar parte da lógica no cliente para aliviar o servidor. Por exemplo, em Civilization, o medidor de memória usada está sempre fora dos gráficos. Você pode criar algo semelhante, deixando apenas a UI no cliente?

Por outro lado, quanto mais inteligente for o cliente, mais caro será o desenvolvimento do jogo. Deixe-me observar que o tempo de desenvolvimento do servidor não depende de forma alguma da erudição do cliente. Mesmo que o cliente seja super-duper-mega inteligente, se o usuário quiser recarregar a janela do navegador, o servidor terá que coletar e reunir todos os dados do jogo para transferi-los para o cliente. A la "Carregando um jogo salvo". Conclusão: Um smart client pode acelerar uma aplicação, mas sempre exigirá recursos adicionais para desenvolvê-la.

Eu sugiro o seguinte teste:

1. O volume do canal permite?

Estime o peso médio da quantidade total de dados do estado do jogo. Em seguida, multiplique pelo número médio de solicitações ao servidor por segundo. Se o número resultante exceder a capacidade do canal de dados de saída, o cliente estúpido será inaceitável. Se esse número ultrapassar 20% do canal de saída, você deve pensar se funcionará?

2. É trabalhoso?

Estime a complexidade do algoritmo de coleta de dados do jogo (em frações de segundo). Aqui, leve em consideração todas as consultas ao banco de dados. Em seguida, multiplique pelo número médio de solicitações ao servidor por segundo. Se o tempo exceder um segundo, um cliente estúpido é inaceitável. Se esse número ultrapassar 200 ms, você deve pensar se isso vai durar?

Continuação:

Olá a todos! Agora vou te contar como fazer um RTS simples (RTS - Real Time Strategy, ou seja, uma estratégia em tempo real) abrir uma rede 8.1 (a operabilidade não é garantida no 8.0) criar um objeto objControl, ou seja, este será nosso objeto principal, criar um evento de criação ( Criar) Adicionar evento => Criação (Adicionar evento => Criar) o evento de criação é feito apenas uma vez - ao criar, clique na aba de controle à direita cardápio vertical e clique com o botão direito em Executar código e escreva o código (é melhor não copiar o código, mas escrevê-lo você mesmo, é muito mais fácil de lembrar):

200?"200px":""+(this.scrollHeight+5)+"px");">startx=0; //Declara uma variável para o ponto inicial de x
início=0; //Declara uma variável para o início do ponto por y
desenhar_rect=falso; //Não desenha um retângulo de seleção

Variável: Um pedaço de memória que contém informações. Eles têm um nome próprio com o qual você pode contatá-los. Variáveis em GML podem conter um número real ou uma string. Por exemplo, uma mesa é uma variável, madeira ou vidro é um valor
Agora criamos um evento step (Step, Add Event => Step) e realizamos a operação novamente (clique com o botão direito em Executar código):

200?"200px":""+(this.scrollHeight+5)+"px");">
if mouse_check_button_pressed(mb_left) //Se LMB for pressionado
{
draw_rect=true; //Desenhamos um retângulo
startx=mouse_x; //Iniciar posição x = posição x do mouse
inicial=mouse_y; //Posição inicial = posição do mouse
com todos selecionados=falso; //Esta ainda não é uma variável declarada, descobriremos o que fará mais tarde
}

If mouse_check_button_released(mb_left) //Se o LMB for liberado
{
desenhar_rect=falso; //Não desenhamos um retângulo
para (eu=0;eu<=instance_number(par);i+=1) //Читайте про цикл for ниже
{
ii=instance_find(par,i); //Estamos procurando por um objeto que ainda não foi feito
if(collision_rectangle(startx,starty,mouse_x,mouse_y,ii,true,false)) //Aqui está nosso retângulo de colisão (contato)
{
ii.selected=true;
}
}
}

O código é grande e complexo enquanto aprendemos sobre a instrução condicional if:
O código com if é executado assim:

200?"200px":""+(this.scrollHeight+5)+"px");">
se (condição)
{
Ação
}

Também pode conter uma instrução else (caso contrário), exemplo:

200?"200px":""+(this.scrollHeight+5)+"px");">if (condição)
{
Ação
}
outro
{
ação 2
}

E for é um operador de loop, é executado assim:

200?"200px":""+(this.scrollHeight+5)+"px");">
para (<переменная> ; <выражение> ;<действие переменной>)
{
<действия>
}

A declaração for é uma coisa muito poderosa, ajuda muito em situações difíceis

Operador – ações embutidas em uma linguagem, por exemplo, as mais comuns são int, if, else, string, switch, for, case, break, exit, etc., etc.

Agora também criamos um evento de desenho (draw) e escrevemos da mesma forma:

200?"200px":""+(this.scrollHeight+5)+"px");">if draw_rect=true
{
alfa=0,8;
draw_rectangle_color(startx,starty,mouse_x,mouse_y,c_green,c_green,c_green,c_green,true);
}

Tudo é fácil aqui, aqui está a mesma coisa só em russo:
se precisarmos desenhar um retângulo, selecionamos transparência e desenhamos um retângulo
aqui estão os argumentos

200?"200px":""+(this.scrollHeight+5)+"px");">draw_rectangle_color(x1,y1,x2,y2,cor 1, cor 2, cor 3, cor 4, contorno)

contorno - se apenas a aresta (verdadeiro) ou o retângulo preenchido (falso) será desenhado
Encontramos uma nova palavra - constante, esta é uma expressão numérica ou código substituído por uma palavra, a rede possui constantes integradas:

200?"200px":""+(this.scrollHeight+5)+"px");">verdadeiro - 1
falso - 0
pi-3,1415...

Bem, descobrimos, agora precisamos criar um novo objeto - um objeto pai que se conectará aos seus filhos. Vamos chamá-lo de par (para alterar o nome você precisa alterar o código no evento da etapa do objeto de controle), escreva no evento de criação:

200?"200px":""+(this.scrollHeight+5)+"px");">selected=false; //Aqui está nossa variável, se o objeto está selecionado

Isso é tudo. Agora, é claro, precisamos de um objeto que possa se mover, chamamos ele de objTest e escrevemos o código no evento de criação:

200?"200px":""+(this.scrollHeight+5)+"px");">gox=x; //Para onde ir...
goy=y; //por você
selecionado=falso; //Não fomos selecionados =)
object_set_parent(self,par) //Aqui está a escolha do pai

Nova ação:

200?"200px":""+(this.scrollHeight+5)+"px");">object_set_parent(ind,obj)

Define o objeto pai como o objeto denominado ind.
E um novo operador: self, significa que a ação irá para si mesma
Não tenha medo, ainda falta um pouco no evento step:

200?"200px":""+(this.scrollHeight+5)+"px");">se distância_ao_ponto(gox,goy) > 20
{
mp_potential_step(gox,goy,6,sólido);
}
if(selected=true) && mouse_check_button_pressed(mb_right)
{
gox=mouse_x;
goy=mouse_y;

Formação de estratégia
Você não pode confiar em amadores:
seus planos podem dar certo inesperadamente,
e ninguém está pronto para isso.

(A.Cuningham)

Nas duas edições anteriores aprendemos faça jogos 2D simples, controle sprites, role a tela do jogo, rastreie colisões de objetos do jogo, construa uma interface (botões, mouse, teclado, áreas de texto) e trabalhe em tela cheia e modos de janela. Tudo isso foi feito usando um jogo de arcade como exemplo.

Desta vez passaremos dos jogos arcade para um gênero mais “sério” - estratégias. Aqui teremos que dominar toda uma série de novos mecanismos, mas também não haverá nada complicado aqui. Neste artigo nós Vamos estudar a estrutura de uma estratégia baseada em turnos(e também estratégia em tempo real- é ainda mais fácil fazer isso com o LKI-Creator) e faremos um jogo como exemplo, projetado, porém, apenas para multi usuário modo (e também editor de mapas para ela). Trataremos do modo single player na próxima edição de nossa coluna - dedicada a noções básicas de inteligência artificial.

Como esta já é a terceira lição, não entraremos em detalhes todos código de exemplo - felizmente, muita coisa foi feita exatamente da mesma forma que nas duas vezes anteriores. Para referência, há um programa de exemplo (contém muitos comentários) e artigos anteriores.

Bem, você pode encontrar os materiais de nossas aulas anteriores em nosso CD, na seção “Jogo faça você mesmo” criada especialmente para esse fim.

Formulação do problema

Vamos escrever um jogo de estratégia que consiste em uma batalha entre dois exércitos de fantasia. O objetivo da batalha é capturar vários obeliscos, colocado no mapa. Antes da batalha, posicionamos nossas tropas, compostas por 6 espadachins, 4 arqueiros, 2 cavaleiros, 2 mágicos e 1 fantasma, dentro do território que nos foi atribuído. Além deles, existem neutros no mapa dragões.

Características dos lutadores
Lutador	Movimento	Exitos	Faixa	Dano	Proteção	Capacidades
Espadachim	4	8	1	7	2	-
Arqueiro	4	5	7	5	1	-
Cavaleiro	3	15	1	9	4	Cura, Golpe do Cavaleiro
Mago	3	12	5	6	0	Bola fogo
Fantasma	4	7	2	5	5	Regeneração
O Dragão	6	30	2	12	5	Voo

As características dos lutadores são apresentadas na tabela. Tratamento- este é o direito de curar um guerreiro vizinho (exceto um fantasma) até a saúde total uma vez por batalha. Golpe do Cavaleiro- o direito de infligir dano triplo uma vez por jogo. Bola fogo- o ataque do mago remove pontos de vida não apenas do alvo imediato, mas também dos quadrados circundantes. Regeneração- recuperação de 1 golpe por turno. Voo- o direito de ultrapassar obstáculos.

O jogo é jogado no modo multiplayer, na versão Hot Seat (jogar em um computador, turnos um de cada vez). Após o turno dos jogadores, os dragões neutros fazem o seu turno, atacando qualquer inimigo dentro de um raio de 7 células.

A festa termina quando um lado captura mais da metade dos obeliscos presentes no mapa ou morre completamente.

O mapa foi inicialmente definido no editor de mapas. Existem obeliscos, dragões e obstáculos (objetos através dos quais você não pode se mover ou atacar).

Preparando-se para o trabalho

Antes de começarmos, precisaremos reinstalar o pacote Criador LKI. O fato é que, em comparação com a última vez, muitas alterações e acréscimos foram feitos nele.

(Eu espero que Delfos você já instalou; caso contrário, leia as recomendações sobre este tema em nosso artigo anterior - na edição de junho da revista ou no CD desta edição ou no site.)

É importante: a versão anterior do LKI-Creator apresentava alguns problemas de compatibilidade com novas versões do Delphi. Nesta versão eles são eliminados.

Pegue o arquivo com textos e imagens do programa do nosso CD (seção “Jogo com suas próprias mãos”) e descompacte-o no diretório do projeto.

Agora você pode baixar arquivos necessários daqui .

Deveríamos ter três subdiretórios. Um - Unidades - armazena bibliotecas DirectX e módulos do pacote LKI-Creator. Em outro – Projeto – trabalharemos; as fotos que precisaremos são colocadas lá com antecedência, e versão anterior nossa arcada. No terceiro - Escort - um programa pronto no qual devemos ter sucesso.

Agora vamos instalar (reinstalar) o LKI-Creator. No menu Delphi, abra o item Componente e selecione Instalar Componente. Se você já instalou este pacote, fique na aba Em pacote existente, caso contrário vá até a aba Em novo pacote e preencha as linhas vazias conforme mostrado na figura (na linha superior, a maneira mais fácil é selecionar o arquivo LKI2dEngine. pas usando o botão Procurar e na parte inferior apenas escreva LKI). Em seguida, clique em OK e selecione Instalar. Agora você deve ver a aba LKI no painel superior do Delphi.

Agora só falta fazer o upload do nosso projeto. No menu Arquivo, selecione Abrir, abra o arquivo Project\Obelisk.dpr...

Onde está o mapa, Billy? Precisamos de um mapa!

No entanto, antes de entrarmos no assunto principal, precisaremos trabalhar um pouco mais no motor gráfico.

No Star Escort, nosso projeto anterior, o “mapa” não tinha significado: as estrelas eram colocadas aleatoriamente e não afetavam nada, e a posição de outros objetos era especificada diretamente no código ou determinada pelo acaso. Isso não é adequado para todos os projetos. Isso significa que é hora de adicionarmos ao nosso mecanismo mapa de área.

Você provavelmente já pode adivinhar como será a aparência - colocamos um objeto de mapa na janela do projeto e depois o registramos na propriedade Mapa nosso motor.

É assim... mas temos mais de uma classe de cartão. Vamos olhar mais de perto...

Tipos de cartões

O mapa consiste em algo paisagem E objetos instalado nele. A paisagem é mais frequentemente (mas nem sempre) dividida em células chamadas azulejos- azulejos.

Como sabemos no curso escolar de geometria, um plano pode ser coberto sem lacunas ou sobreposições com polígonos regulares de três tipos: triângulo (equilátero), quadrado, hexágono. Os campos triangulares não são particularmente convenientes, portanto, células quadradas ou hexágonos são usadas com mais frequência.

De certa forma, conviver com quadrados é mais fácil: se tivermos uma matriz bidimensional de células, fica imediatamente claro como encontrar as células adjacentes a uma determinada célula. São +1 e -1 para cada um dos dois índices. Com hexágonos tudo é um pouco mais complicado... mas o tabuleiro hexagonal tem uma propriedade muito valiosa: todas as direções nele são iguais. Este não é o caso de uma grade quadrada: as diagonais são significativamente diferentes das horizontais e verticais. Portanto, para cálculos estratégicos sérios, os hexágonos podem ser melhores que os quadrados.

Existem também cartas não lado a lado. LKI-Creator suporta dois tipos: gráfico e patchwork.

Um mapa gráfico é um mapa no qual apenas alguns pontos-chave têm significado, além de talvez áreas especiais (por exemplo, áreas intransitáveis), e o resto é apenas um padrão que não tem efeito de jogo. É assim que os mapas estelares são frequentemente feitos, como, digamos, em Master of Orion: estrelas e buracos negros são pontos-chave, o resto é pano de fundo. Neste modo, às vezes eles fazem mapas globais, por exemplo, para um RPG.

O mapa patchwork é dividido em áreas, e dentro da área todos os pontos são iguais, você não pode se mover ao longo do “patchwork”. Isto é bom para estratégias globais, onde uma província é a unidade mínima de território.

Exemplos de cartas de vários jogos, indicando o tipo, estão nas fotos.

Então a maioria bidimensional os mapas (tridimensionais - artigo especial) podem ser divididos em quatro classes:

Retangular- TLKIRectMap. Este é um mapa lado a lado, as células são quadradas. Tal mapa, por exemplo, em Civilização III.
Hexagonal- TLKIHexMap. Mapa lado a lado com células hexagonais. Usado em muitos jogos de guerra, e não só: é assim, por exemplo, que o mapa de batalha Heroes of Might & Magic era tradicionalmente feito.
Esses dois tipos de cartas são descendentes da classe geral TLKITileMap.
Graphovaya- TLKIGraphMap. Este cartão tem plano de fundo (propriedade de plano de fundo) e os pontos-chave destacados nele são objetos estáticos. A posição de outros objetos neste mapa é expressa por coordenadas comuns (como uma nave espacial no espaço interestelar) ou por referência a um objeto (a mesma nave em órbita de um planeta). Estas são as cartas Mestre de Orion, Arcano (global) e assim por diante.
Retalhos- TLKIClusterMap. Possui uma propriedade de fundo, como a do gráfico, e uma segunda propriedade - mascarar, que determina qual ponto pertence a qual região, e a propriedade Fronteiras, que define as conexões entre os “fragmentos”. É assim que os mapas são organizados, por exemplo, em Medieval: Total War ou Victoria.

É importante: as classes de mapas não são descritas no módulo LKI2dEngine, mas no LKI2dMap.

Ângulos de inclinação

Mas se você acha que isso esgota as capacidades do LKI-Creator para exibir mapas, você está muito enganado.

O mapa pode ser apresentado vista do topo ou isométrico- olhe em um ângulo com a vertical. Por exemplo, o mapa de Civilization III ou Heroes of Might & Magic IV é isométrico, mas Civilization I adota uma visão de cima para baixo.

Normalmente, a isometria é usada para mapas lado a lado, enquanto os mapas gráficos são usados com vista superior, uma vez que a escala dos mapas gráficos é geralmente menor. Mas há exceções: por exemplo, em Medieval: Total War há um mapa isométrico de retalhos.

A propriedade map é responsável pela isometricidade Isométrico e dois parâmetros que definem o ângulo em que nossa câmera olha: Fi E Teta.

O primeiro é responsável pela rotação do mapa em relação ao eixo vertical: por exemplo, se você definir 45 graus (é medido em graus), a célula retangular da grade será orientada com um ângulo ascendente, como em Civilização . Em Phi=0, um dos lados da célula será horizontal.

O segundo controla a inclinação da câmera em relação à vertical. Por conveniência, é dado como a razão entre unidades de comprimento horizontais e verticais. Digamos que, se quisermos que nossa célula tenha metade da altura e da largura, precisamos definir Theta como 2.

Com um mapa lado a lado, não podemos escolher esses ângulos arbitrariamente: afinal, (ainda) não temos 3D. Eles dependem diretamente dos parâmetros dos ladrilhos. Por exemplo, se tivermos um eixo em forma de diamante com um ângulo ascendente e o eixo vertical tiver metade do tamanho do eixo horizontal, devemos definir os parâmetros 45 e 2.

Mas os mapas gráficos e de retalhos dão a você o direito de atribuir esses parâmetros como quiser (e até mesmo, se desejar, alterá-los no processo), mas você não deve se deixar levar por isso - além do fato de que tais turnos levam um muito tempo, eles também não parecem muito legais. E não se esqueça que se o seu mapa for artístico, com fotos, inscrições, etc., então eles vão virar junto... Em geral, às vezes é mais fácil desenhar um mapa de retalhos levando em consideração a rotação necessária - felizmente, distâncias muitas vezes não desempenham nenhum papel lá.

Articulações

Mapa de retalhos, vista superior.

Os mapas de blocos têm outro problema - a união de blocos. É controlado pelo parâmetro TileBorderStyle. Na maioria das vezes isso telhaReta, um modo em que os blocos simplesmente se encaixam sem quaisquer efeitos de borda, ou telhaBorder, em que são traçadas linhas separando um ladrilho do outro - os limites das células (neste último caso, não se esqueça de definir cor redes no parâmetro TileBorderColor).

Mas há uma opção mais complicada, quando peças idênticas são adjacentes umas às outras sem alterações, e diferentes são usadas usando uma peça “transicional” especial. Isso geralmente é feito se o mapa consiste principalmente em grandes extensões de um tipo de território, digamos, grandes áreas verdes, e uma célula individual não é importante e não deve ser notada pelo jogador. Esta é a carta de Heroes of Might Magic. Mas se cada célula for processada separadamente, como no Civilization, esse método não é adequado e é melhor separar claramente as células umas das outras. Tecnologia “fundida” (também chamada mascarar) é especificado pelo valor TileBorderStyle igual a telhaMasked. Falaremos sobre sua estrutura em outra ocasião - este é um tópico bastante complexo.

Telha

Elemento do mapa - objeto de classe TLKITile- possui uma estrutura simples. Contém inicialmente: coordenadas, o sprite que o desenha, o código do tipo de azulejo (que determina o que temos aqui - uma colina, deserto, estrada, mar?) e capacidade de cross-country (isto é relevante na maioria dos jogos). O último é o número de unidades de movimento gastas para se mover através desta peça. terra esquadrão. Para peças intransitáveis, este é um número negativo.

Outro parâmetro - Objetos, uma lista de objetos localizados neste bloco (tipo TLKIGameObject).

Para saber qual célula foi clicada, o mapa possui um método MouseTile(x,y) retornando o bloco selecionado.

Os métodos de bloco incluem É vizinho(Azulejo, Distância). Esta função retorna verdadeiro se o Tile não estiver a mais do que as células de Distância do ladrilho fornecido (por padrão, este parâmetro é igual a um, ou seja, se você simplesmente escrever IsNeighbour(Tile), a função retornará verdadeiro para o ladrilho imediatamente adjacente para a peça dada. Para uma grade quadrada, aquelas peças que fazem fronteira diagonalmente também são consideradas “vizinhas”.

Funções Primeiro vizinho E PróximoVizinho são usados para verificar todas as células adjacentes a uma determinada. O primeiro deles aponta para alguma célula vizinha, e o segundo só pode ser chamado após chamar o primeiro, e distribui os próximos vizinhos, um de cada vez.

Enumeração de vizinhos

// Causando danos a uma célula

procedimento TObeliskTile.Damage(dmg: inteiro);

se(Objetos.Contagem > 0) e// Pode ser que tenhamos

// não mais que um objeto por célula

(Objetos.ID > 0) // Objetos passivos

//não danificado

Dec(Objetos.Hits,

// Subtraia automaticamente a proteção contra danos

Max(0,dmg-(Objetos como TObeliskGameObject).Defesa);

se Objetos.Hitsthen morrem; // Nós removemos os mortos

// Ataque de bola de fogo

procedimento TObeliskTile.Fireball;

var Vizinho: TObeliskTile;

Vizinho:= PrimeiroVizinho como TObeliskTile;

Vizinho.Dano(6);

Vizinho:= PróximoVizinho como TObeliskTile;

até Vizinho = zero; // Até que os vizinhos acabem

Um exemplo está na barra lateral “Enumerando Vizinhos”. Este procedimento calcula a bola de fogo que atinge uma célula e todos os seus vizinhos.

Isto é interessante: pelo trabalho dela isso não importa nada, temos uma rede hexagonal ou quadrada.

Freqüentemente, precisamos de alguns outros parâmetros e, geralmente, da classe de peças que compõem o mapa - descendente TLKITile. Portanto, no exemplo - TObeliskTile é herdado de TLKITile.

É importante: Se trouxermos um mapa de blocos para a tela do jogo, as coordenadas, bem como os métodos TLKIGameObject relacionados à distância, por padrão, começam a medir a distância em blocos em vez de pontos. As coordenadas de botões, ícones, etc. continuam a ser medidos em pixels! Mas este modo pode ser desligado - isto pode ser útil para estratégias em tempo real.

Selecionando um cartão

Então, vamos começar com uma rede retangular (TLKIRectMap), um mapeamento isométrico (parâmetros angulares 0, 1,5). Deixe a grade ser desenhada (estilo tileBorder). Vamos dizer ao motor que este mapa específico deve ser exibido. Até agora, todas as ações necessárias foram concluídas sem escrever uma única linha de código.

Estas operações devem ser feitas antes inicialização do mecanismo, bem como declaração de fonte.

Declararemos as figuras, como antes, como sprites.

Editor de mapas

Mapa de retalhos, isométrico.

Existem algumas dificuldades aqui. Exatamente o mesmo mecanismo, as mesmas declarações de blocos... A interface, como selecionar um bloco, carregar/salvar, etc., pode ser feita facilmente meios padrão Delphi: ninguém está nos forçando a traduzi-lo para modo tela cheia. Não analisaremos isso aqui - tudo está no arquivo de exemplo. O código de exemplo usado deliberadamente a maneira mais simples; Se desejar, você pode, por exemplo, tornar gráfica a paleta de objetos e a paleta de blocos.

O editor possui apenas dois recursos que não conhecemos. O primeiro é bastante simples: é um novo recurso de mouse projetado especificamente para mapas lado a lado. Função TLKIRectMap.SelectTile retorna um ponteiro para o bloco exato que foi clicado, para que possamos lidar facilmente com o clique.

Mas o segundo novo produto merece uma consideração mais cuidadosa.

Na verdade, há muitas maneiras de salvar e ler dados dele. Escolhemos o método codificado no arquivo Base de Canhão. Cannon é uma ferramenta para ler e escrever objetos descendentes TCannonObject com verificação de tipo e alguns outros recursos.

Vejamos o código (“Escrever cartão”).

Gravando um cartão

procedimento TObeliskMap.Save;

var i,j: inteiro;

InitSave(FNome);

WriteStr(MapaNome);

Write(Map.Largura, SizeOf(Map.Largura));

Write(Map.Height, SizeOf(Map.Height));

para eu:=0 para Mapa.Largura-1 fazer

para j:=0 para Mapa.Altura-1 fazer

Write(Map.Tiles.Code, SizeOf(inteiro);

Veja como funciona. Primeiro você precisa abrir o arquivo usando um procedimento especial IniciarSalvar, cujo único parâmetro é o nome do arquivo. Em seguida, salvamos o cabeçalho para controle de tipo usando um procedimento especial WriteHeader. Em seguida, anotamos tudo o que precisamos usando o procedimento WriteStr para strings e para todos os outros campos - Escrever(seu segundo parâmetro é o tamanho dos dados gravados em bytes). Você pode escrever seus próprios procedimentos para campos de objetos conforme necessário Salvar com um registro de cabeçalho. Por fim, fechamos o arquivo com o procedimento FinSave.

Todos os objetos que possuem cabeçalho próprio devem ser declarados separadamente. No capítulo Inicialização módulo (seção opcional que vem depois Implementação, que contém comandos que devem ser executados logo no início, ao iniciar o programa), deve-se escrever a seguinte linha, por exemplo:

RegisterUserName(tpMap, "TObeliskMap");

TpMapé uma constante que você também deve declarar. Iguale, digamos, a 1. E no construtor do objeto TObeliskMap, atribua o valor desta constante ao parâmetro ID do tipo.

Por que todo esse barulho? Além da correspondência de tipos, você obtém um benefício muito importante.

Se o formato do arquivo mudar, digamos, devido à adição de novos campos, você não precisará escrever nenhum “conversor” que converta os arquivos antigos em novos. Seu código irá lê-los automaticamente.

Este código inicializará automaticamente o novo campo como vazio se não estiver salvo no arquivo. E você pode escrever um arquivo simplesmente adicionando a linha WriteStr(Name) bem no final.

Comente: Se você ainda não entendeu para que serve esse processo, não se preocupe. Você pode usar métodos mais convencionais de gravação e salvamento. Mas em projetos de jogos verdadeiramente em grande escala, esse caminho oferece vantagens significativas.

Vamos jogar

Primeiro de tudo, precisamos criar uma nova classe derivada de TLKIGameObject. Sentiremos falta das propriedades do antigo. Na nova classe, você precisa adicionar campos para as características principais: alcance, movimento e assim por diante.

É importante: Nosso antigo parâmetro de velocidade permanece conosco, mas indica a velocidade da peça se movendo pela tela, e não a distância que ela percorrerá por turno. Se estivéssemos a fazer uma estratégia em tempo real, não precisaríamos de um novo parâmetro, mas caso contrário teremos que introduzi-lo.

Em nossa tela aplicaremos botões TLKIButton na forma de arqueiros, espadachins, mágicos, fantasmas, cavaleiros.

Primeiro temos o arranjo. Vamos definir a zona de posicionamento para um lado como as três “linhas” superiores do mapa, para o outro - como as três “linhas” inferiores.

O código funciona assim. Ao pressionar qualquer um dos botões, a instalação do lutador correspondente é ativada; Clicar em um quadrado desocupado na área de posicionamento coloca a figura ali e desativa o botão. Assim que todos os botões forem desabilitados, o movimento é transferido para o inimigo.

No início de cada novo movimento, todos os botões são acionados novamente: isso é feito para que seja mais fácil para a pessoa perceber com quem ela ainda não se parece. Assim, clicar no botão seleciona a figura e, assim que um movimento é feito, o botão desaparece. Outro botão - “Terminar turno” - aparece somente após a fase de colocação.

Da última vez já fizemos operações para habilitar e desabilitar elementos da interface, então não analisaremos esta operação em detalhes - veja o código de exemplo.

Movimento da figura

// Se a célula selecionada estiver ocupada pelo inimigo, atacamos,

// se estivermos livres, nos moveremos, se estivermos ocupados com os nossos

// ou um obstáculo - ignore o clique

Bloco:= Map.MouseTile(MouseX, MouseY);

se(Telha = nada)// Clique fora da janela do jogo

então saída;

// Movendo-se

se(Tile.Objects.Count = 0)

e(Dist(Auto)

e não Mudou-se então

// Vamos verificar se podemos chegar lá

se não HasWay (bloco) então saída;

MoveObj(ID, Tile.x, Tile.y);

// O jogo é baseado em turnos - mova-se imediatamente

Movido:= verdadeiro;

se Atacado então

Ícone.IsVisível:= falso;

// Ataque

se(Tile.Objects.Count > 0)

e(Dist(Auto)

e não Atacado então

Obj:= Tile.Objects;

// Atacamos apenas inimigos

se Obj.Side = Lado então saída;

Obj.Damage(dmg);

Atacado:= verdadeiro;

// Se a movimentação for concluída, remova o ícone

se Mudou-se então

Ícone.IsVisível:= falso;

O movimento é processado da seguinte forma (ver “Movimento da peça”). A célula clicada está localizada. Se houver um inimigo sobre ele, e eles estiverem dentro do alcance, ele é prejudicado; se estiver vazio e dentro do alcance, a peça se move (se os obstáculos permitirem); se estiver ocupado, mas não por um inimigo, o clique é ignorado .

Quando ambos os lados se aproximaram, os dragões agiram. Eles operam de forma muito simples: selecionam o não-dragão mais próximo que esteja a 7 quadrados deles e atacam. Veja o código de ações do dragão.

Ações do Dragão

// Verificando peças dentro de 7 quadrados do dragão

para eu:= Máx(0, x - 7) para Min(MaxSize, x + 7) fazer

para j:= Máx(0, y - 7) para Min(MaxSize, y + 7) fazer

se (Map.Tiles.Objects.Count > 0) e

(Map.Tiles.Objects.Code>1)

// 0 - código de obstáculo, 1 - dragão

então começar

// Selecionando um ponto para mover

se x = eu então machado:=eu

outro se x > eu então machado:=i+2

outro machado:= i-2;

se y=j então sim:=j

outro se você>j então sim:= j+2

outro sim:= j-2;

MoveObj(NÃO, machado, ay);

// Vamos atacar

Map.Tiles.Damage(12);

// Quebrando o ciclo: não mais que um ataque

// cada dragão por rodada

Por fim, resta verificar se mais da metade dos obeliscos estão ocupados pelas tropas de um lado - e se estiverem, pare o jogo e declare o vencedor!

Então, temos um jogo de estratégia. Porém, para a felicidade completa, o que falta, em primeiro lugar, é a inteligência artificial, que permitirá dar ao jogo um modo single player (não consideramos o procedimento mais simples para controlar dragões). É o que faremos na próxima vez. Te vejo em um mês!

Em edições futuras

Nas próximas edições falaremos sobre:

sistemas de partículas para exibição de fumaça, faíscas, etc.;
trabalhar com transparência;
motores tridimensionais;
Noções básicas de IA;
depurando o programa;
criando um plano de jogo e roteiro,
escrever um documento de design;
equilíbrio do jogo;
pensando nos personagens do jogo e suas falas;
trabalhar com pacotes Photoshop e 3D;
animações;
música e dublagem;
e muito mais.

É bem possível aprender a fazer tudo isso com as próprias mãos. Em breve você verá isso.

Escreva para nós…

Para quem pensa que o pacote pode ser complementado com alguma coisa: em primeiro lugar, não se esqueça que não há Versão final pacote, mas apenas aquele que implementa as funções descritas em nossos artigos. Talvez algumas de suas ideias já tenham sido implementadas e estejam aguardando sua vez (veja a barra lateral “Em edições futuras”). E em qualquer caso: ao nos oferecer uma ideia, tente justificar porque a sua proposta é útil para muitos jogos ao mesmo tempo, e não apenas para o seu específico.

Para trabalho independente

Enquanto espera pela próxima edição, você pode trabalhar em seu próprio projeto ou tentar melhorá-lo. Aqui estão algumas idéias para sua própria implementação:

divida os objetos obstáculos em destrutíveis (árvores e arbustos) e indestrutíveis (rochas), e certifique-se de que as bolas de fogo e o sopro do dragão queimem a vegetação;
criar poços (célula marrom) ou um fogo que arda por vários turnos (célula vermelha) no local onde o ataque de fogo foi desencadeado;
permitir que espadachins e cavaleiros cubram seus vizinhos, dando-lhes +1 na defesa;
tornar suave o movimento das figuras na tela.

E se em tempo real?

Não é mais difícil fazer um jogo de estratégia em tempo real se você apenas fornecer aos jogadores diferentes meios de entrada. A maneira mais fácil de fazer isso é pela rede - falaremos sobre isso em uma das próximas edições. As seguintes alterações também serão necessárias:

nenhum campo necessário Velocidade do jogo na aula PARAbeliskObject- use a velocidade do motor básico (a velocidade de movimento na tela é igual à velocidade do jogo);
o cálculo inteiro de distâncias está desabilitado;
o código de movimento da figura é reescrito, levando em consideração que é necessário traçar uma trajetória em torno dos obstáculos;
O botão "fim do movimento" foi removido.

Isso é tudo. Você tentará fazer isso sozinho?

Hoje em dia, você pode encontrar facilmente muitas estratégias de negociação, o único problema é que a maioria delas não funciona ou não é suficientemente eficaz. Nessa situação, criar uma estratégia do zero é uma excelente solução para o problema.

E embora em cada situação específica a criação de um veículo seja diferente, as etapas principais permanecem as mesmas. Ou seja, você pode criar algo como um guia universal, passando sequencialmente por todas as etapas, e no final teremos um sistema totalmente funcional.

Embora consideremos a opção de criar uma estratégia do zero, começando com uma ideia e terminando com a introdução de um filtro e o desenvolvimento final do veículo, isso não significa que todos os sistemas prontos devam ser imediatamente descartados por serem obviamente ineficazes. . Vários TS podem ser usados como base e simplesmente adicionar alguns filtros para eliminar sinais falsos.

Principais etapas da criação de uma estratégia

Se você pegar de 5 a 7 indicadores aleatoriamente e tentar criar um veículo funcional a partir deles, é improvável que surja algo útil. Primeiro você precisa pensar na ideia principal da estratégia e só depois passar para a seleção das ferramentas. A seguinte sequência de ações pode ser sugerida:

se o sistema for criado do zero, o primeiro passo é trabalhar na ideia. Nesta fase, você só precisa decidir qual será o seu estilo de negociação, por exemplo, se as transações serão realizadas ao longo da tendência ou contra ela, ou talvez a estratégia seja planejada exclusivamente para o rompimento. Ainda não estamos pensando em detalhes;
Depois de escolher o estilo de negociação apropriado, você pode começar a trabalhar nos detalhes. Antes de selecionar os instrumentos, você precisa determinar claramente os pares de moedas e prazos de trabalho, o horário de negociação, etc.;

Importante! Ao escolher um intervalo de tempo, não é aconselhável ir muito pequeno, principalmente se o trader não tiver experiência em especulação em pequenos intervalos de tempo. Para iniciantes, geralmente é melhor não ir abaixo de H1-H4; você pode ler mais sobre como escolher o intervalo de tempo ideal.

a próxima etapa é a seleção dos instrumentos adequados, e aqui a abundância de escolha pode ser uma piada cruel para o trader, pois ele tem dezenas de indicadores à sua disposição, a capacidade de usar análises de velas, ondas, técnicas e fundamentais. De toda essa variedade, você precisa escolher vários instrumentos que melhor se adaptem ao estilo de negociação pretendido;
Uma das principais regras de qualquer estratégia é que o sinal recebido deve ser confirmado por vários filtros, mas é aconselhável limitar o seu número. Por exemplo, para estratégias de indicadores, é indesejável que o número de indicadores exceda 3-4, caso contrário, haverá confusão nos sinais e se você planeja trabalhar com análise técnica, os indicadores desempenharão um papel de apoio;
são desenvolvidas regras para suporte de posição, o resultado deve ser um algoritmo de ações para qualquer cenário;
a última etapa é rodar o veículo primeiro em uma conta histórica e depois em uma conta demo, ou melhor ainda, em uma conta de centavos reais. O objetivo principal é testar a viabilidade da estratégia em condições reais, e uma conta real (mesmo um centavo) permitirá sentir toda a gama de emoções, da euforia à amargura das perdas.

Você também pode aconselhar a não se preocupar com a complexidade do veículo. A prática mostra que a complexidade excessiva não é de forma alguma um indicador de eficácia. Como sistema mais simples, mais fácil será negociar.

O que deve estar incluído no veículo

Criar uma estratégia é um pouco como um conjunto de construção: você só precisa escolher as peças certas. Ao criar um veículo você pode e deve usar:

indicadores. Além disso, você não deve perseguir seu número ou complexidade excessiva, mesmo em veículos totalmente mecânicos, 3 a 5 peças são suficientes;
padrões gráficos - bandeiras, flâmulas, triângulos, cabeça e ombros, fundos duplos e topos bem conhecidos ainda funcionam bem;
construções gráficas;
Níveis Fibo;
elementos de análise fundamental - agora é difícil ganhar dinheiro apenas com notícias, mas é preciso levar em conta o calendário econômico nas negociações. Pelo menos apenas mova as transações para o ponto de equilíbrio antes da divulgação de estatísticas importantes para os EUA ou a Europa, ou mesmo feche completamente o lucro.

Existem também várias técnicas cujos benefícios são questionáveis:

Martingale é uma tática inicialmente não lucrativa, a única chance de sucesso é que antes da perda você consiga recuperar o valor do depósito e ganhar um pouco;

Também é indesejável usar o bloqueio, a menos que seja absolutamente necessário, pois é muito difícil sair do castelo;
Também é melhor não usar sinais externos. Sinais externos significam, por exemplo, uma comparação do número de vendedores/compradores, vários índices do humor da maioria dos traders, etc. Mas também há uma série de recursos que você pode ouvir, por exemplo, Autochartist dá bons sinais com base em padrões gráficos;
Também é melhor não usar elementos de análise de ondas (pelo menos para iniciantes). Embora haja exceções aqui, por exemplo, a negociação na Wolfe Waves é baseada precisamente na análise de ondas, mas não é particularmente complexa.

Desenvolvimento de uma estratégia de indicadores simples

Suponhamos que a ideia principal da estratégia seja negociar exclusivamente na direção da tendência. Além disso, você entrará no mercado não no momento do surgimento de uma tendência, o que é bastante arriscado, mas após a conclusão de uma pequena correção.

A estratégia deve funcionar em quase todos os pares de moedas; isto é necessário porque, devido ao longo período de tempo, os sinais não ocorrerão com muita frequência. Portanto, a situação será avaliada usando 5 a 7 pares de moedas ao mesmo tempo. Quanto ao prazo, D1 é adequado, partimos do fato de que o Forex na fase inicial é apenas um acréscimo ao trabalho principal, portanto negociaremos em velas diárias.

Agora você precisa decidir como exatamente será determinado o momento de entrada. Existem muitas opções para identificar uma tendência:

visualmente - mas a observação não permitirá que você desenvolva regras comerciais claras;
usando uma ou mais médias móveis;
de acordo com o valor do indicador ADX, se for superior a 30, então há uma tendência forte, menos de 20, o mercado está calmo;
utilização de construções gráficas;
As Bandas de Bollinger permitem avaliar a força de uma tendência pela distância entre os limites superior e inferior do canal.

Em geral, existem muitas opções, mas como a estratégia precisa ser o mais simples possível, vamos nos concentrar nas médias móveis. Ou melhor, uma MM, julgaremos a direção da tendência pela posição do preço em relação a ela. Você pode começar com períodos que calculam a média do preço durante todo um período de tempo (semana, mês, trimestre, etc.), por exemplo, 20 será a média do preço do mês anterior. O mais difícil é escolher o período de MA adequado, mas aqui você terá que proceder por tentativa e erro.

A ideia principal da negociação será a seguinte: esperamos que apareça o movimento da tendência, depois segue-se uma correção dentro de um dia, após o seu término é concluído um negócio. Se tudo isso for apresentado na forma de regras claras, o algoritmo de ações ficará assim (usando o exemplo das compras):

primeiro verificamos a posição do preço em relação à MA, o preço deve estar acima da linha;
Em seguida precisamos encontrar um movimento de tendência, precisamos de uma vela com corpo grande e sombras pequenas (é aconselhável que o valor da sombra não ultrapasse 10-15% do tamanho do corpo da vela);
deve ser seguido por uma vela com um pequeno intervalo diário (distância do máximo ao fechamento). O preço de fechamento não deve atingir o nível de 50% do dia anterior - neste dia ocorre a correção do preço.

Neste caso, a correção pode ocorrer de acordo com 2 cenários:

Quando uma vela com uma longa sombra abaixo é formada, você pode abrir uma negociação imediatamente no fechamento do dia. Este formato da vela indica que a correção já foi concluída;
uma opção possível é quando a vela de correção fecha no mínimo, ou seja, a reversão ainda não foi concluída, neste caso você precisa esperar até que a próxima vela feche, se for branca, você pode abrir uma posição longa.

Quanto à manutenção da posição e às ordens de proteção, o stop loss deve ser colocado pelo menos além do meio da vela com corpo grande. Para obter o nível alvo, basta separar o valor da mesma vela do nível de compra; você pode usar um trailing stop.

As regras da estratégia foram formadas, resta apenas testá-la em ação. A prática mostra que mesmo um algoritmo tão simples produz mais da metade das negociações lucrativas (e se você transferir a negociação para zero antecipadamente, a probabilidade de perda diminui).

Entrada no início da tendência

O TS proposto acima perde parte do movimento da tendência, mas não requer muito tempo para análise de mercado. Se for possível monitorar o comportamento do preço do dia, então você pode tentar acompanhar a tendência logo no início de sua formação. Portanto, a ideia principal da estratégia é entrar no mercado depois que o preço começar a sair do canal horizontal.

E aqui é muito importante receber um sinal confiável na hora certa, logo no início da tendência. As médias móveis podem novamente ajudar, mas serão usadas de forma um pouco diferente da estratégia anterior. Você pode pegar vários MAs com períodos diferentes e julgar a formação de uma tendência pela sua localização em relação um ao outro.

Esta não é uma abordagem revolucionária; Bill Williams usou algo semelhante em seu famoso Alligator. Então esse indicador pode até ser tomado como base do TS.

Se adicionarmos o Alligator com configurações padrão ao H1, podemos ver que ele dá muitos sinais falsos; nossa tarefa é eliminá-los. Para isso, entraremos no mercado com uma ordem pendente, e o nível de sua colocação será determinado por meio de Fractais.

Como resultado, o fluxo de trabalho ficará assim (usando o exemplo de compras):

Procuramos uma área plana no gráfico (todas as linhas do Alligator estão caoticamente entrelaçadas umas com as outras);
Em seguida, você precisa de uma vela fractal (e ela deve estar localizada acima das linhas, sem sequer tocá-las com a sombra inferior);
uma ordem stop de compra é colocada logo acima do seu máximo e uma ordem de proteção é colocada além do limite inferior da zona de consolidação;
O TP é fixo (50-70 p) ou usa um trailing stop. Em geral, é muito difícil prever a força de um movimento de tendência, por isso é melhor usar um trailing stop do que um TP fixo ou determinar o nível alvo usando a mesma análise técnica.

Este exemplo não é o desenvolvimento de uma estratégia do zero, mas sim uma ligeira adaptação de uma estratégia já conhecida ao mercado moderno.

Exemplo de um sistema combinado simples

A ideia continua a mesma - entrada no final da correção, mas vamos resolver esse problema de uma forma diferente. O objetivo permanece o mesmo - determinar o momento da conclusão da correção e entrar na direção da tendência, mas se antes usávamos a média móvel, agora usaremos os níveis Fibo e o oscilador para determinar a conclusão da reversão.

Estaremos interessados em um movimento de tendência pronunciado, que também pode ser determinado visualmente. Depois disso, basta esticar os níveis Fibo até ele, isso é necessário para determinar os níveis potenciais para completar a correção. O nível de correção mais significativo é de 38,2%; é permitido negociar em recuperações de 50% e 61,8%.

Mas o fato de o preço atingir o nível Fibo não é suficiente; é necessária confirmação. O Estocástico pode lidar muito bem com essa tarefa (você pode tentar usar o RSI para a mesma finalidade). Por exemplo, para uma transação de compra, o preço deve estar próximo do nível de correção e o Estocástico naquele momento deve estar na zona de sobrevenda.

Depois que o preço atinge o nível, esperamos até que o Estocástico saia da zona de sobrevenda e compre. O stop pode ser colocado além do próximo nível de correção e o TP pode ser colocado pelo menos na máxima recente antes do início do pullback.

Os níveis Fibo e um oscilador são apenas o mínimo necessário para receber um sinal. Se desejar, você pode complicar o sistema introduzindo filtros adicionais.

Estratégias baseadas em análise técnica

Se a análise técnica for utilizada em sua forma pura, a tarefa se torna um pouco mais simples: não é mais necessário desenvolver um veículo do zero. Existem uma série de técnicas e ferramentas cuja eficácia foi testada ao longo dos anos, cabendo ao comerciante apenas escolher as adequadas e utilizá-las nas construções.
Em princípio, para uma negociação bem-sucedida, basta:

linhas de tendência - nós as construímos em diferentes intervalos de tempo, começando pelo mais alto e descendo gradativamente até o de trabalho;
Níveis Fibo, eles devem ser ampliados para movimentos de preços significativos na história. Os níveis de correção de 38,2, 50 e 61,8% serão de importância fundamental; a prática mostra que a correção geralmente termina nessas marcas;
O MT4 também implementa uma série de outras ferramentas de análise técnica, por exemplo, forcados Andrews, um conjunto de ferramentas Gann, vários tipos de canais, etc.

Mas para uma previsão bastante precisa, os níveis Fibo e as linhas de tendência são suficientes; áreas de concentração de níveis e linhas geralmente atuam como suporte/resistência. A negociação pode ser realizada tanto para um rompimento quanto para uma recuperação de níveis e linhas.

Quanto aos filtros adicionais, você pode adicionar padrões de velas e algum tipo de indicador para procurar divergências (o mesmo Estocástico ou MACD). Você pode ler mais sobre o uso da análise técnica.

Filtros para sistemas de negociação

Qualquer veículo de negociação, mesmo que a ideia funcione e a negociação seja geralmente lucrativa, gera muitos sinais e alguns deles não são lucrativos. Depois que as regras do sistema forem formadas, você poderá usar vários filtros universais que ajudarão a melhorar a proporção de transações lucrativas/não lucrativas.

Existem vários filtros que se adequam a quase todas as estratégias:

situação em prazos mais elevados. Se, por exemplo, a estratégia for executada em H1 de acordo com uma estratégia mecânica, então não seria errado olhar para o que está a acontecer em H4 e D1;
faixa média diária, ou seja, a distância que o preço percorre em média por dia; ao negociar intradiário, isso ajudará a filtrar uma série de sinais. Vamos imaginar que durante o dia o preço se mova em média 100-120 pips, se em um dos dias o preço à noite já tivesse ultrapassado 90-100 pips em uma direção, e o TS dá um sinal para entrar no mercado no mesma direção, então faz sentido ignorá-la , as estatísticas dizem que é improvável que o tráfego continue neste dia;

Importante! O cumprimento desta regra levará ao fato de que algumas negociações lucrativas serão perdidas, mas a proporção de negociações lucrativas/perdedoras aumentará.

O número de velas após a formação do sinal também é importante, existe até um filtro de 5 velas, que discutiremos com mais detalhes.

Quando o TS dá um sinal, então, idealmente, a situação deve começar a se desenvolver a nosso favor quase imediatamente após a conclusão da transação (ou seja, nas próximas 1-3 velas). Se isso não acontecer, quanto mais tempo tiver passado desde a conclusão da transação, menor será a influência no mercado daqueles fatores que importaram quando o trader entrou no mercado. Sua influência desaparece com o tempo.

Você pode tomar 5 velas como critério; se, após a conclusão de um negócio, o preço não se moveu em uma direção lucrativa para 5 velas, então é melhor fechar o negócio manualmente. Isso significa um cenário em que o gráfico permanece no mesmo lugar, mas se o preço tiver ido para o lado não lucrativo, esse filtro não será aplicado.

Esta condição se aplica a quase todos os prazos (com exceção de m1-m5). É claro que ainda existe a possibilidade de que o preço, tendo oscilado em torno de uma marca, se mova na direção certa, mas a nossa escolha é a estabilidade. É melhor sacrificar algumas negociações lucrativas, mas evite de 3 a 5 negociações não lucrativas.

Resumindo

Começar a trabalhar sem um sistema de negociação é como a morte, todo trader deve se lembrar disso. Neste caso, perder o depósito é apenas uma questão de tempo.

Escolher um veículo adequado não é difícil, além disso, você pode encontrar bons sistemas funcionais de domínio público. Você também pode se preocupar em criar sua própria estratégia, até porque isso não exige conhecimento de linguagens de programação, basta ter uma ideia e pelo menos conhecimentos básicos de como funciona o mercado e quais indicadores são utilizados para quais finalidades.

O processo em si lembra a montagem de um conjunto de construção - primeiro definimos um problema e depois simplesmente selecionamos as ferramentas necessárias para resolvê-lo. Depois de verificar o histórico, você pode prosseguir para o teste TS em uma conta demo ou cent.

Popular na categoria: