🤔 Para Refletir :
"Mudar não é fraqueza, pelo contrário, é um sinônimo de superação."
- Ricky O Bardo

Sistema de Yu-Gi-Oh! -Vídeo NOVO [20/12/19]

Mayleone Feminino

Conde
Membro
Membro
Console.Write("Hello World!");
Juntou-se
25 de Outubro de 2016
Postagens
267
Bravecoins
3.021
tenor.gif

Olá pessoal, como vão? Há exatamente um mês eu iniciei o desenvolvimento de um sistema de batalhas ao estilo Yu Gi Oh, mais precisadamente seguindo as regras e design do game para PS1: Yu-Gi-Oh Forbidden Memories.

O sistema foi iniciado com a adição de cartas num banco de dados SQLite, e dentro do Unity a única coisa que ele fazia era instanciar essas cartas do banco para a cena, contendo as informações de cada carta como: pontos de ataque, pontos de defesa, nome da carta, e a imagem dela que era renderizada na Unity através do componente SpriteRenderer.

O vídeo do início da proposta pode ser visualizado logo abaixo:

[youtube]https://www.youtube.com/watch?v=lbERV7Jm2MQ[/youtube]

Porém, com o passar das semanas, o sistema foi ganhando forma e hoje conta com diversas classes para gerenciar cada aspecto do projeto.
No final das contas, o sistema está assim atualmente (24/07/19):

[youtube]https://www.youtube.com/watch?v=c9ieTwi3y9A[/youtube]

>> Banco de dados:
- Sistema de leitura e acesso ao banco de dados para criar os decks de cartas (maiores informações no primeiro vídeo acima);

- Graças à flexibilidade do SQLite, é possível construir de forma simples e direta os decks de cada jogador, basta adicionar à tabela de 'Jogadores' um novo registro de jogador, e ir adicionando ou removendo as cartas registradas no banco de dados para cada jogador, assim é possível criar diversos decks diferentes, com as cartas que desejar!

>> Deck Manager:
Classe responsável por gerenciar tudo o que for associado aos decks dos jogadores:

- Gerenciamento dos decks através de pilhas(stacks);
- Adição de informações das cartas do banco de dados para as pilhas de decks;
- Gerenciamento da quantidade de cartas no deck;
- Embaralhamento do deck ao iniciar a partida através do algoritmo: Fisher-Yates Shuffle.

>> Draw Manager:
Classe responsável por manipular o sistema de Draw (compra) de cartas do jogo.
Essa classe é parcial e foi dividida em duas:

- Draw Manager Amount:
Responsável por gerenciar quantas cartas deverão ser instanciadas do deck para a mão dos jogadores, possibilitando instanciar as cinco cartas iniciais, quanto qualquer quantidade subsequente, como por exemplo, ao se utilizar de alguma carta com efeito similar ao Pot Of Greed.
Basta apenas passar como argumento da função de Draw da classe, a quantidade de cartas que deseja instanciar, que o sistema fará automaticamente a compra dessas cartas.

Também responsável por verificar se o jogador possui cartas suficientes para comprar, e caso não, encerra a jogada fazendo com que o jogador que não tenha mais cartas para comprar, perca.

Por ser uma classe pequena, posso mostrá-la aqui de ante-mão:

Código:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace YuGiOhManager{
 
 public static partial class DrawManager{

  private const float timeToAnimation = 0.3F;

  public static IEnumerator DrawCards(int amount, bool isMainPlayer = true){

   var currentDeck = isMainPlayer ? DeckManager.deck : DeckManager.deckAI;

   for (int i = 0; i < amount; i++) {
    if (currentDeck.Count > 0) {
     yield return new WaitForSeconds (timeToAnimation);
     InstantiateInScene (isMainPlayer);
    } else {
     DialogueUI.ShowDialogue ((isMainPlayer ? "Player 1" : "Player 2") + " doesn't have enough card to draw. Lose!");
     GameManager.gameOver = true;
     yield break;
    }
   } 
  }
 }
}

- Draw Manager Instance:
Essa classe é responsável por instanciar de fato as cartas na cena, carregando as informações fornecidas do banco de dados.
São muitos processos como: Verificar se a carta a ser instanciada é uma carta do main player ou do bot, passar as informações do banco de dados para os prefabs das cartas, gerenciar o local da mão que essa carta será instanciada, e etc.

>> Hand Manager:
Essa classe fica ao encargo de gerenciar tudo o que diz respeito às cartas na mão do jogador.

- Função que retorna qual "mão" está sendo avaliada (cartas na mão do main player ou do bot);

- Função de Sort Hand (reorganizar as cartas na mão, assim que uma carta é escolhida para ser jogada no campo);

- Função que remove a carta da mão e coloca no tabuleiro, assim que a carta é escolhida.

Essa classe também é muito importante para o sistema de Inteligência Artificial escolher qual carta ela irá jogar de sua mão para o campo.

>> Board Manager:
Nesta classe estão as funções responsáveis por manipular as cartas que estão em campo (no tabuleiro).

- Verificar se o campo está vazio;
- Verificar se o campo está cheio;
- Verificar qual melhor local para colocar a carta em campo;
- Retorna qual campo está sendo analisado (de qual jogador);
- Sistema de Replace Card (substituição). Quando o campo está cheio, deve-se substituir uma carta já existente no tabuleiro por uma selecionada da mão.

>> Battle Manager:
Essa classe tem a responsabilidade de gerenciar tudo o que for relacionado ao sistema de batalha.

- Define as cartas que estão batalhando;
- Define quem está atacando e quem está sendo atacado;
- Verifica quem perdeu ou ganhou a batalha;
- Desconta os pontos de vida do perdedor;
- Verifica possíveis empates;
- Chama a classe de animação de batalha;
- Destrói do campo a carta perdedora da batalha;
- Sistema de atacar pontos de vida diretamente.

>> Battle Animation Manager:
A classe "Battle Manager", como dito acima, é responsável por gerenciar a batalha do jogo, mas a parte do feedback visual dessa batalha fica à cargo da classe: "Battle Animation Manager". Então essa classe é responsável por ativar as animações na cena de acordo com o tipo da batalha.
Quem atacou ganhou da carta atacada? Quem atacou perdeu da carta atacada? Foi empate? Não houve nada? Ataque direto aos pontos de vida? Todas essas animações são gerenciadas através de uma enumeração de ações, de acordo com a batalha que ocorreu e as cartas envolvidas na mesma.
É através dessa classe também que são mostrados os pontos de vidas descontados na tela.

