Tetris3D [Unreal Engine 4]

**guitz** · 14/09/2016, 20h16

Bonjour,

Mon premier projet sur l'Unreal Engine 4 : un Tetris 3D que je vais essayer de rendre original dans les graphismes et certains détails d'animations.

Je ferai les graphismes en tout dernier.

J'ai spawned assez de cubes (Cube.cpp) dans CubesManager.cpp, et pour la gestion des events , j'ai TetrisPlayerController.cpp.

Je parviens à déplacer horizontalement la forme, la roter, et gerer les collisions avec les murs.

Pour le mouvement de descente je pense utiliser 2 matrices A (les formes amboitées sur le sol), B (la forme en mouvement) dont chaque élément vaut 1 s'il est occupé par un cube et 0 sinon. Avant de valider un déplacement je fais A+B et si aucun élement ne vaut 2, alors je valide. C'est plus simple que ce que je ne pensais avant de commencer le projet.

J'en ai un peu bavé pour prendre en main les bases de l'unreal engine 4 (c++ et blueprint) , mais c'est maintenant que ça commence à devenir sympa

**yahiko** · 14/09/2016, 20h31

C'est prometteur je trouve. Difficile de commenter plus en détail pour le moment, mais disons qu'on devine bien qu'il va s'agir d'un Tetris.

Bon courage

**guitz** · 14/09/2016, 20h33

Merci

**dragonjoker59** · 14/09/2016, 20h52

Salut!

