Faire un jeu de plateforme en JAVA

[invited8db657c]

Bonjour, bonsoir à tous !
Actuellement en terminale, dans le but de ma spé je doit faire un programme.
Nous avons décidé d'en faire un mixant divers chose, dont des plateformes.
Mais on es dessus depuis bien 2 mois et on sèche (c'était un bon indicateur pour changer d'idée mais c'est trop tard x)).
Notre soucis est de rendre les plateforme viable, que notre personnage puisse si déplacé et tomber dans les trou quand il n'y a plus de plateforme.
Pour créer notre plateforme nous utilisons Tiled (et des tuiles 64x64) et nous codons sur Processing.
Notre prof nous a aiguiller sur le fait d'utiliser un tableau avec les valeurs des tuiles (et donc 0=vide) mais je n'arrive pas a visualiser le codage d'un tel système.

Voici le code actuel :

PImage fond, plate; //Variable image décor
PImage perso; //Variable image personnage du joueur
float absPerso, ordPerso;
float speed = 0;
float gravity = 0.1; 
int ligne, colonne;
int plateforme[] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 59, 10, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 57, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 59, 50, 19, 0, 0, 0, 0, 0, 0, 57, 62, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 59, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57, 62, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 2, 0, 5, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57, 62, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 59, 10, 10, 6, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22, 23, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 57, 62, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 5, 49, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

void setup() {
  size(1280, 512);
  // On charge les images
  fond = loadImage("Fond.png");
  plate = loadImage("carte test.png");
  perso = loadImage("persos.png");
  absPerso = 40;
  ordPerso = 345;
}

void draw () {
  image(fond, 0, 0);
  image(plate, 0, 0);
  image(perso, absPerso, ordPerso);
  ordPerso = ordPerso + speed;
  speed = speed + gravity;
  if (ordPerso > 370) {
    speed = speed * -0.95;
    ordPerso = 370;
  }
  if (absPerso<0) {
    absPerso=0;
  }
  if (absPerso > 1275) {
    absPerso=1275;
  }
}

void keyPressed() {
  if (key == CODED) {
    if (keyCode == RIGHT) {
      perso = loadImage("persos.png");
      absPerso = absPerso+5;
    } else if (keyCode == LEFT) {
      perso = loadImage("persosG.png");
      absPerso = absPerso-5;
    }
  }
}

Si jamais vous n'av ez rien que des pistes celà me serait très utile, merci d'avance
-----

[invite6486d7bd]

Donc vous avez un terrain de 20 x 8 (1280/64 et 512/64) composé de "blocs" (de 64 Pixels chaques... donc rectangulaires en fait ).

Mais si je regarde la définition du "terrain", ça ne colle pas.
On aurait plutôt du 40 x 16 et les blocs font donc 32 pixels.

 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 59,10,19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,22,23,23,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 0, 0, 0, 0, 0, 0, 57,1, 1, 1, 1, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 59,50,19,0, 0, 0, 0, 0, 0, 57,62,5, 5, 5, 5, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 2, 0, 59,10,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57,62,5, 5, 5, 5, 5, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 2, 0, 5,10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57,62,5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 59,10,10,6, 0, 24,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57,62,0, 0, 0, 0, 0, 0, 0, 0, 0, 22,23,23, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29,57,62,5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 10,10,10,10,10,10,10,10,10,10,10,10,5, 49,19,0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 10,10,10,10,10,10,10,10,10,10,10,10,10,10,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55,56,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55,56,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

Ca ressemble déjà plus à un terrain.

Les chiffres qui sont indiqués sont à mon avis les codes pour les types de blocs.
3,1,2 par exemple sont des blocs supérieurs, genre herbe, neige, ou que sais-je.
57 est de type escalier, 59 le bord gauche d'une rampe, etc.

Maintenant, pour ce qui concerne le code lui-même, c'est juste une amorce, il manque tout en fait...
Pour aller plus loin, il faudrait définir comment le jeu doit avoir lieu.
Je ne vois pas par exemple quoi que ce soit qui fait référence à des sauts. (en général sur les jeux de plateforme
on peut faire des sauts, ou grimper à des échelles, mais on ne sait pas si c'est le cas ici).

Je vois également que vous avez défini un déplacement de 5 pixels par appui clavier.
Ce nombre est à mon avis une erreur, il faudrait un multiple de 2, pour qu'il n'y ait pas décalage ou que le joueur
puisse contrôler précisément son positionnement sur les blocs. (De la même manière, le positionnement du joueur au début du jeu
doit également obéir à cette règle).

[invited8db657c]

Déjà merci de ta réponse ^^
Enfait je me suis rendue compte d'un soucis avec mon design de plateforme.
Je suis bel et bien en 64 pixels et en 40/16 mais j'ai enregistré la carte en 50%. Ce qui m'as tous divisé. Donc je dois plus voir mes tuiles comme du 32 ducoup ?

Alors les sauts sont bien prévue (on avait des échelles aussi mais au final on ne pense pas les utiliser, à voir) mais tout simplement pas codé. Car pour moi du moment que la plateforme ne fonctionne pas les déplacements (et donc les sauts) bah ne seront peut être pas bien codé.

Merci beaucoup de soulever ce point, je n'y avais pas penser ^^'. ET c'est bien plus logique en effet !

[invite6486d7bd]

Je suis bel et bien en 64 pixels et en 40/16 mais j'ai enregistré la carte en 50%. Ce qui m'as tous divisé. Donc je dois plus voir mes tuiles comme du 32 du coup ?

Ca dépend ce que vous comptez faire.
Actuellement, vous affichez l'ensemble du "niveau" constitué d'une plateforme sur tout l'écran.
Vous devez dans ce cas de figure réduire la taille de la plateforme (c'est du boulot).
L'avatar sera petit, et le style du jeu sera médiocre (on revient à un type d'affichage que l'on retrouve chez les premiers jeux de plateforme).
Désavantage (ou pas, mais comme dit, vous devez préciser le but du jeu, pour l'instant le jeu n'a pas d'âme) : Le joueur peut visualiser l'ensemble de la plateforme, ce qui démystifie l'environnement (ennui assuré pour le joueur).
Autre désavantage : La petitesse de l'avatar et du décor diminue la jouabilité (difficile d'être précis dans ces conditions).

Ce que vous pourriez faire en revanche (c'est plus technique, mais c'est à vous de voir), c'est de garder le codage de la plateforme tel quel, mais changer le style d'affichage.
Au lieu d'afficher l'ensemble de la plateforme en une fois, vous pourriez n'afficher que la portion qui se trouve autour de l'avatar.
L'avatar serait fixe, placé au centre de l'écran et c'est le décor autour de lui qui bouge (comme dans les jeux de plateforme modernes).

Dans ce cas, vous devez au contraire prévoir un agrandissement des images des blocs et de l'avatar (a noter qu'il y a plus de de travail de graphisme).

A vous de voir.

Alors les sauts sont bien prévue (on avait des échelles aussi mais au final on ne pense pas les utiliser, à voir) mais tout simplement pas codé.

Au boulot alors.
Quelques pistes :
Pour sauter, il faut que l'avatar soit posé.
Vous devez définir si l'avatar peut modifier sa position pendant le saut ou la chute, et actuellement votre code ne bloque pas le déplacement lors d'une chute.

Vous devriez à minima renommer ordPerso et absPerso, par exemple en PersoX et PersoY (C'est plus lisible, surtout pour un non francophone).
Le mieux, pour simplifier le code, serait d'employer un type dédié plutôt que d'employer deux variables.
Une Possibilité serait d'employer le type PVector, qui peut aussi s'employer avec uniquement x et y.
https://processing.org/reference/PVector.html

Par exemple :

JoueurPos = new PVector(40, 10);

Il vous faut une vitesse en X et en Y pour gérer le saut, mais actuellement vous avez appelé la vitesse de chute Speed et vous n'avez pas nommé la vitesse de translation en X (c'est +5 ou -5 pixels dans votre programme).
C'est peu lisible, et ça ne va pas arranger votre affaire, puisqu'il va falloir additionner la vitesse et la position.

Une meilleure façon de procéder serait de définir le vecteur vitesse en 2D (qui comprend donc la vitesse en x et en y):

JoueurVit = new PVector(0, 0);

Si vous appuyez sur la touche droite, vous mettez la composante x de JoueurVit à 5 (ou 4 ou 1 ou vous incrémentez, c'est comme vous voulez, etc).
Si vous relâchez la touche, vous mettez la composante x de JoueurVit à 0, l'avatar s’arrête net.

Si vous appuyez sur la touche saut et que la variable boolean Pose (que vous devez définir) est à true , vous mettez la variable boolean Pose à false, et vous mettez la valeur y de JoueurVit à la vitesse de saut (par exemple 4).
De la même manière vous décrémentez à chaque tour la valeur y de JoueurVit de la valeur de gravité (par exemple -1), si l'avatar n'est pas posé.
Tant qu'il n'est pas posé, on rajoute simplement la valeur de la gravité (négative) à JoueurVit, ça simule l'augmentation de la vitesse de chute de manière réaliste.

Ensuite, à chaque tour, vous additionnez JoueurVit à JoueurPos et vous testez les dépassements ou et collisions (il faut également vérifier si l'avater est posé et définir la vitesse maximum qu'il supporte au moment de l'impact, et si l'avatar traverse un bloc, ce qu'il ne devrait pas)
Le cas échéant, il perd 1 point de vie, recommence au début, en faisant une pause ou pas etc, à vous de définir ce que vous voulez faire.

Je vous laisse déjà réfléchir à tout ça.

[A voir en vidéo sur Futura]

[invite6486d7bd]

D'autre part, il aurait été plus judicieux de prévoir une autre structure pour la plateforme (il vaut mieux le faire dès maintenant).
Vous avez codé la plateforme sous la forme d'un tableau à 1 dimension, alors que votre écran a 2 dimensions.
Jetez un oeil ici : https://processing.org/tutorials/2darray/

[invited8db657c]

Alors nous avons (grâce à notre prof) réussit à faire fonctionner nos plateformes.
En effet nous n'avions pas la méthode la plus simple, et même si j'avais l'idée de comment faire nous n'arrivions pas à l'appliquer.
Voici donc le code de la plateforme :

  for (int i=0; i<plateforme.length; i++) {
    ligne = i/40; //division euclidienne entière, donne le numéro de ligne
    colonne = i%40; //reste de la division euclidienne entière, donne le numéro de colonne
    //  println(ligne, colonne);

    ligneP = int(absPerso /32);// Nombre de tuiles en abs
    colonneP = int(ordPerso/32)+1;// Nombre de tuiles en ord + 1 <= 1 tuile pour la taille du personnage

    if (colonneP*40+ligneP<640 && plateforme[(colonneP)*40+ligneP]==0) { // On teste si sous les pieds du personnage il y a du vide
      ordPerso +=10;

      break;
    }
  }

Et donc le fameux saut du personnage (il ne saute que à droite par contre ...) que je vais tenter de modifier avec vos pistes

if (keyCode == UP) {
      ordPerso = ordPerso-30;
      absPerso = absPerso+8;
    }

Pour ce qui est de la taille de la fenêtre, je la trouve correct sans pour autant "piquer" les yeux. Mais en même temps quand on passe du temps devant quelque chose on finit par ne plus en voir les défauts ...

(EDIT : L'image rend plus petite ici, mais en "vrai" elle n'est aucunement flou ou sur-pixelisé)

POur le but, "jeu sans âme". Je dois avouer ne pas comprendre. Mais après je n'ai pas donné toutes les infos.
Notre jeu a une histoire (et une alternance Quizz/Plateforme) et sur la plateforme il doit allez d'un point A à un point B.

Merci encore