>> Change Turn Manager:
Essa classe faz o papel de gerenciar de quem é a vez, e de encerrar a mesma, quando algum jogador solicitar, chamando os eventos necessários para "reiniciar" a vez do próximo jogador.
Também é responsável por chamar a classe da Inteligência Artificial para que ela possa jogar, caso esteja na vez dela.

>> State Manager:
Aqui não se trata de uma classe em específico, mas sim de um escopo do namespace "YuGiOh System", para armazenar as enumerações que serão utilizadas em todas as classes do sistema, como as enumerações das fases do turno (Draw Phase, Main Phase, Battle Phase, End Phase), o estado atual da carta (OnHand, OnBoard), enumerações dos estados das batalhas (já citados anteriormente), delegados para gerenciar eventos do sistema, e etc.

>> UI Manager:
Essa classe gerencia as informações que serão visualizadas na UI da Unity, como as imagens da carta selecionada, seus pontos e nome.
Seu evento de mostrar essas informações na UI é disparado através de uma outra classe chamada "Mouse Manager" que é um componente do prefab das cartas, que detecta se o cursor do mouse está sobre a carta, assim, caso esteja, as informações daquela carta são mostradas em cada componente da UI, como os de Image e Text.

>> Game Manager:
Essa classe é algo mais generalizada, que visa armazenar informações globais do jogo e não de algo específico como as classes Managers anteriores.

- Armazena os pontos de vida dos jogadores;
- Os turnos dos jogadores;
- Se é o primeiro turno ou não;
- A fase atual;
- Se é game over;
- Se alguma animação de batalha está sendo executada;
- Se a caixa de diálogos está ativada;
- Armazena as cartas atuais que estão sendo selecionadas para alguma ação.

>> Outras classes:
Além dessas classes que gerenciam o sistema, há outras classes mais específicas, como a classe que ativa as caixas de diálogos, o sistema de animações das compras de cartas, as ações de cada carta na mão (Set Up, Set Down e Cancel), as ações das cartas no tabuleiro (Battle, Change Mode, Cancel), inicialização das informações da partida, Mouse Manager, superclasse responsável por receber as informações do banco de dados, e etc.

>> Inteligência Artificial (I.A)

Artificial-Intelligence.jpg


Como o projeto não é online, se fez necessário a inserção de um sistema de I.A básico para jogar contra o jogador principal.
Essa I.A foi muito inspirada no bot dos primeiros oponentes do já citado Yu-Gi-Oh Forbidden Memories do PS1, ou seja, com uma tática ofensiva, tendo a prioridade em atacar seus pontos de vida e destruir as suas cartas, apesar de ela possuir algumas cartas defensivas em seu deck.

A I.A foi dividida em dois scripts: Um que decide qual é a melhor carta para selecionar na mão e jogar no tabuleiro, de acordo com diversos fatores influenciáveis em suas decisões, tais como: A carta que desejo selecionar é capaz de vencer de alguma carta no campo do oponente? Existe alguma carta no MEU campo que já dá conta do recado? É melhor eu me defender? Descarto a carta mais fraca da mão? Ataco os pontos de vida diretamente? e etc.

O outro script é responsável por fazer a I.A decidir qual a sua melhor ação com suas cartas já em campo, como: Vai batalhar? Se sim, contra qual carta do oponente? Vai só se defender? Mudar a posição de batalha de alguma carta? E assim por diante...

No final de vários e vários testes, apesar de uma I.A básica, ela atende bem as expectativas, procurando sempre fazer a melhor jogada que a traga mais benefícios.

>> O que pretendo implementar no futuro?
O sistema está completo com tudo que planejei desde a sua concepção, mas isso não irá me impedir de implementar novos recursos posteriormente.
Alguns que tenho em mente são:

- Adição de cartas do tipo "Spell" e "Trap";
- Deck Viewer, ou seja, um visualizador para as cartas do seu deck;
- Mais inimigos, com decks diferentes, ou seja, vai surgir a necessidade de criar um sistema de seleção de personagens.

>> Onde o sistema vai ser disponibilizado?
Download 64 BITS da versão demonstrativa:

https://mega.nz/#!lawUGSJa!9UtT2OEqbuTisNxzZMaoJY-DshpNBUXDFm1VVNch9To

O game over de fato ainda não foi implementado, também pretendo mudar algumas ações da AI, e adicionar o sistema de descarte na próxima atualização, mas já está jogável.




ATUALIZAÇÕES - 03/12

E aí pessoal, como vão? Depois de muitos meses sem mexer no projeto, hoje finalmente eu pude dar aquela atualizada que eu mais gostaria de dar (agora com PC novo é só alegria). Confira abaixo as novidades:

