Discussion :

[Vin789]

Bonjour

Je m'intéresse à la programmation de jeux 2D en réseau avec Java, j'utilise la librairie Slick2D. N'ayant pas d'expérience dans la programmation de jeux en réseaux je me suis lancé dans la lecture de ce tutoriel:
http://gafferongames.com/game-physic...ration-basics/

D'après ce que j'ai compris (mon niveau en maths/anglais est plutôt moyen ) la physique semble obligatoire pour la réalisation d'un jeux en réseau. J'ai donc commencé l'implémentation du RK4 en Java conformément au tutoriel de gafferongames. J'ai construit une petite démo basé dessus ou on peut déplacer un tank (Windows/Java SE6).

http://www.vin789.fr/wordpress/games/gogi.rar

Mon problème est le suivant, je n'arrive pas à intégrer la notion de rotation et diminution de la vitesse en fonction de la rotation. Le tutoriel 3 de gafferongame le fait mais dans un univers 3D avec des Quaternions. Hors je veux rester dans la 2D.

J'ai "bidouillé" le code de la méthode accélération pour faire ralentir mon tank mais on dirait surtout que ce dernier se déplace sur une patinoire . Il me manque surement la notion de masse ou de frottement de l'air.

Si quelqu'un peut m'aider à intégrer la rotation pour la 2D dans le R4K, je le remercie d'avance

Voici le code utilisé dans la partie physique de la démo (tout le code source est disponible dans le .rar):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
public class PhysicMath {
 
	private static Derivative evaluate(State initial, float t, float dt, Derivative d) {
		State state = new State();
		state.position.set(initial.position.x + d.dx.x * dt, initial.position.y + d.dx.y * dt);
		state.velocity.set(initial.velocity.x + d.dv.x * dt, initial.velocity.y + d.dv.y * dt);
 
		Derivative output = new Derivative();
		output.dx.set(state.velocity);
		output.dv.set(acceleration(state, t + dt));
		return output;
	}
 
	private static Derivative evaluate(State initial, float t) {
		Derivative output = new Derivative();
		output.dx.set(initial.velocity);
		output.dv.set(acceleration(initial, t));
		return output;
	}
 
	public static void integrate(State state, float t, float dt) {
		Derivative a = evaluate(state, t);
		Derivative b = evaluate(state, t + dt * 0.5f, dt * 0.5f, a);
		Derivative c = evaluate(state, t + dt * 0.5f, dt * 0.5f, b);
		Derivative d = evaluate(state, t + dt, dt, c);
 
		final float dxdt = 1.0f / 6.0f * (a.dx.x + 2.0f * (b.dx.x + c.dx.x) + d.dx.x);
		final float dydt = 1.0f / 6.0f * (a.dx.y + 2.0f * (b.dx.y + c.dx.y) + d.dx.y);
 
		final float dvxdt = 1.0f / 6.0f * (a.dv.x + 2.0f * (b.dv.x + c.dv.x) + d.dv.x);
		final float dvydt = 1.0f / 6.0f * (a.dv.y + 2.0f * (b.dv.y + c.dv.y) + d.dv.y);
 
		state.position.set(state.position.x + dxdt * dt, state.position.y + dydt * dt);
 
		float nvx = state.velocity.x + dvxdt * dt;
		float nvy = state.velocity.y + dvydt * dt;
 
		// Driven too fast is bad for health...
		if (Math.abs(nvx) < 80)
			state.velocity.x = nvx;
 
		if (Math.abs(nvy) < 80)
			state.velocity.y = nvy;
	}
 
	private static Vector2f acceleration(State state, float t) {
		float force = 0;
 
		if (state.input.left) {
			state.ang -= 2;
		}
 
		if (state.input.right) {
			state.ang += 2;
		}
 
		float dirX = (float) Math.sin(Math.toRadians(state.ang));
		float dirY = (float) -Math.cos(Math.toRadians(state.ang));
 
		if (state.input.down) {
			force -= 800;
		} else if (state.input.up) {
			force += 800;
		} else {
			if (!(state.velocity.x > -0.01f && state.velocity.x < 0.01f)) {
				state.velocity.x += -(state.velocity.x * 0.01f);
			}
			if (!(state.velocity.y > -0.01f && state.velocity.y < 0.01f)) {
				state.velocity.y += -(state.velocity.y * 0.01f);
			}
		}
 
		return new Vector2f(dirX * force, dirY * force);
	}
 
	private static class Derivative {
 
		public Vector2f dx; // derivative of position: velocity
		public Vector2f dv; // derivative of velocity: acceleration/force
 
		public Derivative() {
			this.dx = new Vector2f();
			this.dv = new Vector2f();
		}
	}

[Nyarlathotep]

N'ayant pas d'expérience dans la programmation de jeux en réseaux

Ce ne serait pas plus simple de commencer avec une intégration par Euler, plutôt ? (Même si "If you use Euler then you are a bloody idiot", les notions mathématiques derrière le RK4 ne sont pas accessibles à tout le monde)

Sinon, pour l'info, une force de frottement a généralement l'expression suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

F=-k*v

où F est le vecteur force de frottement
v le vecteur vitesse
k le coefficient de frottement (généralement dans l'intervalle 0..1)

Ça ne m'a pas l'air trop dur de l'intégrer au code existant, juste une petite modif de la variable "force".