C'est donc l'affichage uniquement qui est en 3D, ou tu envisages des règles en 3D ? (je ne sais pas lesquelles, le seul exemple me venant à l'esprit est Tetrisphere, sur N64, si je me souviens bien.)

**guitz** · 14/09/2016, 21h03

Excellent Tetrisphere je connaissais pas.

Non pour le moment je vais rester sur un gameplay tetris classique sur ce projet. Pour un 2nd projet éventuellement pourquoi pas essayer de trouver un gameplay différent en utilisant la 3D.

**guitz** · 15/09/2016, 00h02

Bonsoir,

Je suis entrain de créer une de mes matrices: celles des cubes emboités sur le sol.

Je veux donc créer un TArray 2D dynamique donc chaque élément contiendrai une struct qui elle contient 2 tableaux 1D (pointeurs sur cube pawn, et IsACube qui vaut 0 ou 1).
La déclaration dans CubesManager.h m'a l'air correcte, en tout cas le compilateur n'a pas l'air de s'en plaindre.

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
#include "Cube.h"
#include "GameFramework/Pawn.h"
#include "CubesManager.generated.h"
 
struct CubeStruct
{
	TArray<ACube*> Cube;
	TArray<int32> IsACube;
};
 
UCLASS()
class TETRIS6_API ACubesManager : public APawn
{
	GENERATED_BODY()
 
public:
 
        ...
 
	//2D TArray of the static cubes positions and their Cube pointers
	TArray<CubeStruct> StaticCubesMatrix;
 
};

Mais dans CubesManager.cpp, dans le constructeur, je ne vois pas trop comment implémenter mon 2D TArray :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "Tetris6.h"
#include "CubesManager.h"
 
 
ACubesManager::ACubesManager()
{
	...
 
	for (int32 i = 1; i <= NumCubesPerRow; i++) {
		for (int32 j = 1; j <= NumCubesPerColumn; j++) {
 
		}
	}
}

J'ai fait quelques essais sans succès, vous voyez comment svp ?

**LittleWhite** · 15/09/2016, 09h25

Bonjour,

Je ne connais pas le C++ à la UE4. J'aurais fait un std::array, en C++. Suivant la documentation de TArray, vous pouvez faire des Add().

Sinon, pourquoi il y a une pile verticale de cube au dessus du terrain de jeu ?

**guitz** · 15/09/2016, 11h05

Bonjour,

Ce sont tous les cubes qui vont servir au Tetris, j'aurai pu les mettre n'importe où sur la scène en fait du moment qu'ils sont hors caméra

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
 
#include "Cube.h"
#include "GameFramework/Pawn.h"
#include "CubesManager.generated.h"
 
struct CubeStruct
{
	TArray<ACube*> Cube;
//array de type pointeur sur cube
	TArray<int32> IsACube;
//array de type int32
 
};
 
UCLASS()
class TETRIS6_API ACubesManager : public APawn
{
	GENERATED_BODY()
 
public:
 
        ...
 
	//2D TArray of the static cubes positions and their Cube pointers
	TArray<CubeStruct> StaticCubesMatrix;
//Array de type CubeStruct
 
};

Little white vous l'implémenteriez compment vous en c++ pure ? Ensuite je l'adapte en c++ UE4. Merci

**dragonjoker59** · 15/09/2016, 11h23

Salut!

Ton tableau 2D représente donc la grille de ton Tetris?
Du coup, je ne comprends pas pourquoi chaque case a un tableau de cube.
Là, il me semble y avoir un gros mélange de l'affichage et de la logique du jeu.

Pour moi, la grille du Tetris contient de simples booléens, pour dire vide ou pleine.
Ensuite la logique d'affichage va s'occuper pour chaque case pleine d'y afficher un cube.

**guitz** · 15/09/2016, 11h27

Il me faut aussi les pointeurs de chaque cubes dans la matrice (dont chaque élément est un couple ) car comme ça juste après qu'une nouvelle forme soit emboitée aux autres j'appelle une fonction qui boucle sur chaque ligne de la matrice et si tous les IsACube valent 1 je supprime tous les cubes de la ligne et fait chuter ceux du dessus.

**dragonjoker59** · 15/09/2016, 11h41

Ben non, si tu découples la logique de jeu de la logique d'affichage, tu n'as rien à faire au niveau des cubes.
Ta boucle d'affichage va juste parcourir la grille et afficher un cube où il faut, c'est tout.

**guitz** · 15/09/2016, 11h53

Même si chaque forme (4 cubes) a sa propre couleur ?

**dragonjoker59** · 15/09/2016, 11h58

Dans ma grille, j'ai parlé de booléens, mais on peut mettre des entiers, représentant le code couleur du cube.
Ou tu peux faire 2 choses: la grille, qui contient des cellules, chaque cellule étant un entier prenant 3 valeurs (vide, cube, forme), et les formes qui elles peuvent avoir une couleur, une position et une orientation (qui permettront de déterminer quels cellules de la grille elle occupe), ...
Du coup la boucle de rendu dessine d'abord les formes, puis les cellules de type cube de la grille, te permettant donc d'avoir un rendu spécialisé pour les formes, et un rendu basique pour les cubes "statiques" de la grille.

**guitz** · 15/09/2016, 13h03

Si ta matrice ne stocke que ces 3 données par élément, alors comment savoir quel Cube enlever quand une ligne est pleine de cubes ? N'est ce pas plus simple de stocker que ces 2 données (IsACube (cube présent à cet endroit ou non) et ACube* (pointeur sur cube)) ?

**dragonjoker59** · 15/09/2016, 13h25

Lorsque tu valides une ligne tu fais un simple déplacement des cellules de ta grille (tu descends les cellules au-dessus de la ligne de 1 ligne).
Aucun cube n'intervient, là...

Encore une fois, je ne peux que te conseiller de séparer la logique du jeu et la logique d'affichage, là tu pars dans des réflexions complexes alors qu'il n'y a pas lieu.

**guitz** · 15/09/2016, 13h35

Merci du conseil.

Pour ma matrice, je n'utilise plus TArray, mais un tableau 2D statique en c++ pure et ça marche, et chaque élément de la matrice est une struct. J'ai pas été très malin au début de vouloir que ma struct contienne 2 tableaux 1D

A bientôt pour une prochaine mise à jour

**guitz** · 17/09/2016, 01h05

Bonjour,

Désormais toutes les collisions sont prises en compte

Il y a un bug d'éclairage que je règlerai plus tard.

Il ne reste plus qu'à :

- faire un appel aléatoire d'une forme à chaque fois que SpawnCurrentShape(CurrentShape) est appellé , à définir un interval de temps dans

Code :

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

1
2
3
4
5
void ACubesManager::Tick(float DeltaTime)
{
	...
 
}

pour la chute d'un interval d'un cube pour chaque forme. (interval de temps qui va diminuer à mesure que le niveau augmente)
- Animer la disparition de chaque ligne de cubes, et la descente du bloc du dessus
- ajouter une UI avec score, niveau etc...

Ca c'est pour ressembler au tetris classique, après je compte rajouter ma touche perso.

**divxdede** · 17/09/2016, 10h42

Bonjour,

Attention, il y a quelques régles concernant un jeu Tetris pour:

Choisir une pièce au hazard : Ce n'est pas un pur hazard. Dans les faits c'est un technique de "Bag". C'est comme si tu mettais toutes les pièces possibles dans un sac et tu pioches au hazard dedans. Une fois le sac vide, tu recommences.
Ce qui fait que tu ne peux jamais avoir plus de 2 fois de suite la même pièce (derniere d'un bag, première du bag suivant).
Cette mécanique n’empêche pas pour autant de tirer à l'avance les pièces pour montrer au joueur la prochaine pièce.

Concernant les rotations de pièces. La "norme" de Tetris est d'utiliser le SRS (Super Rotation System) dont tu peux trouver une documentation ici : https://tetris.wiki/SRS
La difficulté du SRS est notamment la gestion du "lock delay". Tant que tu arrives à bouger (tourner/déplacement gauche-droite) une pièce suffisamment vite, elle ne se bloque pas.

Ensuite il y a le scoring, il est recommandé de detecter certaines séquences comme le T-Spin qui donne plus de points au joueur.

En règle général, je te conseil de lire le Tetris Guideline qui décrit les règles (obligatoires et facultatives) : https://tetris.wiki/Tetris_Guideline

Bonne continuation à toi, mais même sur un jeu simple comme Tetris, il y a du boulot.

**guitz** · 17/09/2016, 12h05

Merci

**LittleWhite** · 17/09/2016, 12h34

Certes, penser aux règles officielles c'est cool. Mais je pense qu'avant de les intégrer, il faut avoir une base qui marche pleinement.
De plus, les règles officielles Tetris© ne sont pas les seules existantes. Une autre version que j'aime (encore plus que celle du Tetris©) c'est la version The GrandMaster (le jeu d'arcade, que l'on peut voir speedrunner). Mais bon, c'est mon avis de joueur

Tetris3D [Unreal Engine 4]

Projets

Discussions similaires

Partager

Partager