IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Projets Discussion :

Tetris3D [Unreal Engine 4]


Sujet :

Projets

  1. #21
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Bonjour,

    Oui en effet avant de rajouter beaucoup de code, il faut avoir une base seine. Et sinon Comme je l'ai dit, je compte rester sur un Tetris classique avant que des idées de gameplay original me viennent.

    Tâche du jour:
    Là je suis entrain de regarder DELEGATE en c++ pour pouvoir faire un custom blueprint event qui puisse être appelé depuis le c++ et pouvoir rajouter une timeline node dans Cube blueprint pour gérer la courbe de vitesse de chaque cube déplacé plutôt qu'un déplacement téléporté (comme dans la gameboy 1991) de la hauteur d'un cube + l'espace intercube.
    La grosse difficulté dans UE4 c'est de naviguer à sa guise entre c++ et blueprint (Car le blueprint hérite de sa classe c++ parente)

    L'intéret de naviguer de c++ à blueprint et vice versa c'est que le c++ permet une immense flexibilité, et comme tu l'as dit LittleWhite, est plus propice à l'optimisation. Mais les blueprint permettent dans certains cas de faire en 2 clics des trucs qui prendraient 15 lignes de code en c++ (en se tapant au passage la doc d'Epic)

  2. #22
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Bonjour à tous,

    Bon bin ça avance bien, niveau code il reste plus qu'à :

    - améliorer l'algo de random pour les pièces, comme on me l'a conseillé
    - faire l'UI
    - le fait que la prochaine piece soit montrée à l'utilisateur
    - pourquoi pas un mouvement de caméra sympa quand on fait 4 lignes d'un coup
    - pourquoi pas un effet de particule quand la pièce touche le sol




    La je bascule sur les graphismes, je reviendrai sur le code plus tard. Je modélise un genre de Kremlin au tour de la zone de jeu

    Concernant mon code, vous voyez des trucs à améliorer ?

    Je sais qu'il vaut mieux que je crée une classe Matrix à part mais c'est un petit projet et j'ai la flemme, en dehors de ça ya rien de choquant ?

    TetrisPlayerController.h

    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
    // Fill out your copyright notice in the Description page of Project Settings.
     
    #pragma once
     
    #include "GameFramework/PlayerController.h"
    #include "TetrisPlayerController.generated.h"
     
     
    UCLASS()
    class TETRIS6_API ATetrisPlayerController : public APlayerController
    {
    	GENERATED_BODY()
     
    		//ACubesManager* GetControlledPawn() const;
     
    		virtual void BeginPlay() override;
    	virtual void Tick(float DeltaSeconds) override;
     
    public:
     
     
    	ACubesManager* CubesManager = nullptr;
     
    	UFUNCTION(BlueprintCallable, Category = "Inputs")
    		void MoveRight();
    	UFUNCTION(BlueprintCallable, Category = "Inputs")
    		void MoveLeft();
    	UFUNCTION(BlueprintCallable, Category = "Inputs")
    		void SpinCubes();
    	UFUNCTION(BlueprintCallable, Category = "Inputs")
    		void RotateRight();
    	UFUNCTION(BlueprintCallable, Category = "Inputs")
    		void RotateLeft();
     
     
    };

    TetrisPlayerController.cpp

    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
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    // Fill out your copyright notice in the Description page of Project Settings.
     
    #include "Tetris6.h"
    #include "Cube.h"
    #include "CubesManager.h"
    #include "TetrisPlayerController.h"
     
     
    void ATetrisPlayerController::BeginPlay() {
     
    	Super::BeginPlay();
     
    	//UE_LOG(LogTemp, Warning, TEXT("%s"), *CubesManager->GetName());
     
    	for (TActorIterator<ACubesManager> Itr(GetWorld(), ACubesManager::StaticClass()); Itr; ++Itr)
    	{
    		if (Itr->IsA(ACubesManager::StaticClass()))
    		{
    			CubesManager = *Itr;
     
    			if (!CubesManager) { return; }
    		}
    		else
    		{
    			continue;
    		}
    	}
     
    }
     
     
    // Called every frame
    void ATetrisPlayerController::Tick(float DeltaTime)
    {
    	Super::Tick(DeltaTime);
     
    	if (!CubesManager) { return; }
    }
     
    void ATetrisPlayerController::RotateRight() {
    	if (CubesManager->CurrentShape != 1 && CubesManager->CubesCanBeMoved) {
    		CubesManager->RotateCubes(-CubesManager->Angle);
    	}
    }
     
    void ATetrisPlayerController::RotateLeft() {
    	if (CubesManager->CurrentShape != 1 && CubesManager->CubesCanBeMoved) {
    		CubesManager->RotateCubes(CubesManager->Angle);
    	}
    }
     
    void ATetrisPlayerController::MoveRight() {
     
    	if (!CubesManager->CubesCurrentShapeArray[3] || !CubesManager->CubesCanBeMoved) { return; }
    	CubesManager->MoveCubes(Direction::RIGHT);
     
    }
     
    void ATetrisPlayerController::MoveLeft() {
     
    	if (!CubesManager->CubesCurrentShapeArray[3] || !CubesManager->CubesCanBeMoved) { return; }
    	CubesManager->MoveCubes(Direction::LEFT);
     
    }
     
    void ATetrisPlayerController::SpinCubes() { // Fait rapidement descendre les cubes
     
    	if (!CubesManager->CubesCanBeMoved) { return; }
     
    	CubesManager->SpinSteps = 0;
    	CubesManager->CubesCanBeMoved = false;
     
     
    	for (int32 i = 0; i <= 3; i++) {
    		CubesManager->CubesCurrentShapeArray[i]->MovementZTick = 1;
    		CubesManager->CubesCurrentShapeArray[i]->InitZ = CubesManager->CubesCurrentShapeArray[i]->GetActorLocation().Z;
    		CubesManager->CubesCurrentShapeArrayTest[i].Cube = CubesManager->CubesCurrentShapeArray[i];
    		CubesManager->CubesCurrentShapeArrayTest[i].y = CubesManager->CubesCurrentShapeArrayTest[i].Cube->GetActorLocation().Y;
    		CubesManager->CubesCurrentShapeArrayTest[i].z = CubesManager->CubesCurrentShapeArrayTest[i].Cube->GetActorLocation().Z - (CubesManager->SpinSteps + 1) * (CubesManager->CubeWidth + CubesManager->SpaceInterCubes);
    	}
     
    	while (!CubesManager->ShapeCollidesWithMatrix(CubesManager->CubesCurrentShapeArrayTest)){
     
    		CubesManager->SpinSteps++;
     
    		for (int32 i = 0; i <= 3; i++) {
    			CubesManager->CubesCurrentShapeArrayTest[i].z = CubesManager->CubesCurrentShapeArrayTest[i].Cube->GetActorLocation().Z - (CubesManager->SpinSteps + 1) * (CubesManager->CubeWidth + CubesManager->SpaceInterCubes);
    		}
     
     
    	}
     
    	if (CubesManager->SpinSteps > 0) {
     
    		GetWorld()->GetTimerManager().ClearTimer(CubesManager->MovingDownCubesHandle);
    		CubesManager->SetSpinningCubesTimer();
     
    	}
     
    }

    Cube.h

    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
    // Fill out your copyright notice in the Description page of Project Settings.
     
    #pragma once
     
    #include "GameFramework/Pawn.h"
    #include "EasePenner.h"
    #include "Cube.generated.h"
     
    UENUM(BlueprintType)
    enum class Direction : uint8
    {
    	LEFT 	UMETA(DisplayName = "LEFT"),
    	RIGHT	UMETA(DisplayName = "RIGHT"),
    	DOWN	UMETA(DisplayName = "DOWN"),
    	NONE	UMETA(DisplayName = "NONE")
    };
     
    UENUM(BlueprintType)
    enum class SensRotation : uint8
    {
    	LEFT 	UMETA(DisplayName = "LEFT"),
    	RIGHT	UMETA(DisplayName = "RIGHT"),
    	NONE	UMETA(DisplayName = "NONE")
    };
     
    //DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnMoveCubesBackRequest);
     
    UCLASS()
    class TETRIS6_API ACube : public APawn
    {
    	GENERATED_BODY()
     
     
    public:
    	// Sets default values for this pawn's properties
     
    	ACube();
     
    	//ACube() : EasePennerObject();
     
    	// Called when the game starts or when spawned
    	virtual void BeginPlay() override;
     
    	// Called every frame
    	virtual void Tick(float DeltaSeconds) override;
     
    	// Called to bind functionality to input
    	virtual void SetupPlayerInputComponent(class UInputComponent* InputComponent) override;
     
    	void MoveBack();
     
    	UPROPERTY(BlueprintReadWrite, Category = "Movement")
    		Direction Dir;
     
    	UPROPERTY(BlueprintReadWrite, Category = "Material")
    		bool ReadyToSetMaterialColor;
     
    	UPROPERTY(BlueprintReadWrite, Category = "Material")
    		FLinearColor  MaterialColor;
     
    	int32 NumRowsToCollapse;
    	float InitX, InitY, InitZ, DeltaTime_;
     
    	int32 MovementXTick, MovementZTick;
    	EasePenner* EasePennerObject;
     
    };
    Cube.cpp

    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
    // Fill out your copyright notice in the Description page of Project Settings.
     
    #include "Tetris6.h"
    #include "Cube.h"
     
     
     
    // Sets default values
    ACube::ACube()
    {
    	// Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    	PrimaryActorTick.bCanEverTick = false;
     
    	ReadyToSetMaterialColor = false;
    	MaterialColor = FLinearColor(0.0f, 0.0f, 0.0f, 1.f);
    	NumRowsToCollapse = 0;
     
    	MovementZTick = 1;
    	DeltaTime_ = 0.016666666; // Si on souhaite 40 fps
     
    	EasePennerObject = new EasePenner();
     
    }
     
    // Called when the game starts or when spawned
    void ACube::BeginPlay()
    {
    	Super::BeginPlay();
     
    }
     
    // Called every frame
    void ACube::Tick(float DeltaTime)
    {
    	Super::Tick(DeltaTime);
     
    }
     
    // Called to bind functionality to input
    void ACube::SetupPlayerInputComponent(class UInputComponent* InputComponent)
    {
    	Super::SetupPlayerInputComponent(InputComponent);
     
    }
    CubesManager.h

    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
    // Fill out your copyright notice in the Description page of Project Settings.
     
    #pragma once
     
     
    #include "GameFramework/Pawn.h"
    #include "CubesManager.generated.h"
     
     
    //TODO intégrer à la classe ACube
    struct CubeStruct
    {
    	ACube* Cube;
    	bool IsACube;
    	float y;
    	float z;
    	int32 YMat;
    	int32 ZMat;
    };
     
    UCLASS()
    class TETRIS6_API ACubesManager : public APawn
    {
    	GENERATED_BODY()
     
    public:
    	// Sets default values for this pawn's properties
    	ACubesManager();
     
    	// Called when the game starts or when spawned
    	virtual void BeginPlay() override;
     
    	// Called every frame
    	virtual void Tick(float DeltaSeconds) override;
     
    	void SpawnCurrentShape(int32 CurrentShape);
    	void MoveCubes(Direction Dir);
    	void MoveCubesDown(); //Utile pour le SetTimer pour l'interval de temps entre chaque pas vertical de chute des cubes
    	void RotateCubes(float Angle);
     
    	bool ShapeCollidesWithMatrix(CubeStruct ShapeArr[]);
    	bool UpdateMatrix(CubeStruct ShapeArr[]);
    	void EaseCollapseCubesRows();
    	void EaseRemoveCubesRows();
    	bool CollapseMatrix(int32 RowToClearStartIndex, bool RowsIndexesToClear[]);
    	bool ClearMatrixRows();
     
    	void SpinCubes();
    	void SetMovingDownCubesTimer(float DeltaTime);
    	void SetSpinningCubesTimer();
     
    	//virtual void SetupPlayerInputComponent(class UInputComponent * InInputComponent) override;
     
    	UPROPERTY(EditDefaultsOnly, Category = "Our Spawning object")
    		TSubclassOf<ACube> SpawningObject;
     
    	bool CubesHaveSpawned, CubesCanBeMoved;
    	int32 CollapseCubesRowsDuration, GlobalTick, Delay, SpinSteps;
    	int32 CubeWidth, CurrentShape, NumCubesPerRow, NumCubesPerColumn, NumCubes, TopCubeIndex, Score, level;
    	float SpaceInterCubes, pi, RightBoundary, LeftBoundary, TopBoundary, MaxDeltaTimeMoveCubesDown, MinDeltaTimeMoveCubesDown;
    	float DeltaTime, Angle; //used to rotate tetris shape
     
    	FTimerHandle MovingDownCubesHandle; //handles the delay beetween one step Z-axis moving Cubes
    	FTimerHandle CollapseCubesRowsHandle, RemoveCubesRowsHandle, SpinCubesHandle;
     
    	TArray<ACube*> CubesArray;
    	TArray<ACube*> CubesCurrentShapeArray;
    	TArray<ACube*> CubesToCollapseArray;
    	TArray<ACube*> CubesToRemoveArray;
    	CubeStruct CubesCurrentShapeArrayTest[4]; //utile pour des tests collision entre autres
     
    											  //TODO hard code à changer avec include de constantes
    											  //TODO rendre les tableaux dynamiques statiques
    											  //TODO utiliser soi uniquement les TArray ou les array(c++ native)
    	CubeStruct CubesMatrix[12][21]; // Cubes emboités et immobiles posés au sol
     
    	EasePenner* EasePennerObject;
     
    };
    CubesManager.cpp

    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
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    495
    496
    497
    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    508
    509
    510
    511
    512
    513
    514
    515
    516
    517
    518
    519
    520
    521
    522
    523
    524
    525
    526
    527
    528
    529
    530
    531
    532
    533
    534
    535
    536
    537
    538
    539
    540
    541
    542
    543
    544
    545
    546
    547
    548
    549
    550
    551
    552
    553
    554
    555
    556
    557
    558
    559
    560
    561
    // Fill out your copyright notice in the Description page of Project Settings.
     
    #include "Tetris6.h"
    #include "Cube.h"
    #include "CubesManager.h"
    #include <vector>
     
     
    ACubesManager::ACubesManager()
    {
    	PrimaryActorTick.bCanEverTick = true;
     
    	CubesHaveSpawned = false;
    	CubesCanBeMoved = true;
    	SpaceInterCubes = 2;
    	CubeWidth = 100;
    	NumCubesPerRow = 10;
    	NumCubesPerColumn = 20;
    	RightBoundary = float((NumCubesPerRow + 3) + float(CubeWidth * (NumCubesPerRow + 2))) / 2;
    	LeftBoundary = -RightBoundary;
    	TopBoundary = (NumCubesPerColumn + 1) * SpaceInterCubes + NumCubesPerColumn * CubeWidth;
     
    	NumCubes = NumCubesPerRow * NumCubesPerColumn;
    	TopCubeIndex = 0; //index du cube le plus haut dans la matrice
    	Score = 0;
    	level = 1;
     
    	MinDeltaTimeMoveCubesDown = 0.05;
    	MaxDeltaTimeMoveCubesDown = 0.6;
    	GlobalTick = 1;
    	CollapseCubesRowsDuration = 40; //40 fois DeltaTime donc une durée de 1 seconde
    	Delay = 3;
    	DeltaTime = 0.016666666; //pour des SetTimer() d'animation à 40fps
     
    	CurrentShape = 7;
    	Angle = 90;
    	pi = 3.141592;
     
    	EasePennerObject = new EasePenner();
     
    	for (int32 i = 0; i < NumCubesPerRow + 2; i++) { // pour les collisions sur les bords de la grille on fait comme si ils contenaient un cube
    		for (int32 j = 0; j < NumCubesPerColumn + 1; j++) {
    			CubesMatrix[i][j].Cube = nullptr;
     
    			if (i == 0 || i == NumCubesPerRow + 1 || j == 0) {
    				CubesMatrix[i][j].IsACube = true;
    			}
    			else {
    				CubesMatrix[i][j].IsACube = false;
    			}
    		}
    	}
     
    }
     
     
    // Called when the game starts or when spawned
    void ACubesManager::BeginPlay()
    {
    	Super::BeginPlay();
     
    	for (int32 i = 0; i < NumCubes; i++) {
    		CubesArray.Add(GetWorld()->SpawnActor<ACube>(SpawningObject, FVector(0.f, 0.f, float(3000 + i * 200)), FRotator::ZeroRotator));
    		if (!CubesArray[i]) { return; }
    	}
    	CubesHaveSpawned = CubesArray.Num() == NumCubesPerRow * NumCubesPerColumn;
     
    }
     
    // Called every frame
    void ACubesManager::Tick(float DeltaTime)
    {
    	Super::Tick(DeltaTime);
     
    	if (CubesHaveSpawned) {
    		SpawnCurrentShape(CurrentShape);
    		SetMovingDownCubesTimer(MaxDeltaTimeMoveCubesDown);
    		CubesHaveSpawned = false;
    	}
     
    }
     
    void ACubesManager::SetMovingDownCubesTimer(float DeltaTime) {
    	GetWorld()->GetTimerManager().SetTimer(MovingDownCubesHandle, this, &ACubesManager::MoveCubesDown, DeltaTime, true);
    }
     
    void ACubesManager::SetSpinningCubesTimer() {
    	CubesCanBeMoved = false;
    	GetWorld()->GetTimerManager().SetTimer(SpinCubesHandle, this, &ACubesManager::SpinCubes, DeltaTime, true);
    }
     
    void ACubesManager::MoveCubesDown() {
    	MoveCubes(Direction::DOWN);
    }
     
     
    void ACubesManager::RotateCubes(float Angle) {
     
    	float PivotPointY = CubesCurrentShapeArray[0]->GetActorLocation().Y;
    	float PivotPointZ = CubesCurrentShapeArray[0]->GetActorLocation().Z;
    	float y, z, s, c, NewY, NewZ;
    	float AngleRadians = Angle * pi / float(180);
    	FRotator ActorRotation;
     
    	TArray<float> newY_arr, newZ_arr;
    	TArray<FRotator> rotation;
     
    	CubeStruct current_shape_arr[4];
     
    	//UE_LOG(LogTemp, Warning, TEXT("%f"), CubesCurrentShapeArray[1]->GetActorRotation().Pitch);
     
    	for (int32 i = 0; i < 4; i++) {
     
    		s = FMath::Sin(AngleRadians);
    		c = FMath::Cos(AngleRadians);
    		y = CubesCurrentShapeArray[i]->GetActorLocation().Y;
    		z = CubesCurrentShapeArray[i]->GetActorLocation().Z;
    		// translate point back to origin:
    		y -= PivotPointY;
    		z -= PivotPointZ;
    		// translate point back:
    		NewY = y * c - z * s + PivotPointY;
    		NewZ = y * s + z * c + PivotPointZ;
     
    		ActorRotation = CubesCurrentShapeArray[i]->GetActorRotation();
    		ActorRotation.Yaw += Angle;
    		newY_arr.Add(NewY); newZ_arr.Add(NewZ); rotation.Add(ActorRotation);
     
    	}
     
     
    	for (int32 i = 0; i < 4; i++) {
     
    		current_shape_arr[i].Cube = CubesCurrentShapeArray[i];
    		current_shape_arr[i].y = newY_arr[i];
    		current_shape_arr[i].z = newZ_arr[i];
    	}
     
    	if (!ShapeCollidesWithMatrix(current_shape_arr)) {
    		for (int32 i = 0; i < 4; i++) {
    			CubesCurrentShapeArray[i]->SetActorLocation(FVector(-482.f, newY_arr[i], newZ_arr[i]));
    			//Array[i]->SetActorRotation(rotation[i]);
    		}
    	}
     
    }
     
     
    void ACubesManager::MoveCubes(Direction Dir) {
     
    	int32 right_boundary, left_boundary, factor_y = 0, factor_z = 0;
    	CubeStruct cube_movement[4]; //va stocker step movement en y et z
     
    	right_boundary = RightBoundary - CubeWidth / 4;
    	left_boundary = LeftBoundary + CubeWidth / 4;
     
    	switch (Dir) //TODO utiliser ENUM
    	{
    	case Direction::LEFT:
    		factor_y = -1;
    		factor_z = 0;
    		break;
    	case Direction::RIGHT:
    		factor_y = 1;
    		factor_z = 0;
    		break;
    	case Direction::DOWN:
    		factor_y = 0;
    		factor_z = -1;
    		break;
    	}
     
     
    	for (int32 i = 0; i <= 3; i++) {
    		CubesCurrentShapeArrayTest[i].Cube = CubesCurrentShapeArray[i];
    		cube_movement[i].y = factor_y * (CubeWidth + SpaceInterCubes);
    		cube_movement[i].z = factor_z * (CubeWidth + SpaceInterCubes);
    		CubesCurrentShapeArrayTest[i].y = CubesCurrentShapeArrayTest[i].Cube->GetActorLocation().Y + factor_y * (CubeWidth + SpaceInterCubes);
    		CubesCurrentShapeArrayTest[i].z = CubesCurrentShapeArrayTest[i].Cube->GetActorLocation().Z + factor_z * (CubeWidth + SpaceInterCubes);
    	}
     
    	if (!ShapeCollidesWithMatrix(CubesCurrentShapeArrayTest)) { // si non collision
    		for (int32 i = 0; i <= 3; i++) {
    			CubesCurrentShapeArray[i]->SetActorLocation(CubesCurrentShapeArray[i]->GetActorLocation() + FVector(0.f, cube_movement[i].y, cube_movement[i].z));
    			//CubesCurrentShapeArray[i]->Move(Dir);
    		}
    	}
    	else { // si collision
    		if (Dir == Direction::DOWN) { // Si une forme est posée au sol
     
     
    			if (UpdateMatrix(CubesCurrentShapeArrayTest)) {
     
    				ClearMatrixRows();
     
    			}
     
    		}
    	}
     
    }
     
     
    bool ACubesManager::UpdateMatrix(CubeStruct ShapeArr[]) { // intégre les 4 nouveaux cubes dans la matrices après collision au sol
     
     
    	int32 top_cube_index = TopCubeIndex;
     
    	for (int32 k = 0; k < 4; k++) {
    		CubesMatrix[ShapeArr[k].YMat][ShapeArr[k].ZMat].IsACube = true;
    		CubesMatrix[ShapeArr[k].YMat][ShapeArr[k].ZMat].Cube = ShapeArr[k].Cube;
     
    		if (ShapeArr[k].ZMat > top_cube_index) { //on detecte la position Z du cube la plus grande
    			top_cube_index = ShapeArr[k].ZMat;
    		}
    	}
     
    	TopCubeIndex = top_cube_index;
     
    	//UE_LOG(LogTemp, Warning, TEXT("top cube index : %d"), TopCubeIndex);
     
    	return true;
    }
     
    void ACubesManager::SpinCubes() { //TODO faire aussi une rotation de 360 degrés autour axe Z du shape
     
    	FVector actor_location;
    	FRotator actor_rotator;
     
    	for (int32 i = 0; i <= 3; i++) {
     
    		if (CubesCurrentShapeArray[i]->MovementZTick > CollapseCubesRowsDuration) {
     
    			SetMovingDownCubesTimer(MaxDeltaTimeMoveCubesDown); 
    			if (UpdateMatrix(CubesCurrentShapeArrayTest)) {
    				ClearMatrixRows();
    			}
    			GetWorld()->GetTimerManager().ClearTimer(SpinCubesHandle);
     
    			return;
     
    		}
    		else {
     
    			/*actor_rotator = CubesCurrentShapeArray[i]->GetActorRotation();
    			actor_rotator.Pitch = EasePennerObject->EaseInOutExpo(float(CubesCurrentShapeArray[i]->MovementZTick), 0, -90, (float)CollapseCubesRowsDuration); //TODO rendre CubeWidth et SpaceInterCubes Globales
    			CubesCurrentShapeArray[i]->SetActorRotation(actor_rotator); */
     
    			actor_location = CubesCurrentShapeArray[i]->GetActorLocation();
    			actor_location.Z = EasePennerObject->EaseInOutQuart(float(CubesCurrentShapeArray[i]->MovementZTick), CubesCurrentShapeArray[i]->InitZ, - SpinSteps * (CubeWidth + SpaceInterCubes), (float)CollapseCubesRowsDuration); //TODO rendre CubeWidth et SpaceInterCubes Globales
     
    			CubesCurrentShapeArray[i]->SetActorLocation(actor_location);
     
    			CubesCurrentShapeArray[i]->MovementZTick++;
     
    		}
     
    	}
     
    }
     
     
    void ACubesManager::EaseRemoveCubesRows() {
     
    	int32 duration = (CubesToCollapseArray.Num() - 1) * Delay + CollapseCubesRowsDuration;
    	//UE_LOG(LogTemp, Warning, TEXT("REMOVE_EASE"));
     
    	FVector actor_location;
     
    	for (int32 i = 0; i < CubesToRemoveArray.Num(); i++) {
     
    		if (CubesToRemoveArray[CubesToRemoveArray.Num() - 1]->MovementZTick > duration) {
     
    			CubesToRemoveArray.Empty();
    			GetWorld()->GetTimerManager().ClearTimer(RemoveCubesRowsHandle);
     
    			return;
     
    		}
    		else {
     
    			if (CubesToRemoveArray[i]->MovementZTick <= duration) {
    				actor_location = CubesToRemoveArray[i]->GetActorLocation();
    				actor_location.X = EasePennerObject->EaseOutQuart(float(CubesToRemoveArray[i]->MovementZTick), CubesToRemoveArray[i]->InitX, 828, (float)duration);
    				actor_location.Z = EasePennerObject->EaseOutQuart(float(CubesToRemoveArray[i]->MovementZTick), CubesToRemoveArray[i]->InitZ, 2500 - CubesToRemoveArray[i]->InitZ, (float)duration);
    				CubesToRemoveArray[i]->SetActorLocation(actor_location);
     
    				CubesToRemoveArray[i]->MovementZTick++;
    			}
     
    		}
    	}
     
    }
     
     
    void ACubesManager::EaseCollapseCubesRows() {
     
    	FVector actor_location;
     
    	for (int32 i = 0; i < CubesToCollapseArray.Num(); i++) {
     
    		if (CubesToCollapseArray[CubesToCollapseArray.Num() - 1]->MovementZTick > CollapseCubesRowsDuration) {
     
    			GlobalTick = 1;
    			CubesToCollapseArray.Empty();
    			CurrentShape = FMath::RandRange(1, 7);
    			SpawnCurrentShape(CurrentShape);
    			SetMovingDownCubesTimer(MaxDeltaTimeMoveCubesDown); 
    			CubesCanBeMoved = true;
    			GetWorld()->GetTimerManager().ClearTimer(CollapseCubesRowsHandle);
     
    			return;
     
    		}else {
    			if (i * Delay <= GlobalTick - 1) { //mise en place d'un delay entre chaque animation de cube
    				if (CubesToCollapseArray[i]->MovementZTick <= CollapseCubesRowsDuration) {
    					actor_location = CubesToCollapseArray[i]->GetActorLocation();
    					actor_location.Z = EasePennerObject->EaseOutBounce(float(CubesToCollapseArray[i]->MovementZTick), CubesToCollapseArray[i]->InitZ, -(CubeWidth + SpaceInterCubes)*CubesToCollapseArray[i]->NumRowsToCollapse, (float)CollapseCubesRowsDuration); //TODO rendre CubeWidth et SpaceInterCubes Globales
    					CubesToCollapseArray[i]->SetActorLocation(actor_location);
     
    					CubesToCollapseArray[i]->MovementZTick++;
    				}
     
    			}
    		}
     
    	}
     
    	GlobalTick++;
     
    }
     
    bool ACubesManager::CollapseMatrix(int32 RowToClearStartIndex, bool RowsIndexesToClear[]) {
     
    	GetWorld()->GetTimerManager().ClearTimer(MovingDownCubesHandle);
     
    	int32 num_rows_to_collapse = 0; //utile pour savoir de combien chaque rangée de cube chute
     
    	for (int32 j = RowToClearStartIndex; j < TopCubeIndex + 1; j++) {
     
    		if (RowsIndexesToClear[j - RowToClearStartIndex] && j - RowToClearStartIndex < 4) {
    			num_rows_to_collapse++;
    		}
    		else {
     
    			for (int32 i = 1; i <= NumCubesPerRow; i++) {
     
    				if (CubesMatrix[i][j].IsACube && num_rows_to_collapse > 0) {
     
    					CubesMatrix[i][j].Cube->MovementZTick = 1;
    					CubesMatrix[i][j - num_rows_to_collapse].Cube = CubesMatrix[i][j].Cube;
    					CubesMatrix[i][j - num_rows_to_collapse].IsACube = true;
    					CubesToCollapseArray.Add(CubesMatrix[i][j].Cube);// va être utile pour l'animation dans le SetTimer()
    					CubesToCollapseArray[CubesToCollapseArray.Num() - 1]->NumRowsToCollapse = num_rows_to_collapse;
    					CubesToCollapseArray[CubesToCollapseArray.Num() - 1]->InitZ = CubesMatrix[i][j].Cube->GetActorLocation().Z;
    					//CubesMatrix[i][j].Cube->SetActorLocation(CubesMatrix[i][j].Cube->GetActorLocation() + FVector(0.f, 0.f, -(CubeWidth + SpaceInterCubes)*num_rows_to_collapse));
    					CubesMatrix[i][j].Cube = nullptr;
    					CubesMatrix[i][j].IsACube = false;
     
    				}
     
    			}
     
    		}
    	}
     
    	TopCubeIndex -= num_rows_to_collapse;
     
    	CubesCanBeMoved = false;
    	GetWorld()->GetTimerManager().SetTimer(CollapseCubesRowsHandle, this, &ACubesManager::EaseCollapseCubesRows, DeltaTime, true);
    	GetWorld()->GetTimerManager().SetTimer(RemoveCubesRowsHandle, this, &ACubesManager::EaseRemoveCubesRows, DeltaTime, true);
     
    	return true;
     
    }
     
     
    bool ACubesManager::ClearMatrixRows() {
     
    	int32 cubes_compteur = 0, row_to_clear_start_index = 0;
    	bool rows_indexes_to_clear_arr[4] = { false };
     
    	if (TopCubeIndex == 0) { return false; }
     
    	for (int32 j = 1; j < TopCubeIndex + 1; j++) {
    		for (int32 i = 1; i < NumCubesPerRow + 1; i++) {
    			cubes_compteur += CubesMatrix[i][j].IsACube;
    		}
    		if (cubes_compteur == NumCubesPerRow) {
     
    			if (row_to_clear_start_index == 0) { //si on en est à la premiere rangée pleine
    				row_to_clear_start_index = j; // on indique l'index de la première rangée à vider
    			}
     
    			rows_indexes_to_clear_arr[j - row_to_clear_start_index] = true;
     
    			if (j == row_to_clear_start_index + 3) {
    				break;
    			}
     
    		}
     
    		cubes_compteur = 0;
     
    	}
     
    	if (row_to_clear_start_index > 0) { //Si on a au moins une rangée à éliminer
     
    		for (int32 j = row_to_clear_start_index; j < row_to_clear_start_index + 4; j++) { 
    			for (int32 i = 1; i < NumCubesPerRow + 1; i++) {
     
    				if (rows_indexes_to_clear_arr[j - row_to_clear_start_index]) {
     
    					CubesMatrix[i][j].Cube->MovementZTick = 1;
    					CubesArray.Add(CubesMatrix[i][j].Cube);
    					CubesToRemoveArray.Add(CubesMatrix[i][j].Cube);// va être utile pour l'animation dans le SetTimer()
    					CubesToRemoveArray[CubesToRemoveArray.Num() - 1]->InitX = CubesMatrix[i][j].Cube->GetActorLocation().X;
    					CubesToRemoveArray[CubesToRemoveArray.Num() - 1]->InitZ = CubesMatrix[i][j].Cube->GetActorLocation().Z;
    					CubesMatrix[i][j].Cube = nullptr;
    					CubesMatrix[i][j].IsACube = false;
     
    				}
     
    			}
    		}
     
    	}
     
     
    	if (row_to_clear_start_index > 0) {
    		return CollapseMatrix(row_to_clear_start_index, rows_indexes_to_clear_arr);
    	}else {
    		CubesCanBeMoved = true;
    		CurrentShape = FMath::RandRange(1, 7);
    		SpawnCurrentShape(CurrentShape);
     
    		return false;
    	}
     
     
     
    }
     
    bool ACubesManager::ShapeCollidesWithMatrix(CubeStruct ShapeArr[]) { //TODO optimiser, en ne bouclant les j que jusqu'à TopCubeIndex 
     
    	CubeStruct shape_array_temp[4];
     
    	float radius = 20; //rayon de tolérence pour que le cube soit "snappé" le point de la grille 2D
    	float cube_y, cube_z, horizontal_step, vertical_step;
    	float semi_cube_width = CubeWidth / 2;
     
    	horizontal_step = RightBoundary * 2 / float(NumCubesPerRow + 2);
    	vertical_step = TopBoundary / float(NumCubesPerColumn);
     
    	for (int32 i = 0; i < NumCubesPerRow + 2; i++) {
    		for (int32 j = 0; j < NumCubesPerColumn + 1; j++) {
    			for (int32 k = 0; k < 4; k++) {
     
    				cube_y = ShapeArr[k].y;
    				cube_z = ShapeArr[k].z;
     
    				cube_y += semi_cube_width; // pour bien positionner le cube virtuel sur la grille 2D prenant en compte les bords et vu que le point de pivot du cube est au centre;
    				cube_z += semi_cube_width + CubeWidth + SpaceInterCubes;
     
    				if (cube_y < horizontal_step * (i + 1) + radius - RightBoundary  &&
    					cube_y > horizontal_step * (i + 1) - radius - RightBoundary &&
    					cube_z < vertical_step * (j + 1) + radius  && cube_z > vertical_step * (j + 1) - radius) { // repère chaque élément de la matric correspondant aux coordonnées du cube
     
    					if (CubesMatrix[i][j].IsACube == true) { return true; } // si une collision est détectée
    					shape_array_temp[k].YMat = i;
    					shape_array_temp[k].ZMat = j;
     
    				}
    			}
    		}
    	}
     
    	 for (int32 k = 0; k < 4; k++) {
    		ShapeArr[k].YMat = shape_array_temp[k].YMat; //sert pour UpdateMatrix()
    		ShapeArr[k].ZMat = shape_array_temp[k].ZMat;
    	} 
     
     
    	return false;
    }
     
     
    void ACubesManager::SpawnCurrentShape(int32 CurrentShape) { //CurrentShape =====>  1 Cube, 2 stick, 3 stair right, 4 stair left, 5 L right, 6 L left, 7 T
     
    	FLinearColor material_color_array[7]; //stocke chaque couleur de chaque forme
     
    	material_color_array[0] = FLinearColor(0.295f, 0.295f, 0.295f);
    	material_color_array[1] = FLinearColor(0.148f, 0.242f, 0.845f);
    	material_color_array[2] = FLinearColor(0.103f, 0.49f, 0.176f);
    	material_color_array[3] = FLinearColor(0.675f, 0.174f, 0.214f);
    	material_color_array[4] = FLinearColor(0.615f, 0.242f, 0.635f);
    	material_color_array[5] = FLinearColor(0.29f, 0.081f, 0.345f);
    	material_color_array[6] = FLinearColor(0.8f, 0.79f, 0.256f);
     
    	int offset = CubeWidth + SpaceInterCubes;
     
    	if (!CubesArray[3]) { return; }
     
    	CubesCurrentShapeArray.Empty();
     
    	CubesCurrentShapeArray.Add(CubesArray[0]);
    	CubesCurrentShapeArray.Add(CubesArray[1]);
    	CubesCurrentShapeArray.Add(CubesArray[2]);
    	CubesCurrentShapeArray.Add(CubesArray[3]);
     
    	CubesArray.RemoveAt(0, 4, true);
     
    	CubesCurrentShapeArray[0]->SetActorLocation(FVector(-482.f, float(CubeWidth / 2 + SpaceInterCubes), float((NumCubesPerColumn - 0.5) * CubeWidth + (NumCubesPerColumn)*SpaceInterCubes)));
     
    	switch (CurrentShape)
    	{
    	case 1:
    		CubesCurrentShapeArray[1]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-offset)));
    		CubesCurrentShapeArray[2]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(offset), 0.f));
    		CubesCurrentShapeArray[3]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(offset), float(-offset)));
    		break;
    	case 2:
    		CubesCurrentShapeArray[1]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-offset)));
    		CubesCurrentShapeArray[2]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-2 * offset)));
    		CubesCurrentShapeArray[3]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(offset)));
    		break;
    	case 3:
    		CubesCurrentShapeArray[1]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, -float(offset), 0.f));
    		CubesCurrentShapeArray[2]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-offset)));
    		CubesCurrentShapeArray[3]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, -float(-offset), float(-offset)));
    		break;
    	case 4:
    		CubesCurrentShapeArray[1]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(offset), 0.f));
    		CubesCurrentShapeArray[2]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-offset)));
    		CubesCurrentShapeArray[3]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(-offset), float(-offset)));
    		break;
    	case 5:
    		CubesCurrentShapeArray[1]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-offset)));
    		CubesCurrentShapeArray[2]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(-offset), float(-offset)));
    		CubesCurrentShapeArray[3]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(offset)));
    		break;
    	case 6:
    		CubesCurrentShapeArray[1]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-offset)));
    		CubesCurrentShapeArray[2]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(offset), float(-offset)));
    		CubesCurrentShapeArray[3]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(offset)));
    		break;
    	case 7:
    		CubesCurrentShapeArray[1]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, 0.f, float(-offset)));
    		CubesCurrentShapeArray[2]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(offset), 0.f));
    		CubesCurrentShapeArray[3]->SetActorLocation(CubesCurrentShapeArray[0]->GetActorLocation() + FVector(0.f, float(-offset), 0.f));
    		break;
     
    	}
     
    	for (int32 i = 0; i < 4; i++) {
    		CubesCurrentShapeArray[i]->MaterialColor = material_color_array[CurrentShape - 1];
    		CubesCurrentShapeArray[i]->ReadyToSetMaterialColor = true;
    	}
     
    }

  3. #23
    Inactif  
    Homme Profil pro
    feignant
    Inscrit en
    Mars 2015
    Messages
    300
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : feignant

    Informations forums :
    Inscription : Mars 2015
    Messages : 300
    Points : 0
    Points
    0
    Par défaut
    Citation Envoyé par guitz Voir le message
    Mdr t'as repris nos tilesheets foireux dessinés sous the gimp Je t'avais dit qu'il y'avait une erreur dedans, enfin bon tant pis

    Sinon ça me fascine qu'on puisse faire un tetris avec unreal, comme quoi tout est possible.

  4. #24
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Très amusante ta vanne sur les tilesheets...

    Au moins je me lance plus dans un projet mégalo qu'il est quasi impossible de terminer contrairement à certains (j'ai déjà fait cette erreur, et ça m'a servie de leçon)

    Un Tetris c'est une façon humble de commencer l'apprentissage de UE4 sans bruler les étapes.

  5. #25
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    J'aime beaucoup comment les lignes s'effacent, lorsqu'une est remplie
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  6. #26
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Merci

    Là j'essaie de modéliser assez de tours du Kremlin et d'intégrer l'aire de jeu dans ce style architectural

    Celle-ci n'est pas terminée :



    Ca va prendre un certain temps

  7. #27
    Membre averti
    Avatar de marshiell
    Profil pro
    Développeur .NET
    Inscrit en
    Mars 2009
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : Allemagne

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : Mars 2009
    Messages : 100
    Points : 338
    Points
    338
    Par défaut
    Quel logiciel utilises-tu pour modéliser les tours du Kremlin? Elle m'a pas l'air trop mal la tour
    On peut faire ca directement dans UE4 ?

  8. #28
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    3DS Max

    Après pour les texture j'utilise l'excellent Mudbox



    Dans UE4 le seul object que tu peux sculpter/modéliser est le landscape

  9. #29
    Membre averti
    Avatar de marshiell
    Profil pro
    Développeur .NET
    Inscrit en
    Mars 2009
    Messages
    100
    Détails du profil
    Informations personnelles :
    Localisation : Allemagne

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : Mars 2009
    Messages : 100
    Points : 338
    Points
    338
    Par défaut
    La vidéo est bannie en Allemagne
    Pas grave haha merci pour ton retour

  10. #30
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    lol

    Il ont fait 20 millions de morts russes et perdus 2 millions de soldats à l'est. C'est comme si les américains censuraient des vidéos sur les arcs et les flèches

  11. #31
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Citation Envoyé par guitz Voir le message
    lol

    Il ont fait 20 millions de morts russes et perdus 2 millions de soldats à l'est. C'est comme si les américains censuraient des vidéos sur les arcs et les flèches
    Tu t'égares, là... Et tu ferais mieux d'éviter tellement ce que tu dis n'a aucun sens.
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  12. #32
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    T'es quand même au courant que l'AK47 était une arme russe ?

    Pourquoi censurent ils ces vidéos en Allemagne ?

  13. #33
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    T'es au courant qu'on est sur un forum de dév?
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  14. #34
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    T'es au courant qu'on est sur mon topic et que je fais des digressions quand j'ai envie ?

    C'est une propriété privée ici, c'est comme si t'étais sous mon toit. Tu vas quand même pas empêcher à ton hôte de dire ce qu'il veut ?

  15. #35
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 045
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 045
    Points : 11 368
    Points
    11 368
    Billets dans le blog
    10
    Par défaut
    Et bien digressons alors.

    Ta remarque a à peu près 50 ans de retard.
    Ca n'a strictement aucun sens de blâmer les (arrière) petits enfants des responsables, pour les actes que certains (ben oui, pas tous non plus, hein...) de leurs (arrière) grands parents ont commis.
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  16. #36
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Il y a pourtant eu des dédomagements importants de la part de l'Allemagne notamment envers Israel, même plus de 50 ans après les méfaits..

    Après Si toutes les vidéos de Ak-47 et autres armes russes sont censurées en Allemagne (je trouve ça surprenant quand même), ça veut bien dire ce que ça veut dire..

    FIN du HS

  17. #37
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 214
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 214
    Points : 10 136
    Points
    10 136
    Par défaut
    Citation Envoyé par guitz Voir le message
    C'est une propriété privée ici, c'est comme si t'étais sous mon toit. Tu vas quand même pas empêcher à ton hôte de dire ce qu'il veut ?
    Tu peux dire ce que tu veux , mais aussi les intervenants peuvent dire ce qu'il veulent

    Sinon non ce topic n'est pas une propriété privé et si elle l'est elle appartient alors à l'admin de developpez.net qui n'est pas toi à ce que je sache .

  18. #38
    Membre expérimenté
    Homme Profil pro
    Développeur
    Inscrit en
    Juillet 2009
    Messages
    416
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : Juillet 2009
    Messages : 416
    Points : 1 443
    Points
    1 443
    Par défaut
    Pour info, dans la description de la vidéo:

    Music by Ice Cube, Das EFX, D-Nice, Dr. Dre, Snoop Doggy Dog, Scarfce, Too Short, Cypress Hill
    et:


    La raison du ban de la vidéo est peut-être beaucoup plus terre à terre que ce que vous pensiez.

    D'ailleurs, quand on la regarde maintenant, elle est complètement silencieuse.

  19. #39
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Bonjour,

    La première tour du Kremlin est entièrement modélisée, j'attaque la seconde qui va être assez différente. Puis quand j'aurais fini les 3 + l'intégration de l'aire de jeu dedans, je vous posterai une mise à jour.


  20. #40
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    2e tour terminée :


Discussions similaires

  1. [GDC 2013] L'Unreal Engine 3 arrive sur nos navigateurs
    Par LittleWhite dans le forum Développement 2D, 3D et Jeux
    Réponses: 11
    Dernier message: 08/05/2013, 00h46
  2. Réponses: 4
    Dernier message: 06/04/2013, 22h22
  3. L'Unreal Engine 3 fonctionne sur Windows 8 RT
    Par dourouc05 dans le forum Unreal Engine
    Réponses: 5
    Dernier message: 31/08/2012, 11h30
  4. E3 2012 : Epic Games publie une première démo de l'Unreal Engine 4
    Par LittleWhite dans le forum Développement 2D, 3D et Jeux
    Réponses: 12
    Dernier message: 28/08/2012, 09h48
  5. Les premières images de l'Unreal Engine 4 dévoilées !
    Par LittleWhite dans le forum Développement 2D, 3D et Jeux
    Réponses: 10
    Dernier message: 25/05/2012, 19h29

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo