main (){
setlocale (LC_ALL, "Portuguese");
system ("color 07");
//Essse loop "ZERA" as casas do tabuleiro para qualquer novo jogo.
for (i=0; i<=3; i++){
for (j=0;j<=3; j++){
casa[i][j] = '\0';
}
}
if (opcao == 5){
system ("cls");
cabecalho();
informa ();
} else {
menu1();
informa ();
}
opcao=0;
//O loop seguinte repete o jogo enquanto se iniciarem novos jogos com os mesmos jogadores.
do {
//A função da estrutura de decisão abaixo é informar novamente ao programa os nomes dos
//jogadores 1 e 2. O programa só passará por ela, em caso de novo jogo com jogadores iguais aos da partida anterior.
if (nomeaux == 1){
strcpy (nome1, nomeaux1);
strcpy (nome2, nomeaux2);
cabecalho ();
tabuleiro ();
}
//Laço de repetição que determina a duração do jogo.
while (vencedor == 0 && turno < 9) {
tabuleiro ();
jogada ();
system ("cls");
cabecalho ();
tabuleiro ();
for (i=1; i<=3; i++){
verificavencedor (i, 1, i, 2, i, 3); //verifica vencedor nas colunas
verificavencedor (1, i, 2, i, 3, i); //verifica vencedos nas linhas
}
verificavencedor (1, 1, 2, 2, 3, 3); //verifica vencedor na primeira diagona
verificavencedor (1, 3, 2, 2, 3, 1); //verifica vencedor na segunda diagonal
}
printf ("Pressione qualquer tecla para continuar...\n\n");
getch ();
placar ();
printf ("Pressione qualquer tecla para continuar...\n\n");
getch ();
menu2();
} while (opcao == 1);
printf("Obrigado por jogar TicTacToe\nDesenvolvido por José Tarciso e Olliver Felipe.\n\n Pressione qualquer tecla para sair...");
getch();
}
int main ()
{
display tela;
display_create(&tela, 52, 25);
char direcao = 77;
int posicao[2] = {tela.width/2, tela.height/2 + 1};
int inimigos[23*48 - 1][2];
int n_inimigos = 0;
int vel = 150;
menu(&tela);
criar_cobra(&tela);
while (1) {
display_clear(&tela);
criar_inimigo(&tela, inimigos, &n_inimigos);
int i;
for (i = 0; i < n_inimigos; i++)
display_put_raw(&tela, inimigos[i][0], inimigos[i][1], 'X');
criar_bordas(&tela);
display_paint(&tela, posicao[0], posicao[1]);
while (kbhit()){
char aux = getch();
if (aux == CIMA || aux == BAIXO || aux == ESQUERDA || aux == DIREITA)
direcao = aux;
}
switch (direcao)
{
case CIMA:
posicao[1]++;
break;
case BAIXO:
posicao[1]--;
break;
case ESQUERDA:
posicao[0]--;
break;
case DIREITA:
posicao[0]++;
break;
}
velocidade(&vel);
placar(&tela, n_inimigos);
verificar_morte(&tela, posicao);
display_show(&tela);
Sleep(vel);
}
return 0;
}
/* ----------------------------------------------------------------------------------------*/
int acao_rayka(int vivos, int aps, int jogs,int jogatual,vetor jogadores)
{
int modA,alvo;
int raykaMP = jogadores[jogatual].mp;
int raykaHP = jogadores[jogatual].hp;
placar (jogs, jogatual, jogadores);
modA = rand()%(2);
if (modA) // Defensivo
{
printf ("Rayka entrou em modo defensivo!\n");
/* Se Rayka estiver com pouco mp, concentra */
if ((raykaMP < MV_mpc_plas+1) && (aps >= MV_apc_con))
{
printf("Rayka se concentra para recuperar seu poder!\n");
GL_concentra(jogatual,jogadores,MV_MIN_dmg_con,MV_mod_con);
sleep(t_delay);
return MV_apc_con;
}
/* Se Rayka estiver com pouco hp, cura */
if ((raykaHP < RaykaMinHP) && (aps >= MV_apc_cul) && (raykaMP >= MV_mpc_cul))
{
printf("Rayka usa seu poder para curar seus ferimentos!\n");
GL_cura(jogatual,jogadores, MV_MIN_dmg_cul, MV_mod_cul, MV_mpc_cul);
sleep(t_delay);
return MV_apc_cul;
}
/* Se Rayka estiver com stat forte, negatis.
Critério:
1. Rayka tem mp e ap suficiente.
2. Rayka vai perder no mínimo dois turnos pelas proximas duas rodadas
ou
2. Rayka var perder no mínimo três de hp pelas proximas três rodadas*/
if (
((aps >= MV_apc_neg) && (raykaMP >= MV_mpc_neg)) &&
(
((jogadores[jogatual].apmod.mod < -1) && (jogadores[jogatual].apmod.dur < -1))
|| /*or*/
((jogadores[jogatual].hpmod.mod < -2) && (jogadores[jogatual].hpmod.dur < -2))
)
)
/*then*/
{
printf("Rayka neutraliza seus status!\n");
GL_negatis(jogatual,jogadores);
sleep(t_delay);
return MV_mpc_neg;
}
/* Se nem cura nem concentração são necessários, então ataque*/
modA = !modA;
}
if (!modA) // Agressivo
{
printf ("Rayka entrou em modo agressivo\n");
if ((raykaMP >= MV_mpc_exp) && (aps >= MV_apc_exp) && (vivos > 2))
{
printf ("Rayka conjura uma grande explosão!\n");
GL_area_ataque(jogs, jogatual, jogadores, MV_MIN_dmg_exp, MV_mod_exp, MV_mpc_exp);
sleep(t_delay);
return MV_apc_exp;
}
if ((raykaMP >= MV_mpc_plas) && (aps >= MV_apc_plas))
{
printf ("Rayka ataca seu inimigo com plasma!\n");
alvo = AI_rayka_target(jogatual,jogs,jogadores);
GL_base_ataque(alvo,jogatual,jogadores,MV_MIN_dmg_plas,MV_mod_plas,MV_mpc_plas);
sleep(t_delay);
return MV_apc_plas;
}
if ((raykaMP >= MV_mpc_bdf) && (aps >= MV_apc_bdf))
{
/**<b>fixme:</b> AI_base_ataque devia cuidar de descontar mp como as outras funções de ataque fazem */
printf ("Bola de fogo!\n");
alvo = AI_rayka_target(jogatual,jogs,jogadores);
GL_base_ataque(alvo,jogatual,jogadores,MV_MIN_dmg_bdf,MV_mod_bdf,MV_mpc_bdf);
sleep(t_delay);
return MV_apc_bdf;
}
if ((raykaMP >= MV_mpc_lab) && (aps >= MV_apc_lab))
{
printf ("Labareda!\n");
alvo = AI_rayka_target(jogatual,jogs,jogadores);
GL_base_ataque(alvo,jogatual,jogadores,MV_MIN_dmg_lab,MV_mod_lab,MV_mpc_lab);
sleep(t_delay);
return MV_apc_lab;
}
}
// Se nada mais deu certo, cajadada!
printf("Rayka ataca com seu cajado!\n");
alvo = AI_rayka_target(jogatual,jogs,jogadores);
GL_base_ataque(alvo,jogatual,jogadores,GL_MIN_dmg_caj,GL_mod_caj,0);
sleep(t_delay);
return GL_apc_caj;
}
/* ----------------------------------------------------------------------------------------*/
int acao_branco(int aps, int jogs,int jogatual,vetor jogadores)
{
int acao,mpAtual = jogadores[jogatual].mp;
placar (jogs, jogatual, jogadores);
acao = opcoes_branco(aps,jogadores[jogatual].mp,jogadores[jogatual].buffer);
/* Tratador da ação do jagador. Note que, como ao entrar no case o valor da váriavel "acao" deixa de ser importante, ela é reutilizada para servir como a váriavel "alvo" */
switch (acao)
{
// ==== Cajado ========================================================================
case GL_caj:
{
acao = target(jogs,jogatual,jogadores,0);
GL_base_ataque(acao, jogatual, jogadores, GL_MIN_dmg_caj, GL_mod_caj, 0);
sleep(t_delay);
return GL_apc_caj;
}
// ==== Feixe de luz ==================================================================
case MB_ID_fdl:
{
if ((mpAtual < MB_mpc_fdl) || (aps < MB_apc_fdl))
return 0;
acao = target(jogs,jogatual,jogadores,0);
GL_base_ataque(acao, jogatual, jogadores, MB_MIN_dmg_fdl, MB_mod_fdl, MB_mpc_fdl);
sleep(t_delay);
return MB_apc_fdl; // Custo de aps da magia
}
// ==== Raio ==========================================================================
case MB_ID_ray:
{
if ((mpAtual < MB_mpc_ray) || (aps < MB_apc_ray))
return 0;
acao = target(jogs,jogatual,jogadores,0);
GL_base_ataque(acao, jogatual, jogadores, MB_MIN_dmg_ray, MB_mod_ray, MB_mpc_ray);
sleep(t_delay);
return MB_apc_ray; // Custo de aps da magia
}
// ==== Furação =======================================================================
case MB_ID_fur:
{
if ((mpAtual < MB_mpc_fur) || (aps < MB_apc_fur))
return 0;
GL_area_ataque(jogs, jogatual, jogadores, MB_MIN_dmg_fur, MB_mod_fur, MB_mpc_fur);
sleep(t_delay);
return MB_apc_fur; // Custo de aps da magia
}
// ==== Tornado =======================================================================
case MB_ID_torn:
{
if ((mpAtual < MB_mpc_torn) || (aps < MB_apc_torn))
return 0;
acao = target(jogs,jogatual,jogadores,0);
GL_base_ataque(acao, jogatual, jogadores, MB_MIN_dmg_torn, MB_mod_torn, MB_mpc_torn);
sleep(t_delay);
return MB_apc_torn; // Custo de aps da magia
}
// ==== Cura ==========================================================================
case MB_ID_cur:
{
if ((mpAtual < MB_mpc_cur) || (aps < MB_apc_cur))
return 0;
acao = target(jogs,jogatual,jogadores,3);
GL_cura(acao, jogadores, MB_MIN_dmg_cur,MB_mod_cur,MB_mpc_cur);
sleep(t_delay);
return MB_apc_cur; // Custo de aps da magia
}
// ==== Acelerar ======================================================================
case MB_ID_haste:
{
if ((mpAtual < MB_mpc_haste) || (aps < MB_apc_haste))
return 0;
acao = target(jogs,jogatual,jogadores,2);
GL_ap_effect(acao,jogatual,jogadores,MB_dmg_haste,MB_dur_haste,MB_mpc_haste);
sleep(t_delay);
return MB_apc_haste; // Custo de aps da magia
}
// ==== Concentração ==================================================================
case MB_ID_con:
{
if (aps < MB_apc_con)
return 0;
GL_concentra(jogatual,jogadores, MB_MIN_dmg_con, MB_mod_con);
sleep(t_delay);
return MB_apc_con; // Custo de aps da magia
}
// ==== Magia Superior ================================================================
case MB_ID_pow:
{
if ((mpAtual < MB_mpc_pow) || (aps < MB_apc_pow)|| (jogadores[jogatual].buffer > 1))
return 0;
GL_charge(jogatual,jogadores,MB_mpc_pow);
sleep(t_delay);
return MB_apc_pow; // Custo de aps
}
// ==== Parar tempo ===================================================================
case MB_ID_st:
{
if ((mpAtual < MB_mpc_st) || (jogadores[jogatual].buffer < 1) || (aps < MB_apc_st))
return 0;
MB_stopTime(jogatual,jogadores);
sleep(t_delay);
return MB_apc_st; // Custo de aps
}
// ====================================================================================
}
return 0; // Não foi uma escolha válida então não gasta ap.
}
