Jogo de tabuleiro

Tenho perguntas
To criando um jogo de tabuleiro e queria saber como que quando cair num talz numero do dado o player andasse tantos quadrados bom do dado cair um numero aletoriamente eu sei queria saber como faze o player andar esses tantos de casa

outra pergunta qnd for a hora do inimigo o dado roda aletoriamente e cai num tal numero e quanto cair ele ande tantas casas.

é bom eu sei como fazer o dado cair um numero aletoriamente keria saber por exemplo se cair o numero cinto aperaça a sprite Dado N° 5

Código:


if numero_do_dado=1
{codigo de andar uma casa}

if numero_do_dado=2
{codigo de andar duas casa}


e asim vai

Acredito que não é algo tão simples assim, como pude entender pelo que o Oscarlos Show disse. Mas vamos esperar pela resposta dele.
Mesmo assim, vlw pela sua ajuda!

Ainda não testei mais ja entendi vou tentar depois.

digamos q ao apertar espaço o dado gire, em seguida jogador deverá andar o nº de casas indicado
no dado(caso seja a vez dele, se nao for a vez dele, quem andará é o obj_cpu, ou seja, o computador):
No evento key press space do obj_dado, bote:

Código:

sprite_index=choose(spr_1,spr_2,spr_3,spr_4,spr_5,spr_6)
if global.turno=1 obj_player.alarm[0]=30
if global.turno=2 obj_cpu.alarm[0]=30

No event create do obj_player bote

Código:

mover=0

no alarm[0] do obj_player bote

Código:

if dado.sprite_index=spr_1 mover=1
if dado.sprite_index=spr_2 mover=2
if dado.sprite_index=spr_3 mover=3
if dado.sprite_index=spr_4 mover=4
if dado.sprite_index=spr_5 mover=5
if dado.sprite_index=spr_6 mover=6
alarm[1]=5

no evento alarm[1] do obj_player

Código:

if mover>0 {x+=30;mover-=1;alarm[0]=15}
if mover=0 global.turno=2

crie agora o obj_cpu, que é o adversario(computador), com alarm[0] igual ao do obj_player, e com o seguinte alarm[1]:

Código:

if mover>0 {x+=30;mover-=1;alarm[0]=15}
if mover=0 global.turno=1

no event create do obj_dado bote:

Código:

global.turno=1

se global.turno for igual a 1, será a vez do player, se for 2 será a vez do adversario, caso seja
jogo de tabuleiro com mais de 2 players, voce vai botando turno=3, turno=4, etc...

Nesses exemplos, os movimentos são sempre x+=30, isso você altera como quiser criando uma condição,
tipo se o player estiver em determinada região ou colidir com tal objeto(q fica numa curva) x+=30,
se tiver em outra y+=30, etc.
tava tentando mandar essa resposta desde umas horas atras, mas internet caindo direto.

Até que eu gostei da idéia do Oscarlos Show, e graças ao Mannoroth, poderei utilizar para mim.
Muito obrigado pela sua ajuda, Mannoroth, isso vai ser muito útil para mim!

como faço para ele andar as determinadas casas

suponho que você queira usar um tabuleiro em "cobra", ou seja, sem uma geometria bem definida, não é mesmo? Bom, isso pode dar trabalho...

Primeiro, vamos melhorar o esquema de aparecer a sprite do dado. Se for só aparecer mesmo, sem ter que mostrar o dado girando, você pode criar uma sprite com seis imagens (ou com o número de imagens do seu dado, que pode ser diferente de seis) e colocar as imagens em ordem crescente. daí, basta escrever essas linhas:

Código:

vlorDoDado=floor(random(6))+1;
image_index=valorDoDado-1;

"porque +1 e -1?" porque se eu usasse ceil(random(6)), haveria uma infintésima possibilidade do resultado ser 0, e eu quero só de 1 a 6. "-1" é pra levar em conta o image_index=0.
"Podia determinar o image_index e fazer o valor do dado igual a ele +1?" Podia, eu que não quis.

Agora, a parte difícil - andar num tabuleiro sem geometria... ( eu sem meu manual )
Bom, obviamente, você vai precisar de um path. Pra cada casa do tabuleiro, crie um ponto desse path. Existem algumas funções que te retornam
- a posição atual do objeto no path (com relação à sua extensão, ou seja, quantos % do path já foram percorridos)
- a posição (x, y) dos pontos do path
- o número de pontos no path
e, se não me engano, existe também uma função que te retorna a posição do objeto no path com relação aos pontos.