1. Seleção de Personagens:
Com a seleção de personagens agora é possível jogar contra outros oponentes além daquele de testes! Isso significa que você terá mais possibilidades de jogadores para desafiar, decks diferentes e cartas novas!!
O sistema te possibilita criar decks diferentes para cada jogador, dessa forma, você pode ter vários oponentes diferentes para duelar contra, pois a AI é genérica e vai saber lidar com qualquer deck que ela tiver disponível.
Os personagens adicionados na versão DEMO foram:


  • Shade (O jogador padrão de AI do primeiro teste
  • Rex Raptor e seu deck de zumbi + dinossauros
  • Weevil Underwood e seu deck de insetos
  • Mai Valentine e seu deck de Harpias e Fadas
  • Bandit Keith e seu deck de feras
  • Yami Bakura e seu deck defensivo e dark
  • Pegasus e seu deck apelativo xD
  • Isis Ishtar e seu deck de água
  • Seto Kaiba e seu deck dragão (sim, tem o Blue Eyes)
  • Heishin e seu deck imbatível (não dá pra ganhar dele, que sacanagem né)

Screenshot da seleção de personagens:
v3kpOwm.png



2. Mais opções de ações:
Além de setar suas cartas para cima ou para baixo e cancelar a ação na DrawPhase, o jogador também pode agora ler a descrição da carta selecionada e o mais legal de tudo: Descartar a carta também!
Com o sistema de descarte é possível eliminar cartas da sua mão que você julgue "inúteis" e na próxima vez que você comprar, você ganhará novas cartas referente à quantidade de cartas descartas. Por exemplo: Se descartar 3 cartas, na próxima rodada você comprará novas 3 cartas.
Esse sistema é similar do que já temos no Yu-Gi-Oh Forbbiden Memories, mas nesse caso o jogador descarta as cartas fundido elas erradamente de propósito.

Para abrir a janela das novas opções, clique na carta com o lado direito do mouse!

Screenshot das novas opções:
DUpJFzw.png



3. Cartas de Spells!!
Essa sem dúvidas era a notícia que eu mais gostaria de anunciar para vocês! Agora o sistema conta com cartas mágicas (spells) para serem jogadas e terem seus efeitos ativados, mudando totalmente o rumo da partida!
Todo o sistema já está pronto pra receber as spells (adição ao board, ativação do seu respectivo efeito, prefab da carta e etc).
Para testes eu já criei duas spells: Raigeki e Dark Hole e elas já estão com seus efeitos criados e funcionando ingame!! 
Por enquanto apenas o player principal pode ativar spells, pois para a AI ainda preciso fazer um algoritmo para ela "pensar" qual o melhor momento para ativar a spell na partida, mas em breve estarei fazendo isso.

Screenshots da spell no jogo:

3vlV6VE.png

Dark Hole ativado:
C6xJWeR.png



O que tem por vir:
Mas as novidades não param por aí! Ainda pretendo melhorar algumas decisões da AI para deixar ela mais precisa, adicionar outras cartas spells além dessas duas, colocar a possibilidade de cartas Traps e Fields, fazer um sistema de Deck Viewer e possibilitar a AI de jogar cartas mágicas e descartar cartas da mão.

Em breve mais atualizações e links para download. 
 
Alguém disse... Yu-Gi-Oh?!?
Com certeza isso será bem interessante sim May, os membros irão gostar bastante, afinal de contas, vários sistemas podem ser feitos com a versatilidade dessa mecânica, não apenas a mesma do game. Se não me falha a memória, o [member=770]Resque[/member] estava criando um projeto de YGO...
Até evento de Yu-Gi-Oh! tivemos aqui no fórum (e não foi o único, aguardem...), creio que irá despertar sim o interesse de algumas pessoas!
Parabéns, a aula ficou muito bem explicada!
 
Yu-Gi-Ohhhhhhhhhhhhhhhhhhhhhh!!!!

Olá [member=895]Mayleone[/member]!!!

Vi o seu vídeo e gostei muito! Cada passo ficou bem explicado, eu nunca mexi com Unity, mas pelo seu vídeo consegui ver que uma ferramenta super poderosa, vou ficar de tocaia aqui e vou esperar ansiosamente pelo próximo tutorial.


Sobre o projeto de Yugi que a [member=962]Jully Anne[/member] comentou, ainda está numa fase bemmm, mas beeem inicial, lembro de até ter comentado sobre com você May, pois você também tinha um projeto de Yugi bem top.

Estou tendo vários problemas com a programação da AI para o meu projeto, e as suas aulas vão me ajudar muito!

Acabei de fazer o upload de uma prévia do meu projeto que está sendo feito no Ace. Não é lá grande coisa, mas espero concluir ele em breve com todas as regras de duelo e cartas da primeira temporada.


https://youtu.be/wODDbsZeEuU
 
Jully Anne comentou:
Alguém disse... Yu-Gi-Oh?!?
Com certeza isso será bem interessante sim May, os membros irão gostar bastante, afinal de contas, vários sistemas podem ser feitos com a versatilidade dessa mecânica, não apenas a mesma do game. Se não me falha a memória, o [member=770]Resque[/member] estava criando um projeto de YGO...
Até evento de Yu-Gi-Oh! tivemos aqui no fórum (e não foi o único, aguardem...), creio que irá despertar sim o interesse de algumas pessoas!
Parabéns, a aula ficou muito bem explicada!

Valeu!!! Então pelo visto o pessoal gosta mesmo de YGO por aqui hein?
Estou trabalhando no sistema quase todos os dias, então é provável que eu lance uma tutorial sim, vamos ver!

Resque comentou:
Yu-Gi-Ohhhhhhhhhhhhhhhhhhhhhh!!!!

Olá [member=895]Mayleone[/member]!!!

Vi o seu vídeo e gostei muito! Cada passo ficou bem explicado, eu nunca mexi com Unity, mas pelo seu vídeo consegui ver que uma ferramenta super poderosa, vou ficar de tocaia aqui e vou esperar ansiosamente pelo próximo tutorial.


Sobre o projeto de Yugi que a [member=962]Jully Anne[/member] comentou, ainda está numa fase bemmm, mas beeem inicial, lembro de até ter comentado sobre com você May, pois você também tinha um projeto de Yugi bem top.

Estou tendo vários problemas com a programação da AI para o meu projeto, e as suas aulas vão me ajudar muito!

Acabei de fazer o upload de uma prévia do meu projeto que está sendo feito no Ace. Não é lá grande coisa, mas espero concluir ele em breve com todas as regras de duelo e cartas da primeira temporada.


https://youtu.be/wODDbsZeEuU

Uau! Tá ficando bem completo o seu sistema, gostei de ver!
Como está fazendo no Ace presumo que esteja usando RGSS3, certo? Fiquei curiosa para saber como resgata as informações das cartas, vc instância tudo de uma vez, ou pega as infos conforme elas vão sendo sorteadas?
A única coisa que eu não gostei foi da demora pra comprar as cartas, acho que poderia ser um pouco mais rápido isso aí, mas de resto está muito bom, pelo visto vai ter até monstros com efeitos, bacana!
Quero ver como vai ficar essa AI, é a parte mais chatinha de fazer mesmo, ainda estou planejando a minha.

Eu também andei dando uma atualizada no meu e agora coloquei o background que o King Gerar havia me feito há dois séculos atrás para o meu projeto, depois posto um vídeo com as devidas atualizações.

[member=770]Resque[/member] , se quiser os códigos do meu projeto para dar uma olhada basta mandar uma PM que eu envio pra ti, okay?
Boa sorte para nós, porque não é fácil. :D
 
Como já comentei no vídeo, achei muito bom, espero que saia o tutorial completo.
 
Apesar de fazer pouca coisa, seu sistema parece legal. Tirando a questão do SQLite, ele parece uma porta de entrada boa para um sistema de cartas (até porque agora ele só saca as cartas).

O Fisher–Yates shuffle não é a mesma coisa que o Shuffle do Linq? Parece que o Linq não tem um Shuffle. Por essa não esperava, já que linguagens como Ruby, Python e até mesmo Java contam com esse método.

Qual a vantagem de usar um banco de dados para um jogo assim? Banco de dados são muito úteis para valores modificados em runtime se necessitam de pesquisas (buscar todos os cards de um tipo X). Outro uso bom é quando a massa de dados é muito grande para ser carregada de uma vez só ou é necessário segurança, logo um servidor gerencia esse tipos de dado. Mas, como as cartas são definidas antes da compilação, não vejo ganho em um sistema assim. Claro, não estou falando para partir para uma abordagem code-driven. Um XML, YAML, JSON ou até um CSV resolveriam a questão das cartas. Na Unity eu particularmente gosto de ScriptableObject para este fim.

Como está fazendo no Ace presumo que esteja usando RGSS3, certo? Fiquei curiosa para saber como resgata as informações das cartas, vc instância tudo de uma vez, ou pega as infos conforme elas vão sendo sorteadas?
Já codifiquei um jogo de cartas uma vez. Fiz os decks salvos serem uma lista de IDs das cartas. Durante a partida eu carregava um Array gigante contendo todas as cartas do jogo. Daí eu só acessava os dados por ID. Uma carta de Yu-Gi-Oh! com descrição de algumas linhas ocuparia uns 500 bytes. Logo se tivesse 10.000 cartas no jogo, gastaria menos de 5Mb. Claro, isso salvo as imagens. Eu carregava todas as imagens das cartas presentes nos decks antes da partida (durante uma tela de loading) e reutilizava conforme necessário (basicamente um Flyweight) .
 
Obrigada, Eranot pelo apoio!

[member=779]FL[/member]
Em relação a sua dúvida sobre o SQLite, na verdade eu ainda pretendo criar um sistema de inserção e remoção de cartas no deck, então como você mesmo disse, o banco de dados facilitaria no que diz respeito a essas queries mais específicas, como procurar por tipo, Level e etc.
Acredito também que a inserção desses valores é mais prático através de uma tabela de banco de dados, apesar de que cogitei realmente usar um JSON para tal.

Por enquanto ele só saca cartas para os jogadores, mas pretendo expandir para um sistema de YGO básico.

Em relação ao shuffle, eu estou testando alguns algoritmos do tipo, por enquanto nenhum me agradou, a maioria sortea as cartas de uma forma muito repetitiva, mas estou estudando e procurando por algoritmos mais eficazes, porém não tão complexos pois se tratará de um tutorial.

Interessante esse esquema de carregar todas as imagens antes do jogo iniciar, no meu caso, eu só crio uma instância da classe que recebe as informações das cartas dentro de uma lista e só quando a carta é sorteada para a cena é que o Sprite da Unity recebe a imagem lá do banco de dados.
 
[member=895]Mayleone[/member]

Mayleone comentou:
Uau! Tá ficando bem completo o seu sistema, gostei de ver!
Como está fazendo no Ace presumo que esteja usando RGSS3, certo?

Isso ae, Gosto de JavaScript mas ainda acho que Ruby permite um desenvolvimento ágil e organizado ao mesmo tempo, além de ser a linguagem de programação que tenho mais experiência.

Mayleone comentou:
Fiquei curiosa para saber como resgata as informações das cartas, vc instância tudo de uma vez, ou pega as infos conforme elas vão sendo sorteadas?

Basicamente, fiz da forma mais simples, igual o [member=779]FL[/member], criei um Array de Hash dentro do projeto. Esse Hash tem as informações das cartas que eu consigo buscar previamente em uma Api online:

https://db.ygoprodeck.com/api/v5/randomcard.php

Depois de salvar em um arquivo o retorno API de todas as cartas que eu preciso, eu coloco o resultado manualmente dentro do meu código, ficando assim:

Código:
$cards = [
  [
    {
      id: "59627393",
      name: "Number 105: Battlin' Boxer Star Cestus",
      type: "XYZ Monster",
      desc: "3 Level 4 monsters During either player's Battle Step, if a "Battlin' Boxer" monster you control battles an opponent's monster: You can detach 1 Xyz Material from this card; negate the effects of the opponent's monster until the end of the turn, that monster you control cannot be destroyed by that battle, also your opponent takes any battle damage you would have taken from that battle.",
      atk: "2500",
      def: "1600",
      level: "4",
      ...
    },
    { 
      id: "73511233",
      name: "Performapal U Go Golem",
      type: "Pendulum Effect Monster",
      desc: "[ Pendulum Effect ] Once per turn, if a monster is Fusion Summoned to your field (except during the Damage Step): You can add 1 "Performapal", "Odd-Eyes", or "Magician" Pendulum Monster from your Graveyard or face-up in your Extra Deck to your hand. ---------------------------------------- [ Monster Effect ] Once per turn, during your Main Phase, if this card was Pendulum Summoned this turn: You can Fusion Summon 1 Fusion Monster from your Extra Deck, using this card you control and Dragon-Type monsters you control as Fusion Materials.",
      atk: "1600",
      def: "1000",
      level: "4"
      ...
    }
...
  ]

O carregamento das cartas eu faço no início do duelo, e mantenho as cartas na memória, como cada duelista só pode ter um 40 cartas no deck, então eu não tenho problemas de performance (melhorias vão ser feitas no futuro, mas atualmente estou mantendo da forma mais simples possível).

Mayleone comentou:
A única coisa que eu não gostei foi da demora pra comprar as cartas, acho que poderia ser um pouco mais rápido isso aí, mas de resto está muito bom, pelo visto vai ter até monstros com efeitos, bacana!

Muito obrigado!

Preciso dar uma ajustada no visual e nas animações mesmo, primeiramente vou tentar fechar um ciclo de duelo 100% funcional. Assim que eu tiver tempo em trabalhar nessas melhorias, posto o resultado aqui.


Mayleone comentou:
Quero ver como vai ficar essa AI, é a parte mais chatinha de fazer mesmo, ainda estou planejando a minha.

Eu imagino haha, atualmente a minha AI só sabe colocar cartas mágicas no campo viradas para baixo =(

Vou deixar essa parte mais pra frente, mas pretendo usar algum tipo de state machine.

Mayleone comentou:
Eu também andei dando uma atualizada no meu e agora coloquei o background que o King Gerar havia me feito há dois séculos atrás para o meu projeto, depois posto um vídeo com as devidas atualizações.

Boa! Vou ficar de olho aqui.

Mayleone comentou:
[member=770]Resque[/member] , se quiser os códigos do meu projeto para dar uma olhada basta mandar uma PM que eu envio pra ti, okay?

Opa beleza!! Igualmente hahaha.

Mayleone comentou:
Boa sorte para nós, porque não é fácil. :D

Não mesmo, valeu aí May!! No aguardo dos seus próximos vídeos.
 
[member=895]Mayleone[/member]
E esse tema nostálgico do Forbidden Memories ai de fundo? Espero que, quando o sistema evoluir, tenha regras, ao contrário do jogo de PS1 que mencionei, porque juntar uma nuvem peidando com uma topeira e sair uma mulher-cigarra é dose kkkkkk.
No aguardo de mais atualizações, boa sorte!

[member=770]Resque[/member]
[youtube]https://www.youtube.com/watch?v=wODDbsZeEuU[/youtube]
276162_Papel-de-Parede-Meme-Cereal-Guy-Cuspindo_1600x1200_400x400.jpg

Lembro que você tinha mencionado uma vez, mas, agora que vi, parece muito com um jogo do GBA que joguei uma vez, está ficando muito bom isso ai cara!
 
[member=770]Resque[/member]
Muito legal essa API e bem mais prática também do que ter que ficar pesquisando as cartas por aí, não conhecia!

No caso da minha AI eu estava inicialmente pensando em fazer com o algoritmo mini-max, mas acho que para a quantidade de jogadas possíveis (mesmo sendo só monstros sem efeito e tal) seria muito complexo pra processar essa árvore de decisão, então ainda to pensando em como vai ser, talvez uma AI mais ofensiva que priorize atacar o adversário sempre (igual a AI dos oponentes iniciais do próprio FB), daí ela só defende realmente se tiver algum monstro mais forte no lado oposto, mais ainda vou ver como vou fazer também, tenho outras coisas pra planejar antes disso. Aliás, aceito sugestões nessa parte hehe!

Sobre a hash, entendi como funciona sim, bem prático.
No meu caso eu tenho uma class encapsulada "Properties"que tem as propriedades das cartas, então quando conecto com o Banco de Dados e ele varre todos os registros da tabela, eu crio uma instância dessa classe e armazeno as informações lidas do BD para a instância, depois que a instância já tiver todas as informações necessárias eu guardo ela numa lista que seria como se fosse o deck mesmo, daí eu embaralho o deck (a lista das instâncias) e quando a carta é comprada eu jogo as informações de "Properties" para uma classe especial da Unity que renderiza a sprite da carta na cena e armazena as informações dela pra usar na partida futuramente:

Código:
 class Card : MonoBehaviour{
public int Id {get; set;}
public int Atk {get; set;}
public int Def {get; set;}
public string Name {get; set;}
public UnityEngine.Texture2D image {get; set;}
}

[member=1]Yoshi[/member]
Hã?? Vou fingir que entendi hahaha!
Mas eu vou ver ainda como que fica essa questão de regras, eu acho que não teria saco para fazer as cartas com efeitos, traps e etc... Como vai ser só um tutorial base, acho que daí a pessoa pode expandir o sistema como quiser, inclusive adicionando esses detalhes.
Porém, isso é algo muito distante ainda, estou apenas na parte do draw e começando a fazer as actions das cartas, vamos ver se faço sim.



Só um printzinho da coisa toda:
MJVna4n.png
 
Yoshi comentou:
[member=770]Resque[/member]
[youtube]https://www.youtube.com/watch?v=wODDbsZeEuU[/youtube]
276162_Papel-de-Parede-Meme-Cereal-Guy-Cuspindo_1600x1200_400x400.jpg

Lembro que você tinha mencionado uma vez, mas, agora que vi, parece muito com um jogo do GBA que joguei uma vez, está ficando muito bom isso ai cara!

Valeu [member=1]Yoshi[/member]!!!

Realmente, os sprites das caras são do Yu-Gi-Oh! The Eternal Duelist Soul de GBA.


Mayleone comentou:
[member=770]Resque[/member]
Muito legal essa API e bem mais prática também do que ter que ficar pesquisando as cartas por aí, não conhecia!

Sim! Mais informações sobre a API pode ser encontrada no guia do site: https://db.ygoprodeck.com/api-guide/


Mayleone comentou:
[member=770]Resque[/member]
No caso da minha AI eu estava inicialmente pensando em fazer com o algoritmo mini-max, mas acho que para a quantidade de jogadas possíveis (mesmo sendo só monstros sem efeito e tal) seria muito complexo pra processar essa árvore de decisão, então ainda to pensando em como vai ser, talvez uma AI mais ofensiva que priorize atacar o adversário sempre (igual a AI dos oponentes iniciais do próprio FB), daí ela só defende realmente se tiver algum monstro mais forte no lado oposto, mais ainda vou ver como vou fazer também, tenho outras coisas pra planejar antes disso. Aliás, aceito sugestões nessa parte hehe!

Realmente, a parte da AI é bem complicada, nunca usei mini-max, vou dar uma olhada como funciona.

Inicialmente eu vou implementar a AI mais burra possível e aos poucos vou melhorando ela, essa sugestão que você deu é muito boa, inicialmente só atacando e defendendo e depois implementar uma Finite State Machine, que pelo que li, não é muito complexo:

https://www.construct.net/en/tutorials/how-to-simplify-your-ai-code-with-finite-state-machines-728


Mayleone comentou:
[member=770]Resque[/member]
Sobre a hash, entendi como funciona sim, bem prático.
No meu caso eu tenho uma class encapsulada "Properties"que tem as propriedades das cartas, então quando conecto com o Banco de Dados e ele varre todos os registros da tabela, eu crio uma instância dessa classe e armazeno as informações lidas do BD para a instância, depois que a instância já tiver todas as informações necessárias eu guardo ela numa lista que seria como se fosse o deck mesmo, daí eu embaralho o deck (a lista das instâncias) e quando a carta é comprada eu jogo as informações de "Properties" para uma classe especial da Unity que renderiza a sprite da carta na cena e armazena as informações dela pra usar na partida futuramente:

Código:
 class Card : MonoBehaviour{
public int Id {get; set;}
public int Atk {get; set;}
public int Def {get; set;}
public string Name {get; set;}
public UnityEngine.Texture2D image {get; set;}
}

Legal!! Dessa forma da pra se beneficiar de várias ferramentas que o banco de dados já tem!

Mayleone comentou:
[member=770]Resque[/member]
[member=1]Yoshi[/member]
Hã?? Vou fingir que entendi hahaha!
Mas eu vou ver ainda como que fica essa questão de regras, eu acho que não teria saco para fazer as cartas com efeitos, traps e etc... Como vai ser só um tutorial base, acho que daí a pessoa pode expandir o sistema como quiser, inclusive adicionando esses detalhes.
Porém, isso é algo muito distante ainda, estou apenas na parte do draw e começando a fazer as actions das cartas, vamos ver se faço sim.

MANO AEORIAEOIR o [member=1]Yoshi[/member] ainda lembra das fusões malucas do FM.

[member=895]Mayleone[/member], basicamente, nesse jogo dava pra fazer várias fusões sem sentido, e acho que nem precisava de Polymerization.


Mayleone comentou:
Só um printzinho da coisa toda:
MJVna4n.png

Karaaai *----* muito top!
 
Mayleone comentou:
Em relação a sua dúvida sobre o SQLite, na verdade eu ainda pretendo criar um sistema de inserção e remoção de cartas no deck, então como você mesmo disse, o banco de dados facilitaria no que diz respeito a essas queries mais específicas, como procurar por tipo, Level e etc.
Linq já resolve o problema da pesquisa para você. Busca por SQL só compensaria se fosse muito complexa (altos joins e uso de views), frequente (por questões de performance) ou a base de dados fosse muito grande (por não conseguir carregar tudo de uma vez).

Mayleone comentou:
Acredito também que a inserção desses valores é mais prático através de uma tabela de banco de dados, apesar de que cogitei realmente usar um JSON para tal.
Tem várias ferramentas para manupular formatos JSON e companhia. A própria Unity provê uma interface ótima aos ScriptableObjects (via seu inspector) e a customizar não é difícil. Com um atributo em consigo exibir sprites e até mesmo modelos 3D.

Enfim, utilizar SQLite na Unity para dados imutáveis em um jogo é uma prática deveras incomum, mas se você se sente confortável com ela, então continue. Tem gente que gosta de fazer jogo de plataforma no RPG Maker, mesmo existindo ferramentas melhores para tanto.

Mayleone comentou:
Interessante esse esquema de carregar todas as imagens antes do jogo iniciar, no meu caso, eu só crio uma instância da classe que recebe as informações das cartas dentro de uma lista e só quando a carta é sorteada para a cena é que o Sprite da Unity recebe a imagem lá do banco de dados.
A desvantagem do meu método, é que se ele carregar muitas imagens em alta resolução num device mais fraco (tipo um iPad velho), a aplicação irá fechar por usar muita memória.

A desvantagem do seu método é o lag se o device for fraco e a imagem pesada. Mas com imagem assim não tem solução, ou você sacrifica a memória (no meu método), ou coloca um lagzinho ou mesmo um loading de cada imagem individual (seu método).

Resque comentou:
Basicamente, fiz da forma mais simples, igual o [member=779]FL[/member], criei um Array de Hash dentro do projeto. Esse Hash tem as informações das cartas que eu consigo buscar previamente em uma Api online:

https://db.ygoprodeck.com/api/v5/randomcard.php
Essa API é um baita achado! E o cara ainda colocou os pontos de ataque e defesa como strings para lidar com os casos mais malucos do TCG. Sagaz!

Mayleone comentou:
No meu caso eu tenho uma class encapsulada "Properties"que tem as propriedades das cartas, então quando conecto com o Banco de Dados e ele varre todos os registros da tabela, eu crio uma instância dessa classe e armazeno as informações lidas do BD para a instância, depois que a instância já tiver todas as informações necessárias eu guardo ela numa lista que seria como se fosse o deck mesmo, daí eu embaralho o deck (a lista das instâncias) e quando a carta é comprada eu jogo as informações de "Properties" para uma classe especial da Unity que renderiza a sprite da carta na cena e armazena as informações dela pra usar na partida futuramente:
Hummm. Eu não faria dessa forma. Se seguir assim, todo e qualquer efeito que permita olhar o Deck fará você carregar e descarregar todas as texturas. No entanto, se as imagens forem muito pequenas isso não faz muita diferença. Enfim, é algo para se medir.

Mayleone comentou:
Código:
 class Card : MonoBehaviour{
public int Id {get; set;}
public int Atk {get; set;}
public int Def {get; set;}
public string Name {get; set;}
public UnityEngine.Texture2D image {get; set;}
}
Eu particularmente evito atrelar dados de um registro (os atributos da carta) direto num componente (parente da MonoBehaviour). Criaria uma classe chamada CardData que teria esses atributos e adicionaria ela no Card, junto com propriedades para acessar os valores por praticidade, ou mesmo para sobrescrever caso haja algum equipamento ou efeito. Também usaria uma classe abstrata ou interface já pensando na implementações de tokens, apesar que ainda é cedo para o sistema.

Fazendo isso os dados ficariam mais fácil de manipular em efeitos mais complexo que uma carta copia a outra. E de qualquer forma você irá precisar armazenar o ataque original e o ataque após os modificadores. Claro, você pode consultar direto o banco de dados quando isso for necessário, mas não é algo prático.
 
[member=770]Resque[/member]
Sobre a AI, state machine é realmente algo muito mais simples de ser implementado, eu prefiro usar quando se trata de AIs mais convencionais, mas ela pode acabar por se tornar previsível se não tomar cuidado e usar apenas uma lógica booleana. Acho interessante neste caso implementar junto da máquina de estado uma lógica Fuzzy para dar uma maior gama de escolhas, e uma certa porcentagem de ações para a AI não ficar tão "robótica".

Em relação ao que o Yoshi disse hmmmm agora faz sentido o que ele falou! Eu também não curto muito aquele sistema de fusão, ele meio que bagunça o jogo, acho que colocaram mesmo para balancear o game já que nos decks iniciais haviam apenas cartas com atk e Def muito baixos, daí surgiu a necessidade de fundir essas cartas para dar origem a uma mais poderosa, mas eu sinceramente não gosto disso, por isso é como eu falei no vídeo, não terá esse sistema de fusão maluca no meu não.

Hoje já iniciei a implementação das ações das cartas, por enquanto só coloca no campo e escolhe se vai ser para baixo ou para cima, mas já criei uma interface para padronizar esses comportamentos nas classes que podem vir além das dos monstros, como da AI e das spells.

[member=779]FL[/member]
Ué, o SQLite possui uma biblioteca justamente para lidar com as funções da Unity e muitas vezes é uma melhor opção do que PlayerPrefs e afins.
Eu sei que o LINQ é capaz de organizar minha coleção e retornar consultas iguais de uma query de um banco de dados, aliás adoro trabalhar com LINQ, acho bem prático principalmente por empregar um paradigma mais declarativo que eu prefiro para essas situações do que ter de ficar fazendo trocentos foreach nas coleções, mas realmente para o que estou planejando, o SQLite está suprindo bem as minhas necessidades, mesmo porque, como eu disse, irei fazer um sistema de inserção de cartas em runtime, e com SQLite basta puxar a tabela do jogador e inserir um novo dado nela, com poucas linhas de código. Sem dizer a fácil manipulação com as tabelas para gerenciar cada deck de forma simples, o jogo te permite ter quantos decks quiser, eu coloquei apenas dois para o sistema (A AI e o main player) mas quem for expandir pode adicionar decks para outros jogadores, tanto para outros oponentes de AI quanto para uma possível versão online.
Outro fator é que eu nunca havia realizado até o momento uma integração com BD no Unity, sabia apenas a teoria e nunca tive a oportunidade de usar na prática, até surgir essa ideia de poder armazenar as cartas registadas em algum local externo e que me fizesse escrever pouco.
Ainda não estudei a fundo sobre esse ScriptableObject, vou dar uma olhada, talvez realmente pode ser uma alternativa frente ao SQLite, vou pesquisar a respeito porque realmente não é algo que eu tenha muito conhecimento.

Por fim, eu não passo os dados diretamente para uma classe de componente do Unity, mesmo porque não se pode instanciar do jeito tradicional uma class que herda de Monobehaviour, se você fosse tentar, levaria vários warns em console.
O que eu faço é exatamente o que você disse: existe uma classe apenas para receber as informações do Banco, que como eu disse, se chama "Properties" e então essas informações são passadas para uma classe da Unity (essa aí que postei) chamada "Card", que aí sim recebe as informações do banco e renderiza a textura no componente de Sprite do prefab da carta.

Enfim, ainda estou na fase de planejamento e testes, muita coisa ainda pode ser que seja alterada e refatorada, mas está sendo interessante todo o processo, estou aprendendo demais com tudo isso e é isso que eu busco ao tentar iniciar um novo projeto!

Obrigada a todos pelos comentários, e desculpe qualquer erro no texto, estou escrevendo pelo celular e ele tende a corrigir algumas palavras que não deveria. xD
 
Mayleone comentou:
Sobre a AI, state machine é realmente algo muito mais simples de ser implementado, eu prefiro usar quando se trata de AIs mais convencionais, mas ela pode acabar por se tornar previsível se não tomar cuidado e usar apenas uma lógica booleana. Acho interessante neste caso implementar junto da máquina de estado uma lógica Fuzzy para dar uma maior gama de escolhas, e uma certa porcentagem de ações para a AI não ficar tão "robótica".
Quando é um jogo de turnos e as possibilidades são muitas para criar um mini-max, eu prefiro utilizar pontuações com pesos. Em algumas partes eu aplico mini-max. A menos que o jogo contenha fases ou comportamentos muito distintos (AKA modo stall e modo vai ou racha), eu não uso uma FSM.

Mayleone comentou:
Ué, o SQLite possui uma biblioteca justamente para lidar com as funções da Unity e muitas vezes é uma melhor opção do que PlayerPrefs e afins.
Para uma persistência bem elaborada, com muitas relações (e não apenas composição) eu concordo que necessita de um modelo entidade relacionamento. Mas no caso que você deu, a menos que o jogador consiga editar cartas, o único dado mutável seria o baralho.

Só que você está usando para os dados da carta, que não são definidos em runtime. Ou seja, são dados que podem ser adicionados diretamente no jogo ao invés de, na inicialização, você popular tabelas SQL com dados imutáveis.

Mayleone comentou:
irei fazer um sistema de inserção de cartas em runtime, e com SQLite basta puxar a tabela do jogador e inserir um novo dado nela, com poucas linhas de código
Não sei se entendi direito. Em runtime quer dizer que as cartas mudam enquanto o jogador está jogando. Consegui interpretar sua frase de duas formas: Um back-end que manda requisições pro front-end via algum protocolo (geralmente WebService). Se for então o seu sistema é bem mais ambicioso do que havia imaginado. Se bem que hoje em dia existem muitas alternativas para alugar servidores que são pouco acessados. A outra interpretação seria o jogador que cadastra as cartas em runtime. Das dezenas de jogos de Yu-Gi-oh! já lançados, eu não conheço nenhum que o jogador consegue inserir cartas.

Mayleone comentou:
Outro fator é que eu nunca havia realizado até o momento uma integração com BD no Unity, sabia apenas a teoria e nunca tive a oportunidade de usar na prática, até surgir essa ideia de poder armazenar as cartas registadas em algum local externo e que me fizesse escrever pouco.
Esse é um ótimo motivo.

Mayleone comentou:
Por fim, eu não passo os dados diretamente para uma classe de componente do Unity, mesmo porque não se pode instanciar do jeito tradicional uma class que herda de Monobehaviour, se você fosse tentar, levaria vários warns em console.
O que eu faço é exatamente o que você disse: existe uma classe apenas para receber as informações do Banco, que como eu disse, se chama "Properties" e então essas informações são passadas para uma classe da Unity (essa aí que postei) chamada "Card", que aí sim recebe as informações do banco e renderiza a textura no componente de Sprite do prefab da carta.
Entendi. Pensei que não fazia isso porque não estava no código que postou. a diferença é que você mantém uma cópia dos valores no MonoBehaviour ao invés de usar uma propriedade que definiria isso com base em cards anexados e/ou outras regras. Bem, dá para fazer dessas duas formas, é questão de gosto.
 
[member=779]FL[/member]
Como te disse por MP, o Scriptable Object realmente é uma ótima alternativa para o que estou fazendo, em breve irei desenvolver outro TCG usando essa ferramenta da Unity, mais uma vez obrigada!



Updates (14/07/19)

[youtube]https://www.youtube.com/watch?v=UsocQ1EUWHY[/youtube]

Adição de background;
Draw pra AI;
Sistema de ações das cartas: set up, down, change mode, battle e cancel;
Sistema de reorganizar cartas na mão quando joga uma carta ao campo;
Animação quando passa o mouse na carta;
Animação quando compra carta;
Refatoração do código;
Adição de novas cartas no banco de dados.


E também:

Fiz a ação de substituir cartas (Replace) quando o tabuleiro está com cinco cartas (cheio).
É bem simples: Se o seu tabuleiro estiver cheio, o sistema vai esperar até que você escolha alguma carta que já está em campo para ser substituída, então ao fazer isso, a carta antiga sai do tabuleiro e é mandada ao graveyard (por enquanto é só destruída da cena, mesmo) e a nova carta vai para o campo na posição da carta destruída.

Testei aqui fazendo com que o player inicialmente compre 7 cartas (só pra ver como que fica) e não ativei a Main Phase quando se coloca a carta em campo, dessa forma, ficamos na Draw Phase e eu posso colocar cartas a vontade no tabuleiro, e assim que ele fica cheio e eu tento colocar mais uma carta em campo, o sistema pede pra fazer a substituição, então está tudo funcionando corretamente como esperado.​
 
O trabalho está ficando excelente! o layout lembra bastante o Yu-Gi-Oh Duel Generation de celular.
obs: essa musica é muito nostálgica  :headphone:
 
Mayleone comentou:
[member=779]FL[/member]
Como te disse por MP, o Scriptable Object realmente é uma ótima alternativa para o que estou fazendo, em breve irei desenvolver outro TCG usando essa ferramenta da Unity, mais uma vez obrigada!



Updates (14/07/19)

[youtube]https://www.youtube.com/watch?v=UsocQ1EUWHY[/youtube]

Adição de background;
Draw pra AI;
Sistema de ações das cartas: set up, down, change mode, battle e cancel;
Sistema de reorganizar cartas na mão quando joga uma carta ao campo;
Animação quando passa o mouse na carta;
Animação quando compra carta;
Refatoração do código;
Adição de novas cartas no banco de dados.


E também:

Fiz a ação de substituir cartas (Replace) quando o tabuleiro está com cinco cartas (cheio).
É bem simples: Se o seu tabuleiro estiver cheio, o sistema vai esperar até que você escolha alguma carta que já está em campo para ser substituída, então ao fazer isso, a carta antiga sai do tabuleiro e é mandada ao graveyard (por enquanto é só destruída da cena, mesmo) e a nova carta vai para o campo na posição da carta destruída.

Testei aqui fazendo com que o player inicialmente compre 7 cartas (só pra ver como que fica) e não ativei a Main Phase quando se coloca a carta em campo, dessa forma, ficamos na Draw Phase e eu posso colocar cartas a vontade no tabuleiro, e assim que ele fica cheio e eu tento colocar mais uma carta em campo, o sistema pede pra fazer a substituição, então está tudo funcionando corretamente como esperado.​

[member=895]Mayleone[/member] O sistema está ficando muito bom! Teve um grande evolução desde a primeira versão que você apresentou.

O tabuleiro está incrível! Creio que com o tamanho de tela que você tem, daria para diminuir um pouco a carta com imagem deixar ela no lugar das cartas com fundo preto na mão do jogador.

O sistema de reorganização está com um pouco de delay, mas tirando isso ficou ótimo!!

No aguardo de mais vídeos hehe
 
[member=770]Resque[/member]
Obrigada pelas sugestões, eu segui meio o que você falou e deixei disponível a miniatura da carta, mas não consigo diminuir o espaço da carta maior porque não foi eu quem fez o layout, foi o King Gerar em 2014 (eu acho) e eu só tenho o PNG finalizado da arte, então não posso redimensionar determinadas partes dela. :\



Feliz em anunciar a conclusão do sistema de YuGiOh na Unity!

Desde a última atualização postada, muita coisa mudou:

- Adição do sistema de batalha, verificando cartas que ganham ou perderam, se houve empate e mostrando todas essas informações através de um BattleAnimation Manager, ou seja, um gerenciador de animações que mostra as imagens das cartas batalhando e quem venceu, bem como os pontos de vida descontados do perdedor, igual ao Forbidden Memories do PS1.

- Mais cartas adicionadas aos decks do player e do bot (totalizando 40 cartas para cada)

- Sistema de caixa de diálogo para mostrar mensagens.
Diferente do RPG Maker, no Unity não existe um sistema padrão de caixa de mensagens, então eu tive que fazer do zero, por isso destaco aqui.

- Sistema de pilha(Stack) para gerenciar os decks (antes era List)

- Refatoração de MUITOS códigos;

- Sistema de EndPhase (para encerrar turno) e consequentemente um sistema que gerencia a vez de cada jogador.

- Inteligência artificial básica: Muito parecida com a tática ofensiva da IA do ygo do PS1. Sempre dando preferência por atacar seus pontos de vida ou suas cartas em campo.
Ela foi dividida em dois Scripts: Um que gerencia a escolha da carta que vai ser jogada da mão para o tabuleiro ( eu disse que ia colocar pra ela escolher aleatoriamente, mas ficou muito falho)
E outro que gerencia as ações das cartas quando elas estão em campo, se vai atacar, defender, trocar posição de batalha, e etc.

Esse projeto deu um trabalho absurdo para ser feito, mas fico muito feliz por ter concluído como eu esperava esse desafio!

Ainda no futuro pretendo implementar spells e traps(algumas que tem no Forbidden Memories, como Raigeki), um sistema de deck Viewer e outros personagens da IA com outros decks mais específicos, mas isso vou deixar mais pra frente. Por agora só existe o duelo.

Caso queriam ver como ficou tudo, eis um vídeo:

[youtube]https://youtu.be/c9ieTwi3y9A[/youtube]
 
[member=895]Mayleone[/member]

Tinha dado uma olhada por cima, mas só agora tive tempo de ler todas as novidades que você escreveu.

Acabei de ver o vídeo e ler o tópico principal que você editou, ficou muito bom!!!!! Parabéns!!!

Mayleone comentou:
- Adição do sistema de batalha, verificando cartas que ganham ou perderam, se houve empate e mostrando todas essas informações através de um BattleAnimation Manager, ou seja, um gerenciador de animações que mostra as imagens das cartas batalhando e quem venceu, bem como os pontos de vida descontados do perdedor, igual ao Forbidden Memories do PS1.

Curti bastante a animação de batalha das cartas, o movimento que a carta faz para colidir com a outra está bem legal. Se você colocar uns efeitos vai ficar muito top!

- Mais cartas adicionadas aos decks do player e do bot (totalizando 40 cartas para cada)


Mayleone comentou:
- Sistema de caixa de diálogo para mostrar mensagens.
Diferente do RPG Maker, no Unity não existe um sistema padrão de caixa de mensagens, então eu tive que fazer do zero, por isso destaco aqui.

Nunca trabalhei com Unity, mas por ser uma ferramente bem conhecida, eu tinha certeza que existiria algum sistema padrão de caixa de mensagens. O bom é que agora você poderá usar o seu sistema em futuros projetos.

Mayleone comentou:
- Inteligência artificial básica: Muito parecida com a tática ofensiva da IA do ygo do PS1. Sempre dando preferência por atacar seus pontos de vida ou suas cartas em campo.
Ela foi dividida em dois Scripts: Um que gerencia a escolha da carta que vai ser jogada da mão para o tabuleiro ( eu disse que ia colocar pra ela escolher aleatoriamente, mas ficou muito falho)
E outro que gerencia as ações das cartas quando elas estão em campo, se vai atacar, defender, trocar posição de batalha, e etc.

Achei esse sistema bem legal, esse sistema permite a AI bolar estratégias de combo ou algo esse tipo?

Mayleone comentou:
Esse projeto deu um trabalho absurdo para ser feito, mas fico muito feliz por ter concluído como eu esperava esse desafio!

Imagino... e você conseguiu fazer bem rápido! Qual foi a parte mais difícil de ser feita?

Mayleone comentou:
Ainda no futuro pretendo implementar spells e traps(algumas que tem no Forbidden Memories, como Raigeki), um sistema de deck Viewer e outros personagens da IA com outros decks mais específicos, mas isso vou deixar mais pra frente. Por agora só existe o duelo.

Ficarei só no aguardo, as cartas mágicas e armadilha dão aquele toque especial no Yu-Gi-Oh!. O sistema ficou muito top, parabéns!!!
 
Voltar
Topo Inferior