Você é uma figura…
estou solicitando código…
já procurei …alias em muitos outros sites de código fonte…
mas não achei,
se você não tem…
não entre no tópico
capisco? OO
Então ao invés de reclamar, formule melhor suas perguntas.
Qualquer formula de “arremesso vertical” resolve o que você quer.
Cara pesquise pela API GTGE. Eles tem exemplos de movimentação, gravidade, etc prontos, é só você baixar, rodar os exemplos, e verificar os fontes.
Dyorgio , não fique nervoso. Geralmente qdo se faz uma pergunta muito subjetiva, as respostas são desse tipo.
Caso vc colocasse aí o código e perguntasse sobre algum bug, alguma dúvida ou o porque disso ou daquilo, teria respostas melhores.
Não seja rude com as pessoas que vem no forum com o intuito de ajudar, tirar dúvidas e contribuir com essa enorme base de conhecimento que temos aqui.
Abraços.
[quote=dyorgio]agora…se for pra me dizer como fazer …se for pra ficar viajando na fisica de inercia, movimento…particulas…
não escrevam…guardem o conhecimento pra vocês…
3 pessoas escreveram no tópico…e não responderam o que eu perguntei…
agora eu tenho um tópico todo sujo…
obrigado[/quote]
Não, não vou guardar, conhecimento não ocupa espaço e nem pesa, respondi o que vc perguntou, só não te dei nada pronto pra vc fazer Ctrl+C / Ctrl+V.
Comece estudando o movimento parabólico:
Isto é, se vc tem capacidade para isso, se não tem, então vamos começar por algo mais simples e identifique as suas dificuldades, preenchendo as lacunas do seu conhecimento na medida do possivel (o que também pode ser feito no GUJ).
E evite topicos sujos com este tipo de comentário mediocre.
Por exemplo, no método update do seu código, para fazer um delocamento em mru:
public void update() {
x = x + vx;
y = y + vy;
}
Agora, se você quer que exista gravidade. Lembre-mos que a gravidade é uma força constante, que força um mruv, ou seja a velocidade varia a cada instante de tempo t. Quer dizer, a cada chamada de nosso update.
public void update() {
vy = vy - g;
x = x + vx;
y = y + vy;
}
Não tem muito segredo. Veja o que diz o algoritmo da física a cada instante t, tente adaptar isso para o método update do seu móvel em questão.
No caso da bola quicar, existe outra força envolvida. A mesmo que deu um impulso inicial para baixo (que pode ter sido criada através do momento da bola e da gravidade). Nesse caso, essa força deve ser invertida.
Acho que não preciso dizer que vy e vx são atributos de sua classe que definem a velocidade em x e y do seu objeto móvel.
Agora… como fazer isso em java…
Bem, os algoritmos acima assumem que você tem uma taxa de updates por segundo constante, como proposto no livro Killer Programming in Java.
Se você estiver trabalhando com updates variáveis, seu método update vai ter que receber também um delta T, e você terá que ajustar o tamanho do deslocamento de acordo com esse delta, o que levaria a fórmulas ligeiramente diferentes.
Como eu disse, melhor mesmo é pegar um livro de física, entender o que acontece a cada instante de tempo e implementar. Tem que lembrar que a física do jogo também não precisa ser tão rigorosa quanto a real. Mesmo porque, se ficar rigorosa demais, pode perder a graça… já pensou se o Mario só pulasse bem baxinho? 
Você pode ler o livro Killer Game Programming in Java no site do próprio autor:
http://fivedots.coe.psu.ac.th/~ad/jg/
Talvez encontre algoritmos prontos por lá.
Ah sim, e eu só respondi sobre o livro de física pois como você mesmo disse:
[quote]Alguem sabe algumas formulas para isso?
sei que já existem diversas APIS como as que o JMonkey usa…
mas queria apenas as formulas matematicas[/quote]
Leia bem o que pediu…
Exemplo de Jogos ajuda ?
https://ping.dev.java.net/
https://genuts.dev.java.net/
Boa sorte! :thumbup:
Dê uma olhada aqui:
http://web.kellegous.com/ecrits/000858
Coloquei o fonte dessa página aqui no anexo. É em java.
Dá uma olhada aqui:
… naum sei programar jogos… mas adoro jogar… conheço vários jogos feitos em flash e que acredito não serem difíceis de implementar em java… por mais que vc não tenha uma animação montada num “stage” em swf… procure códigos fontes em outras linguagens… e tene adaptar… jogos do tipo mario e sonic que tem pulos e velocidade vc encontra de kilo na net… usar um descompilador flash também não é difícil…
fica só uma sugestão de algo que sei que não é impossível e nem tão difícil de fazer… adaptar códigos de outras linguagens para as que a gente usa, pelo menos para mim, é uma boa prática…
[]'s
PS: vinicius, parabens pelo blog, add Bookmark now… =]
[quote=ViniGodoy]Dá uma olhada aqui:
Cara, não entendi uma coisa no seu código.
[code]while (isRunning) {
long beforeTime = System.currentTimeMillis();
game.paintGraphics();
game.updateLogics();
long afterTime = System.currentTimeMillis();
long sleepTime = beforeTime - afterTime;
if (sleepTime > 0)
sleep(40 - sleepTime);
}[/code]
1- O sleepTime não deveria ser o contrário? O instante final menos o inicial?
2- Por que o teste sleepTime > 0 ? Isso não é sempre falso? Ou sempre verdade, caso inverta a operação do sleepTime.
3- O teste não deveria ser se o sleepTime é maior que o DESIRED_UPDATE_TIME ? Algumas vezes, o parâmetro para Thread.sleep() acaba sendo negativo.
Os códigos mais elaborados também estão dessa forma.
Valeu 
Na verdade, o algoritmo do site está um pouco desatualizado mesmo…
A versão final dele está nesse anexo.
Esse trecho em específico ficaria corrigido assim:
while (isRunning) {
long beforeTime = System.currentTimeMillis();
game.paintGraphics();
game.updateLogics();
long afterTime = System.currentTimeMillis();
long sleepTime = afterTime - beforeTime ;
if (sleepTime < 40)
sleep(40 - sleepTime);
}Obrigado por reparar e comentar!
Você tem razão. O teste tem que ser < DESIRED_UPDATE_TIME. Basicamente, se o tempo é menor, damos uma pausa, se é maior, calculamos o excesso. Dei uma revisada no algoritmo por lá, se quiser depois dá uma conferida.
O algoritmo final atualizei para o mesmo que está rodando no meu jogo.
Abraços!
dyorgio, você está trabalhando em alguma coisa relacionada a jogos e física?
Quanto a APIs, até que ponto vale a pena usá-las e a partir de quando vale a pena fazer a sua própria?
Pelo que tenho visto os subsistemas numa engine não são tão facilmente separáveis e reutilizáveis em vários softwares diferentes (por exemplo, um loader depende das estruturas de cena da engine, e isso é impossível de se fazer genérico), portanto imagino que fazer algumas coisas do zero seja vantajoso.
Olá, dyorgio!
Infelizmente, não me lembro de quase nada de física…
Antes de mais nada, não estou tomando partido de ninguém… :lol:
É que a grande maioria do pessoal aqui não curte muito quando o povo vem no GUJ com a intenção de pegar código pronto. Eu mesmo não costumo fornecer, principalmente se percebo que é pra trabalho de escola… :lol: Mas as vezes rola umas exceções :thumbup:
Como eu disse, não rola muito disso… sorry… 
[quote=dyorgio]já procurei …alias em muitos outros sites de código fonte…
mas não achei[/quote]
Tem um treco no google que é massa pra achar código fonte:
http://www.google.com/codesearch
A busca avançada dele é fenomenal. Aposto que lá você vai conseguir achar alguma coisa!
[quote=dyorgio]se você não tem…
não entre no tópico
[/quote]
Opa! Pra quê brigar? Sem apelar, ok? Aqui todo mundo é colega! Se há alguma rusga, por favor, utilize MP, ok? A comunidade do GUJ agradeçe.
“Don’t feed the trolls”
Você pergunta “capisci”, aí eu respondo (ou não) “capisco”. :thumbup:
Que é isso! Pra quê revidar? Que coisa! Quer revidar, use MP!
Eu digo isso por que já dei uma dessa antes. Vi que realmente os outros GUJnautas não querem ver discussões sem ser sobre Java.
A propósito, se ficar bravo comigo, por favor: MP em mim, ok?
“Don’t feed the troll”
Paz e Amor, pessoal!
Divirtam-se!
Um código para loops que uso por aqui…
[code] /**
*
* Loop principal do jogo.
*
*
* Este método calcula o tempo que se passou desde a última iteração com o
* jogo, checa a entrada do usuário e atualiza os objetos do jogo.
*
*/
public void gameLoop() {
Graphics2D graphics;
long newTime;
long deltaT;
if (oldTime == -1) {
oldTime = clock.getCurrentTime();
}
while (running) {
newTime = clock.getCurrentTime();
if (oldTime != newTime) {
/* calcula a diferença de tempo e atualiza o oldTime */
deltaT = newTime - oldTime;
oldTime = newTime;
/*
* adiciona e remove os objetos que se encontram nas listas de
* espera
*/
objectsList.addAll(addList);
addList.clear();
objectsList.removeAll(removeList);
removeList.clear();
/* verifica entrada do usuário */
checkInput(deltaT);
/* atualiza o estado do jogo */
updateGame(deltaT);
/* desenha o frame */
graphics = (Graphics2D) screenManager.getDrawGraphics();
draw(graphics);
graphics.dispose();
screenManager.showBuffer();
}
}
}[/code]
Bem, um resumo por cima, o objeto clock ali é atualizado constantemente a cada intervalo de tempo pré-definido, e o loop verifica se chegou a hora de atualizar o jogo se este valor for diferente de quando houve a última atualização.
Se precisar atualizar, calcula-se a variação do tempo que teve desde a última atualização e guarda em “deltaT” este valor, em ms, que é passado para cada objeto da cena no método update, implementado geralmente deste modo:
public void update(long deltaT) {
setX(getX() + deltaT * getVx());
setY(getY() + deltaT * getVy());
}
onde o vx e o vy são as velocidades em cada eixo, no meu caso em pixels / ms.
Como pode ver, meu método é um pouco diferente do que o ViniGodoy mostrou. O meu atualiza o estado do jogo antes de desenhar na tela e pode também pular alguns quadros, em momentos que o computador estiver muito ocupado com alguma coisa ou for lento demais para alcançar a taxa de quadros por segundo desejada, assim ele não rodará em câmera-lenta em micros mais modestos hehehe.
Espero que ajude 
Pois é, o algoritmo que propus implementa outra técnica, que busca manter o deltaT constante no update.
Acho isso interessante pois, embora o algoritmo do loop fique mais complicado, evita calculos de delta espalhados pelo código inteiro.
Não é pior ou melhor. Ambos algoritmos tem seus pontos fortes e fracos…
Bom, mas se você ver ali em cima, o deltaT só é calculado uma vez também, assim ele se mantém inalterado durante a atualização. [edit] Demorou mas agora entendi o que você quis dizer com deltaT constante… cada update vai sempre incrementar em um passo o jogo.
E com certeza não há melhor ou pior, isso vai depender de cada caso. O melhor seria juntar os dois e dar a opção pro usuário, se deseja habilitar o frame skip ou não, e quantos frames no máximo pular… com o método que usei ali fica um pouco complicado fazer isso mesmo.
Aliás, só vi agora que no código que você anexou aqui implementa tudo isso. Muito legal. Se eu tivesse internet liberada estaria lendo os links que você colocou hehehe.
Isso. É como o JMonkey trabalha. Lá tem diversas implementações do algoritmo.
O básico é ter aquela interface que eu descrevo no blog, com os métodos setup, renderGraphics, paint, update e tearDown.
Aí você pode fazer algoritmos com a política que quiser. Ou mesmo trocar de política e ver como o jogo fica.