A idéia é, no create event, atribuir esse path ao objeto do jogador e ao objeto da CPU. Fácil, grave ele numa variável local e pronto.
Daí, como cada ponto do path corresponde a uma casa, você vai buscar no resultado do dado quantas casas tem que andar. Traduzindo: você, ao rodar o dado, vai ver em que casa está e começar a andar e não parar até estar na casa (casa inicial)+(resultado do dado). Ou na última casa.

Sem o manual, fica difícil criar códigos, mas acho que deu pra passar a idéia geral. Se você gostou, mas estiver com dificuldades em elaborar os códigos, me avise que, com tempo, eu tento criar uns scripts.

Edit: Ih, caramba, tá todo mundo banido nesse tópico?

eu entendi um pouquinho da logica mais não estou conseguindo elaborar o codigo preciso disso urgente me ajuda.
valeu

Ok, parece que não existe uma função que te retorna em que ponto você está, mas existem as seguintes funções úteis:
path_speed - define a velocidade em que se caminha o path
path_get_point_x(ind,n)
path_get_point_y(ind,n) - definem a posição (x, y) de um ponto usado no path
path_get_number(ind) - acha o número de pontos do path
Bom, essas são as que eu considero mais úteis pro seu caso. Basicamente, você deve jogar o dado e adicionar o número ao ponto atual do path em que você está. O resultado é o ponto em que você deve chegar. Ao jogar o dado, defina path_speed pra algum valor diferente de zero e, quando a distância entre a posição e o ponto a ser atingido for menor ou igual à velocidade (você chegou perto o suficiente do ponto), a velocidade será definida pra zero e o ponto a chegar será definido como ponto atual.

Vou fazer um step event e um evento pro dado, aqui. Volto em alguns minutos (ou dias, vai depender de se funcionou ou não...)

Edit: Até que não foi difícil. No create, coloquei isso aqui:

Código:

posAtual=0; //posição atual
posProx =0; //próxima posição
path_start(path0, 0, 1, 0); //o path (note a velocidade=0 e o absolute=0)
nLados=3; //número de lados do dado
dado=0; //resultado do dado (essa é a última vez que ele será zero)
move=3; //a velocidade em que o path será percorrido

Daí, no step, fiz assim:

Código:

if (path_speed==0){ //se está parado (evita de jogar várias vezes ao mesmo tempo)
    if (keyboard_check_pressed(vk_space)){ //se apertar o espaço
        dado=floor(random(nLados))+1; //sorteia o dado
        posProx=posAtual+dado; //define a casa a ser atingida
        path_speed=move; //começa a se mover
        }
    }
    else{ //se NÃO está parado
        if point_distance(x, y, xstart+path_get_point_x(path0, posProx), ystart+path_get_point_y(path0, posProx))<move{ //se a distância ao destino é menor que a velocidade
            path_speed=0; //pára de se mover
            posAtual=posProx; //atualiza a posição atual
            }
        }

E, pra entender o que está acontecendo, usei um pouquinho disso aqui no draw:

Código:

draw_path(path0, xstart, ystart, 0);
draw_sprite(sprite_index, 0, x, y);
draw_circle(xstart+path_get_point_x(path0, posProx), ystart+path_get_point_y(path0, posProx), 10, 1);

draw_text(20, 20, dado);
draw_text(20, 40, posAtual);
draw_text(20, 60, posProx);

--FIM--
Isso não é uma engine, é só uma forma rápida de fazer a coisa funcionar. Pra alternar entre os jogadores e demais truques, deixo por sua conta.
Os comentários explicam o código, use isso pra alterá-lo a seu bel-prazer. Se precisar de alguma explicação adicional, pode perguntar.
Lembre-se de adicionar os eventos da casa na ocasião dele parar e de evitar a casa a ser atingida esteja numa posição maior que o número de pontos do path.

valeu amigo !!!
mais como eu faço para inserir um segundo adversario com intelegencia artificial?
preciso tambem fazer ele exibir perguntas e voltas algumas casas quando necessario

Cria um A.I. pro segundo adversário... O A.I. vai depende muito do jogo que você vai cria, fica difícil da um pronto...

mucurino escreveu:valeu amigo !!!
mais como eu faço para inserir um segundo adversario com intelegencia artificial?
preciso tambem fazer ele exibir perguntas e voltas algumas casas quando necessario

Tanto eu quanto o gabrielsch demos soluções funcionais. Pra qual delas você quer uma IA?
Outra coisa: o adversário deve só se mover pelo tabuleiro, baseado no resultado dos dados, e sofrer as consequencias de onde ele cair ou deverá haver algum tipo de decisão a ser tomada?
Se for só se mover pelo tabuleiro, ele fará a mesma coisa que o jogador, só que não vai precisar apertar espaço. O jogo vai ficar muito chato, porque em pouco tempo o jogador vai perceber que não existe desafio, tudo se baseia em ter mais sorte com os dados.
Se houver alguma decisão a ser tomada, como o alexs2195 disse, depende demais do jogo que você está fazendo, não tenho informações suficientes pra te ajudar.

ele ira exibir perguntas caso ele erre devera voltar algumas casas caso acerte podera avançar

Qual o critério pra saber se o computador vai acertar ou errar?
Se for sorteio, fica fácil. Use uma engine de probabilidade qualquer e mande ver. Só que fica meio bobo, tipo o computador pode acertar uma pergunta agora e, muitas rodadas depois, errar a mesma pergunta.

Outra coisa, pra qualquer engine apresentada, você deve fazer adaptações pra hipótese de voltar casas. Ninguém pensou nisso, ainda. Nenhuma das engines é difícil de adaptar, mas elas DEVEM sofrer alterações.

[igorcandido16@hotmail]
me add no msn que ficas mais facil para que passamos esclarecer menhor esse jog.
vale!!!

Eu não uso msn... Além do mais, acho que sua dúvida pode ajudar outros usuários. Faça um texto explicando tudo o que você quer que aconteça, que aí eu não precisarei ficar perguntando.
Elaborar uma IA normalmente é uma tarfa árdua, mesmo, mas principalmente porque não sabemos o que queremos que ela faça. Uma vez definido isso (cada detalhe disso), o resto passa a ser trabalho braçal.

o jogo tem 2 playes o usuario e o PC. O usuario PC devera ter inteligencia artificial e responder e errar perguntas estas perguntas não deverão se repitir e caso o usuario erre a pergunta deverar voltar um determinado tanto de casas sem que o outro play volte também.

Deixa eu tentar te mostrar o que eu quero dizer com "tudo o que você quer que aconteça"...

No início do jogo, define-se quem começa através de serteio com os dados. A cada turno, um jogador age.
O tabuleiro é totalmente irregular, com umas casas maiores que as outras e algumas casas especiais. Não há sobreposição nem transposição de casas.
**Aqui começa a parte interessante**
Antes de jogar o dado, uma pergunta de múltipla escolha é apresentada ao jogador. Se ele acerta a resposta, anda pra frente o número de casas correspondente ao resultado do dado. Se erra, anda pra trás o mesmo número de casas.
As perguntas não devem se repetir numa mesma jogada. Se acabarem as perguntas, ganha quem estiver mais à frente. As perguntas também não devem aparecer sempre na mesma ordem. É possível, no início do jogo, escolher o tema a que se referem as perguntas. Tenho um banco de dados extenso de perguntas e alternativas.
Ao cair numa casa especial, o jogador pode escolher entre perguntas muito específicas ou perguntas com muitas respostas. Se ele acertar a resposta nessas casas, anda o dobro. Se errar, simplesmente não anda.
Quanto à IA, ela deve escolher uma resposta aleatória, ou seja, havendo 4 respostas, as chances dela acertar é de 1/4, ou seja, 25%. Se o jogador escolher o modo "difícil", essa probabilidade dobra (sim, se forem só duas respostas, a IA sempre acertará). No caso da IA cair em casas especiais, a escolha por "perguntas específicas ou com muitas respostas" também é aleatória. Deve haver um breve delay antes da AI fazer sua escolha, dando a impressão que alguém está pensando antes de tomar uma decisão.
**Aqui acaba a parte interessante**
Se sobrarem pontos nos dados ao chegar ao final, esses são ignorados e o jogador a chegar na última casa vence.

Isso é o que eu ACHO que seu jogo será. Mas não posso presumir isso, você tem que me dizer. Note que qualquer informação errada aí em cima resultaria numa engine diferente da que você quer desenvolver.