Minor - Implémente la collision joueur-centipede - V3.5.0

Implémente la détection de collision entre le joueur et le centipede.

Le joueur perd une vie lors de la collision et devient temporairement invincible.

Ajoute la logique de fin de niveau lorsque tous les segments du centipede sont détruits.

.gitattributes

@@ -1 +1 @@
-UnrealToolbox.exe filter=lfs diff=lfs merge=lfs -text
+UnrealToolbox.exe filter=lfs diff=lfs merge=lfs -text

Config/DefaultEngine.ini

@@ -10,9 +10,9 @@ r.AllowStaticLighting=False
 
 r.GenerateMeshDistanceFields=True
 
-r.DynamicGlobalIlluminationMethod=1
+r.DynamicGlobalIlluminationMethod=0
 
-r.ReflectionMethod=1
+r.ReflectionMethod=0
 
 r.SkinCache.CompileShaders=True
 
@@ -27,6 +27,12 @@ r.DefaultFeature.AutoExposure.ExtendDefaultLuminanceRange=True
 r.DefaultFeature.LocalExposure.HighlightContrastScale=0.8
 
 r.DefaultFeature.LocalExposure.ShadowContrastScale=0.8
+r.Lumen.HardwareRayTracing=False
+r.Lumen.Reflections.HardwareRayTracing.Translucent.Refraction.EnableForProject=False
+r.Mobile.SupportsGen4TAA=False
+r.CustomDepthTemporalAAJitter=False
+r.AntiAliasingMethod=1
+r.DefaultFeature.MotionBlur=False
 
 [/Script/WindowsTargetPlatform.WindowsTargetSettings]
 DefaultGraphicsRHI=DefaultGraphicsRHI_DX12
@@ -94,3 +100,65 @@ ConnectionType=USBOnly
 bUseManualIPAddress=False
 ManualIPAddress=
 
+
+[CoreRedirects]
++ClassRedirects=(OldName="/Script/M4_CPP.M4_CentipedeController",NewName="/Script/M4_CPP.M4_CentipedeController")
++FunctionRedirects=(OldName="/Script/M4_CPP.M4_CentipedeController.OnSegmentDestroyed",NewName="/Script/M4_CPP.M4_CentipedeController.OnSegmentHit")
+
+[/Script/Engine.CollisionProfile]
+-Profiles=(Name="NoCollision",CollisionEnabled=NoCollision,ObjectTypeName="WorldStatic",CustomResponses=((Channel="Visibility",Response=ECR_Ignore),(Channel="Camera",Response=ECR_Ignore)),HelpMessage="No collision",bCanModify=False)
+-Profiles=(Name="BlockAll",CollisionEnabled=QueryAndPhysics,ObjectTypeName="WorldStatic",CustomResponses=,HelpMessage="WorldStatic object that blocks all actors by default. All new custom channels will use its own default response. ",bCanModify=False)
+-Profiles=(Name="OverlapAll",CollisionEnabled=QueryOnly,ObjectTypeName="WorldStatic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility",Response=ECR_Overlap),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldStatic object that overlaps all actors by default. All new custom channels will use its own default response. ",bCanModify=False)
+-Profiles=(Name="BlockAllDynamic",CollisionEnabled=QueryAndPhysics,ObjectTypeName="WorldDynamic",CustomResponses=,HelpMessage="WorldDynamic object that blocks all actors by default. All new custom channels will use its own default response. ",bCanModify=False)
+-Profiles=(Name="OverlapAllDynamic",CollisionEnabled=QueryOnly,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility",Response=ECR_Overlap),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldDynamic object that overlaps all actors by default. All new custom channels will use its own default response. ",bCanModify=False)
+-Profiles=(Name="IgnoreOnlyPawn",CollisionEnabled=QueryOnly,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="Pawn",Response=ECR_Ignore),(Channel="Vehicle",Response=ECR_Ignore)),HelpMessage="WorldDynamic object that ignores Pawn and Vehicle. All other channels will be set to default.",bCanModify=False)
+-Profiles=(Name="OverlapOnlyPawn",CollisionEnabled=QueryOnly,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="Pawn",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Ignore)),HelpMessage="WorldDynamic object that overlaps Pawn, Camera, and Vehicle. All other channels will be set to default. ",bCanModify=False)
+-Profiles=(Name="Pawn",CollisionEnabled=QueryAndPhysics,ObjectTypeName="Pawn",CustomResponses=((Channel="Visibility",Response=ECR_Ignore)),HelpMessage="Pawn object. Can be used for capsule of any playerable character or AI. ",bCanModify=False)
+-Profiles=(Name="Spectator",CollisionEnabled=QueryOnly,ObjectTypeName="Pawn",CustomResponses=((Channel="WorldStatic",Response=ECR_Block),(Channel="Pawn",Response=ECR_Ignore),(Channel="Visibility",Response=ECR_Ignore),(Channel="WorldDynamic",Response=ECR_Ignore),(Channel="Camera",Response=ECR_Ignore),(Channel="PhysicsBody",Response=ECR_Ignore),(Channel="Vehicle",Response=ECR_Ignore),(Channel="Destructible",Response=ECR_Ignore)),HelpMessage="Pawn object that ignores all other actors except WorldStatic.",bCanModify=False)
+-Profiles=(Name="CharacterMesh",CollisionEnabled=QueryOnly,ObjectTypeName="Pawn",CustomResponses=((Channel="Pawn",Response=ECR_Ignore),(Channel="Vehicle",Response=ECR_Ignore),(Channel="Visibility",Response=ECR_Ignore)),HelpMessage="Pawn object that is used for Character Mesh. All other channels will be set to default.",bCanModify=False)
+-Profiles=(Name="PhysicsActor",CollisionEnabled=QueryAndPhysics,ObjectTypeName="PhysicsBody",CustomResponses=,HelpMessage="Simulating actors",bCanModify=False)
+-Profiles=(Name="Destructible",CollisionEnabled=QueryAndPhysics,ObjectTypeName="Destructible",CustomResponses=,HelpMessage="Destructible actors",bCanModify=False)
+-Profiles=(Name="InvisibleWall",CollisionEnabled=QueryAndPhysics,ObjectTypeName="WorldStatic",CustomResponses=((Channel="Visibility",Response=ECR_Ignore)),HelpMessage="WorldStatic object that is invisible.",bCanModify=False)
+-Profiles=(Name="InvisibleWallDynamic",CollisionEnabled=QueryAndPhysics,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="Visibility",Response=ECR_Ignore)),HelpMessage="WorldDynamic object that is invisible.",bCanModify=False)
+-Profiles=(Name="Trigger",CollisionEnabled=QueryOnly,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility",Response=ECR_Ignore),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldDynamic object that is used for trigger. All other channels will be set to default.",bCanModify=False)
+-Profiles=(Name="Ragdoll",CollisionEnabled=QueryAndPhysics,ObjectTypeName="PhysicsBody",CustomResponses=((Channel="Pawn",Response=ECR_Ignore),(Channel="Visibility",Response=ECR_Ignore)),HelpMessage="Simulating Skeletal Mesh Component. All other channels will be set to default.",bCanModify=False)
+-Profiles=(Name="Vehicle",CollisionEnabled=QueryAndPhysics,ObjectTypeName="Vehicle",CustomResponses=,HelpMessage="Vehicle object that blocks Vehicle, WorldStatic, and WorldDynamic. All other channels will be set to default.",bCanModify=False)
+-Profiles=(Name="UI",CollisionEnabled=QueryOnly,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility",Response=ECR_Block),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldStatic object that overlaps all actors by default. All new custom channels will use its own default response. ",bCanModify=False)
++Profiles=(Name="NoCollision",CollisionEnabled=NoCollision,bCanModify=False,ObjectTypeName="WorldStatic",CustomResponses=((Channel="Visibility",Response=ECR_Ignore),(Channel="Camera",Response=ECR_Ignore)),HelpMessage="No collision")
++Profiles=(Name="BlockAll",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="WorldStatic",CustomResponses=,HelpMessage="WorldStatic object that blocks all actors by default. All new custom channels will use its own default response. ")
++Profiles=(Name="OverlapAll",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="WorldStatic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility",Response=ECR_Overlap),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldStatic object that overlaps all actors by default. All new custom channels will use its own default response. ")
++Profiles=(Name="BlockAllDynamic",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="WorldDynamic",CustomResponses=,HelpMessage="WorldDynamic object that blocks all actors by default. All new custom channels will use its own default response. ")
++Profiles=(Name="OverlapAllDynamic",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility",Response=ECR_Overlap),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldDynamic object that overlaps all actors by default. All new custom channels will use its own default response. ")
++Profiles=(Name="IgnoreOnlyPawn",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="Pawn",Response=ECR_Ignore),(Channel="Vehicle",Response=ECR_Ignore)),HelpMessage="WorldDynamic object that ignores Pawn and Vehicle. All other channels will be set to default.")
++Profiles=(Name="OverlapOnlyPawn",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="Pawn",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Ignore)),HelpMessage="WorldDynamic object that overlaps Pawn, Camera, and Vehicle. All other channels will be set to default. ")
++Profiles=(Name="Pawn",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="Pawn",CustomResponses=((Channel="Visibility",Response=ECR_Ignore)),HelpMessage="Pawn object. Can be used for capsule of any playerable character or AI. ")
++Profiles=(Name="Spectator",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="Pawn",CustomResponses=((Channel="WorldStatic"),(Channel="Pawn",Response=ECR_Ignore),(Channel="Visibility",Response=ECR_Ignore),(Channel="WorldDynamic",Response=ECR_Ignore),(Channel="Camera",Response=ECR_Ignore),(Channel="PhysicsBody",Response=ECR_Ignore),(Channel="Vehicle",Response=ECR_Ignore),(Channel="Destructible",Response=ECR_Ignore)),HelpMessage="Pawn object that ignores all other actors except WorldStatic.")
++Profiles=(Name="CharacterMesh",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="Pawn",CustomResponses=((Channel="Pawn",Response=ECR_Ignore),(Channel="Vehicle",Response=ECR_Ignore),(Channel="Visibility",Response=ECR_Ignore)),HelpMessage="Pawn object that is used for Character Mesh. All other channels will be set to default.")
++Profiles=(Name="PhysicsActor",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="PhysicsBody",CustomResponses=,HelpMessage="Simulating actors")
++Profiles=(Name="Destructible",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="Destructible",CustomResponses=,HelpMessage="Destructible actors")
++Profiles=(Name="InvisibleWall",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="WorldStatic",CustomResponses=((Channel="Visibility",Response=ECR_Ignore)),HelpMessage="WorldStatic object that is invisible.")
++Profiles=(Name="InvisibleWallDynamic",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="Visibility",Response=ECR_Ignore)),HelpMessage="WorldDynamic object that is invisible.")
++Profiles=(Name="Trigger",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility",Response=ECR_Ignore),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldDynamic object that is used for trigger. All other channels will be set to default.")
++Profiles=(Name="Ragdoll",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="PhysicsBody",CustomResponses=((Channel="Pawn",Response=ECR_Ignore),(Channel="Visibility",Response=ECR_Ignore)),HelpMessage="Simulating Skeletal Mesh Component. All other channels will be set to default.")
++Profiles=(Name="Vehicle",CollisionEnabled=QueryAndPhysics,bCanModify=False,ObjectTypeName="Vehicle",CustomResponses=,HelpMessage="Vehicle object that blocks Vehicle, WorldStatic, and WorldDynamic. All other channels will be set to default.")
++Profiles=(Name="UI",CollisionEnabled=QueryOnly,bCanModify=False,ObjectTypeName="WorldDynamic",CustomResponses=((Channel="WorldStatic",Response=ECR_Overlap),(Channel="Pawn",Response=ECR_Overlap),(Channel="Visibility"),(Channel="WorldDynamic",Response=ECR_Overlap),(Channel="Camera",Response=ECR_Overlap),(Channel="PhysicsBody",Response=ECR_Overlap),(Channel="Vehicle",Response=ECR_Overlap),(Channel="Destructible",Response=ECR_Overlap)),HelpMessage="WorldStatic object that overlaps all actors by default. All new custom channels will use its own default response. ")
++DefaultChannelResponses=(Channel=ECC_GameTraceChannel1,DefaultResponse=ECR_Block,bTraceType=False,bStaticObject=False,Name="Projectile")
+-ProfileRedirects=(OldName="BlockingVolume",NewName="InvisibleWall")
+-ProfileRedirects=(OldName="InterpActor",NewName="IgnoreOnlyPawn")
+-ProfileRedirects=(OldName="StaticMeshComponent",NewName="BlockAllDynamic")
+-ProfileRedirects=(OldName="SkeletalMeshActor",NewName="PhysicsActor")
+-ProfileRedirects=(OldName="InvisibleActor",NewName="InvisibleWallDynamic")
++ProfileRedirects=(OldName="BlockingVolume",NewName="InvisibleWall")
++ProfileRedirects=(OldName="InterpActor",NewName="IgnoreOnlyPawn")
++ProfileRedirects=(OldName="StaticMeshComponent",NewName="BlockAllDynamic")
++ProfileRedirects=(OldName="SkeletalMeshActor",NewName="PhysicsActor")
++ProfileRedirects=(OldName="InvisibleActor",NewName="InvisibleWallDynamic")
+-CollisionChannelRedirects=(OldName="Static",NewName="WorldStatic")
+-CollisionChannelRedirects=(OldName="Dynamic",NewName="WorldDynamic")
+-CollisionChannelRedirects=(OldName="VehicleMovement",NewName="Vehicle")
+-CollisionChannelRedirects=(OldName="PawnMovement",NewName="Pawn")
++CollisionChannelRedirects=(OldName="Static",NewName="WorldStatic")
++CollisionChannelRedirects=(OldName="Dynamic",NewName="WorldDynamic")
++CollisionChannelRedirects=(OldName="VehicleMovement",NewName="Vehicle")
++CollisionChannelRedirects=(OldName="PawnMovement",NewName="Pawn")
+

Source/M4_CPP/private/M4_CentipedeBody.cpp

@@ -0,0 +1,51 @@
+#include "M4_CentipedeBody.h"
+
+AM4_CentipedeBody::AM4_CentipedeBody()
+{
+	PrimaryActorTick.bCanEverTick = false;
+
+	static ConstructorHelpers::FObjectFinder<UStaticMesh> MeshRef(TEXT("/Game/CTP/04_Mesh/SM_Cube.SM_Cube"));
+	if (MeshRef.Succeeded())
+	{
+		GetStaticMeshComponent()->SetStaticMesh(MeshRef.Object);
+	}
+
+	static ConstructorHelpers::FObjectFinder<UMaterialInterface> HeadMatRef(TEXT("/Game/CTP/05_Material/MI_Head.MI_Head"));
+	if (HeadMatRef.Succeeded())
+	{
+		HeadMaterial = HeadMatRef.Object;
+	}
+
+	static ConstructorHelpers::FObjectFinder<UMaterialInterface> BodyMatRef(TEXT("/Game/CTP/05_Material/MI_Body.MI_Body"));
+	if (BodyMatRef.Succeeded())
+	{
+		BodyMaterial = BodyMatRef.Object;
+	}
+
+	GetStaticMeshComponent()->SetRelativeScale3D(FVector(1.f, 0.4f, 0.4f));
+	GetStaticMeshComponent()->SetMobility(EComponentMobility::Movable);
+	GetStaticMeshComponent()->SetCollisionObjectType(ECollisionChannel::ECC_WorldDynamic);
+	GetStaticMeshComponent()->SetGenerateOverlapEvents(true);
+	GetStaticMeshComponent()->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
+	GetStaticMeshComponent()->SetCollisionProfileName(TEXT("OverlapAll"));
+}
+
+void AM4_CentipedeBody::SetAsHead(bool bHead)
+{
+    bIsHead = bHead;
+    
+    if (bIsHead)
+    {
+        if (HeadMaterial)
+        {
+            GetStaticMeshComponent()->SetMaterial(0, HeadMaterial);
+        }
+    }
+    else
+    {
+        if (BodyMaterial)
+        {
+            GetStaticMeshComponent()->SetMaterial(0, BodyMaterial);
+        }
+    }
+}

Source/M4_CPP/private/M4_CentipedeController.cpp

@@ -0,0 +1,347 @@
+#include "M4_CentipedeController.h"
+#include "M4_LOG.h"
+#include "M4_Gamemode.h"
+#include "M4_Mushroom.h"
+#include "Kismet/GameplayStatics.h"
+
+UM4_CentipedeController::UM4_CentipedeController()
+{
+    SegmentRemainingCount = BodyCount;
+}
+
+void UM4_CentipedeController::Initialize(FSubsystemCollectionBase& Collection)
+{
+    Super::Initialize(Collection);
+    
+    UE_LOG(M4_CPP, Warning, TEXT("Centipede Controller Initialized"));
+    
+}
+
+void UM4_CentipedeController::Deinitialize()
+{
+    UE_LOG(M4_CPP, Warning, TEXT("Centipede Controller Deinitialized"));
+    
+    BodySegments.Empty();
+    PreviousPositions.Empty();
+    SegmentDirections.Empty();
+    
+    Super::Deinitialize();
+}
+
+void UM4_CentipedeController::StartCentipede(FVector SpawnLocation)
+{
+    if (BodySegments.Num() > 0)
+    {
+        UE_LOG(M4_CPP, Warning, TEXT("Centipede already spawned"));
+        return;
+    }
+
+    for (int32 i = 0; i < BodyCount; ++i)
+    {
+        FVector SegmentLocation = SpawnLocation - FVector(0.f, i * CellSize, 0.f);
+
+        AM4_CentipedeBody* Body = GetWorld()->SpawnActor<AM4_CentipedeBody>(
+            AM4_CentipedeBody::StaticClass(),
+            SegmentLocation,
+            FRotator::ZeroRotator
+        );
+
+        if (Body)
+        {
+            BodySegments.Add(Body);
+
+            if (i > 0)
+            {
+                Body->PreviousBody = BodySegments[i - 1];
+                BodySegments[i - 1]->NextBody = Body;
+            }
+
+            Body->SetAsHead(i == 0);
+        }
+    }
+    
+    SegmentHistory.SetNum(BodyCount);
+    for (int32 i = 0; i < BodyCount; ++i)
+    {
+        if (BodySegments.IsValidIndex(i) && BodySegments[i])
+        {
+            FVector InitialPos = BodySegments[i]->GetActorLocation();
+            
+            int32 InitialHistorySize = SegmentSpacing * (i + 1) + MaxHistorySize;
+            for (int32 j = 0; j < InitialHistorySize; ++j)
+            {
+                SegmentHistory[i].Add(InitialPos);
+            }
+        }
+    }
+
+    for (AM4_CentipedeBody* Segment : BodySegments)
+    {
+        SegmentDirections.Add(Segment, FVector2D(0.f, 1.f));
+    }
+
+    UE_LOG(M4_CPP, Warning, TEXT("Centipede spawned with %d segments"), BodySegments.Num());
+}
+
+TStatId UM4_CentipedeController::GetStatId() const
+{
+    RETURN_QUICK_DECLARE_CYCLE_STAT(UM4_CentipedeController, STATGROUP_Tickables);
+}
+
+void UM4_CentipedeController::SpawnCentipede()
+{
+    GM_REF_PTR = Cast<AM4_Gamemode>(GetWorld()->GetAuthGameMode());
+    if (!GM_REF_PTR) return;
+    
+    FVector SpawnLocation = FVector(
+        GM_REF_PTR->MushroomSpawnBounds.Max.X,
+        0.f,
+        0.f
+    );
+    
+    UE_LOG(M4_CPP, Warning, TEXT("Controller spawn location: X=%.2f, Y=%.2f, Z=%.2f"), 
+           SpawnLocation.X, SpawnLocation.Y, SpawnLocation.Z);
+
+    if (SpawnLocation.IsZero())
+    {
+        UE_LOG(M4_CPP, Error, TEXT("Controller position is zero! Check spawn parameters."));
+        return;
+    }
+    
+    for (int32 i = 0; i < BodyCount; ++i)
+    {
+        FVector SegmentLocation = SpawnLocation - FVector(0.f, i * CellSize, 0.f);
+
+        AM4_CentipedeBody* Body = GetWorld()->SpawnActor<AM4_CentipedeBody>(
+            AM4_CentipedeBody::StaticClass(),
+            SegmentLocation,
+            FRotator::ZeroRotator
+        );
+
+        if (Body)
+        {
+            BodySegments.Add(Body);
+
+            if (i > 0)
+            {
+                Body->PreviousBody = BodySegments[i - 1];
+                BodySegments[i - 1]->NextBody = Body;
+            }
+            
+            Body->SetAsHead(i == 0);
+        }
+    }
+}
+
+void UM4_CentipedeController::Tick(float DeltaTime)
+{
+    Super::Tick(DeltaTime);
+
+    if (BodySegments.Num() == 0) return;
+    
+    AM4_CentipedeBody* Head = BodySegments[0];
+    if (Head && Head->bIsHead)
+    {
+        FVector CurrentPos = Head->GetActorLocation();
+        FVector2D SegmentDirection = GetSegmentDirection(Head);
+
+        bool bRowChanged = CheckCollision(Head, SegmentDirection);
+
+        if (bRowChanged)
+        {
+            FVector NewPos = CurrentPos - FVector(0.f, 0.f, CellSize);
+            Head->SetActorLocation(NewPos);
+
+            SegmentDirection.Y *= -1.f;
+            SetSegmentDirection(Head, SegmentDirection);
+        }
+        else
+        {
+            FVector NewPos = CurrentPos + FVector(0.f, SegmentDirection.Y * CentipedeSpeed * DeltaTime, 0.f);
+            Head->SetActorLocation(NewPos);
+        }
+        
+        SegmentHistory[0].Add(Head->GetActorLocation());
+        if (SegmentHistory[0].Num() > MaxHistorySize)
+        {
+            SegmentHistory[0].RemoveAt(0);
+        }
+    }
+    
+    for (int32 i = 1; i < BodySegments.Num(); ++i)
+    {
+        AM4_CentipedeBody* Segment = BodySegments[i];
+        if (!Segment) continue;
+        
+        int32 PrevIndex = i - 1;
+        int32 HistoryLookback = SegmentSpacing;
+        
+        if (SegmentHistory[PrevIndex].Num() > HistoryLookback)
+        {
+            int32 HistoryIndex = SegmentHistory[PrevIndex].Num() - HistoryLookback - 1;
+            FVector TargetPos = SegmentHistory[PrevIndex][HistoryIndex];
+            
+            Segment->SetActorLocation(TargetPos);
+            
+            SegmentHistory[i].Add(Segment->GetActorLocation());
+            if (SegmentHistory[i].Num() > MaxHistorySize)
+            {
+                SegmentHistory[i].RemoveAt(0);
+            }
+        }
+    }
+
+    UpdateHeadStatus();
+}
+
+bool UM4_CentipedeController::CheckCollision(AM4_CentipedeBody* Segment, FVector2D Direction)
+{
+    if (!Segment) return false;
+
+    FVector CurrentPos = Segment->GetActorLocation();
+    FVector NextPos = CurrentPos + FVector(0.f, Direction.Y * CellSize, 0.f);
+    
+    if (!GM_REF_PTR)
+    {
+        GM_REF_PTR = Cast<AM4_Gamemode>(GetWorld()->GetAuthGameMode());
+        if (!GM_REF_PTR) return false;
+    }
+
+    const float LeftBound = GM_REF_PTR->MushroomSpawnBounds.Min.Y;
+    const float RightBound = GM_REF_PTR->MushroomSpawnBounds.Max.Y;
+    const float MinRows = GM_REF_PTR->MushroomSpawnBounds.Min.X;
+    const float MaxRows = GM_REF_PTR->MushroomSpawnBounds.Max.X;
+    
+    if (NextPos.Y <= LeftBound || NextPos.Y >= RightBound)
+    {
+        return true;
+    }
+
+    if (CurrentPos.Z > MinRows && NextPos.Z <= MinRows)
+    {
+        // On inverse la direction de descente pour remonter
+        FVector2D CurrentDirection = GetSegmentDirection(Segment);
+        CurrentDirection.Y *= -1.f;
+        SetSegmentDirection(Segment, CurrentDirection);
+        return true; // Collision détectée, le centipede descendra à la prochaine itération
+    }
+    
+    // Vérification si on atteint la limite haute
+    if (CurrentPos.Z < MaxRows && NextPos.Z >= MaxRows)
+    {
+        // On inverse la direction de montée pour descendre
+        FVector2D CurrentDirection = GetSegmentDirection(Segment);
+        CurrentDirection.Y *= -1.f;
+        SetSegmentDirection(Segment, CurrentDirection);
+        return true; // Collision détectée, le centipede remontera à la prochaine itération
+    }
+
+    int32 NextGridZ = FMath::RoundToInt(NextPos.Z / CellSize);
+    int32 NextGridY = FMath::RoundToInt(NextPos.Y / CellSize);
+
+    TArray<AActor*> FoundMushrooms;
+    UGameplayStatics::GetAllActorsOfClass(GetWorld(), AM4_Mushroom::StaticClass(), FoundMushrooms);
+
+    for (AActor* Actor : FoundMushrooms)
+    {
+        FVector MushroomPos = Actor->GetActorLocation();
+        
+        // Conversion de la position du mushroom en coordonnées de grille (Z, Y)
+        int32 MushroomGridZ = FMath::RoundToInt(MushroomPos.Z / CellSize);
+        int32 MushroomGridY = FMath::RoundToInt(MushroomPos.Y / CellSize);
+        
+        // Vérification si c'est la même cellule de grille
+        if (NextGridZ == MushroomGridZ && NextGridY == MushroomGridY)
+        {
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+FVector2D UM4_CentipedeController::GetSegmentDirection(AM4_CentipedeBody* Segment)
+{
+    if (SegmentDirections.Contains(Segment))
+    {
+        return SegmentDirections[Segment];
+    }
+    return FVector2D(0.f, 1.f);
+}
+
+void UM4_CentipedeController::SetSegmentDirection(AM4_CentipedeBody* Segment, FVector2D Direction)
+{
+    if (Segment)
+    {
+        SegmentDirections.Add(Segment, Direction);
+    }
+}
+
+void UM4_CentipedeController::UpdateHeadStatus()
+{
+    for (int32 i = 0; i < BodySegments.Num(); ++i)
+    {
+        AM4_CentipedeBody* Body = BodySegments[i];
+        if (!Body) continue;
+        
+        bool bShouldBeHead = (i == 0) || (Body->PreviousBody == nullptr);
+        
+        if (Body->bIsHead != bShouldBeHead)
+        {
+            Body->SetAsHead(bShouldBeHead);
+        }
+    }
+}
+
+void UM4_CentipedeController::OnSegmentHit(AM4_CentipedeBody* DestroyedSegment)
+{
+    if (!DestroyedSegment) return;
+
+    int32 SegmentIndex = BodySegments.Find(DestroyedSegment);
+    if (SegmentIndex == INDEX_NONE) return;
+
+    if (SegmentIndex + 1 < BodySegments.Num())
+    {
+        AM4_CentipedeBody* NewHead = BodySegments[SegmentIndex + 1];
+        if (NewHead)
+        {
+            NewHead->SetAsHead(true);
+            NewHead->PreviousBody = nullptr;
+        }
+    }
+
+    if (SegmentIndex > 0 && BodySegments[SegmentIndex - 1])
+    {
+        BodySegments[SegmentIndex - 1]->NextBody = nullptr;
+    }
+
+    // disable collision and hide the destroyed segment
+    DestroyedSegment->GetStaticMeshComponent()->SetCollisionEnabled(ECollisionEnabled::NoCollision);
+    DestroyedSegment->SetActorHiddenInGame(true);
+    // Increase player score
+    if (!GM_REF_PTR)
+    {
+        GM_REF_PTR = Cast<AM4_Gamemode>(GetWorld()->GetAuthGameMode());
+        if (!GM_REF_PTR) return;
+    }
+    GM_REF_PTR->AddScore(100);
+    SpawnMushroomsAtSegmentDeathPos(DestroyedSegment->GetActorLocation());
+    // Decresase the remaining segment count and check if all segments are destroyed
+    SegmentRemainingCount--;
+    if (SegmentRemainingCount <= 0)
+    {
+        // TODO: Trigger level complete or respawn centipede
+        UE_LOG(M4_CPP, Warning, TEXT("All centipede segments destroyed!"));
+    }
+}
+
+void UM4_CentipedeController::SpawnMushroomsAtSegmentDeathPos(FVector Location)
+{
+    FVector Offset = FVector(0.f, FMath::RandRange(-CellSize, CellSize), 0.f);
+    FVector SpawnLocation = Location + Offset;
+    GetWorld()->SpawnActor<AM4_Mushroom>(
+        AM4_Mushroom::StaticClass(),
+        SpawnLocation,
+        FRotator::ZeroRotator
+    );
+}

Source/M4_CPP/private/M4_Gamemode.cpp

@@ -1,6 +1,8 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 #include "M4_Gamemode.h"
 
+#include "M4_CTP_Macros.h"
+#include "M4_Mushroom.h"
 #include "M4_PlayerController.h"
 #include "M4_PlayerPawn.h"
 
@@ -11,10 +13,97 @@ AM4_Gamemode::AM4_Gamemode()
 
 	PlayerControllerClass = AM4_PlayerController::StaticClass();
 	DefaultPawnClass = AM4_PlayerPawn::StaticClass();
+	
+	MushroomCount = FMath::RandRange(20, 25);
 
 }
 
 void AM4_Gamemode::BeginPlay()
 {
 	Super::BeginPlay();
-}
+
+	Score = 0;
+	Lives = 3;
+
+	// Get mushroom size from the class
+	AM4_Mushroom* TempMushroom = GetWorld()->SpawnActor<AM4_Mushroom>(AM4_Mushroom::StaticClass());
+	if (TempMushroom)
+	{
+		FVector MushroomSize = TempMushroom->GetStaticMeshComponent()->Bounds.BoxExtent * 2.0f;
+		CellSize = FMath::Max(MushroomSize.Y, MushroomSize.Z); // Use largest dimension
+		TempMushroom->Destroy();
+	}
+
+	// Calculate grid dimensions based on cell size
+	const int32 GridRows = FMath::FloorToInt(MushroomSpawnBounds.GetSize().X / CellSize);
+	const int32 GridCols = FMath::FloorToInt(MushroomSpawnBounds.GetSize().Y / CellSize);
+
+	// spawn mushrooms in a grid inside the spawn bounds and in random cell
+	if (MushroomCount > 0)
+	{
+		TSet<FIntPoint> OccupiedCells;
+
+		for (int32 i = 0; i < MushroomCount; ++i)
+		{
+			FIntPoint Cell;
+			bool bValidCell;
+			int32 MaxAttempts = 100;
+			int32 Attempts = 0;
+
+			do
+			{
+				Cell.X = FMath::RandRange(0, GridRows - 1);
+				Cell.Y = FMath::RandRange(0, GridCols - 1);
+
+				// Check if cell and adjacent cells are free
+				bValidCell = !OccupiedCells.Contains(Cell) &&
+							 !OccupiedCells.Contains(FIntPoint(Cell.X - 1, Cell.Y)) &&
+							 !OccupiedCells.Contains(FIntPoint(Cell.X + 1, Cell.Y)) &&
+							 !OccupiedCells.Contains(FIntPoint(Cell.X, Cell.Y - 1)) &&
+							 !OccupiedCells.Contains(FIntPoint(Cell.X, Cell.Y + 1));
+
+				Attempts++;
+			} while (!bValidCell && Attempts < MaxAttempts);
+
+			if (!bValidCell)
+			{
+				PRINT_SCREEN(TEXT("Could not find valid cell for mushroom"), FColor::Yellow);
+				continue;
+			}
+
+			OccupiedCells.Add(Cell);
+
+			FVector SpawnLocation;
+			SpawnLocation.Z = MushroomSpawnBounds.Min.X + Cell.X * CellSize + CellSize / 2.0f;
+			SpawnLocation.Y = MushroomSpawnBounds.Min.Y + Cell.Y * CellSize + CellSize / 2.0f;
+			SpawnLocation.X = -400.0f;
+
+			GetWorld()->SpawnActor<AM4_Mushroom>(
+				AM4_Mushroom::StaticClass(),
+				SpawnLocation,
+				FRotator::ZeroRotator
+				);
+		}
+	}
+	
+	PRINT_SCREEN(TEXT("Spawning Centipede Controller"), FColor::Green);
+
+	FVector CentipedeSpawnLocation = FVector(
+		-400.0f,
+		0.0f,
+		MushroomSpawnBounds.Max.X + CellSize
+		);
+
+	// PRINT SCREEN Max.X value
+	PRINT_SCREEN(*FString::Printf(TEXT("Mushroom Spawn Bounds Max.X: %.2f"), MushroomSpawnBounds.Max.X), FColor::Green);
+
+	UM4_CentipedeController* Controller = GetWorld()->GetSubsystem<UM4_CentipedeController>();
+	if (Controller)
+	{
+		Controller->BodyCount = CentipedeBodyCount;
+		Controller->CellSize = CellSize;
+    
+		Controller->StartCentipede(CentipedeSpawnLocation);
+	}
+
+}

Source/M4_CPP/private/M4_Mushroom.cpp

@@ -0,0 +1,60 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "M4_Mushroom.h"
+
+#include "M4_CTP_Macros.h"
+#include "Kismet/GameplayStatics.h"
+#include "M4_Gamemode.h"
+#include "M4_Projectile.h"
+
+
+// Sets default values
+AM4_Mushroom::AM4_Mushroom()
+{
+	// Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
+	PrimaryActorTick.bCanEverTick = true;
+
+	static ConstructorHelpers::FObjectFinder<UStaticMesh> StaticMeshRef(TEXT("/Game/CTP/04_Mesh/SM_Cube.SM_Cube"));
+	if (StaticMeshRef.Succeeded())
+	{
+		GetStaticMeshComponent()->SetStaticMesh(StaticMeshRef.Object);
+	}
+
+	GetStaticMeshComponent()->SetDefaultCustomPrimitiveDataVector4(0, FVector4(0.0, 0.2, 0.2, 1.0));
+
+	GetStaticMeshComponent()->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
+	GetStaticMeshComponent()->SetGenerateOverlapEvents(true);
+	// Set as static object
+	GetStaticMeshComponent()->SetMobility(EComponentMobility::Static);
+
+	// Set scale
+	const FVector2D MushroomScale = FVector2D(0.3f, 0.25f);
+	GetStaticMeshComponent()->SetRelativeScale3D(FVector(1.f, 0.45f, 0.20f));
+	
+	// Set collision profile to block all
+	GetStaticMeshComponent()->SetCollisionProfileName(TEXT("OverlapAll"));
+	
+}
+
+void AM4_Mushroom::BeginPlay()
+{
+	MushLife = 2;
+	DestructionHit = 0;	
+	Super::BeginPlay();
+}
+
+void AM4_Mushroom::OnHit(UPrimitiveComponent* HitComp,AActor* OtherActor,UPrimitiveComponent* OtherComp,FVector NormalImpulse,const FHitResult& Hit) 
+{
+	
+	AM4_Projectile* Projectile = Cast<AM4_Projectile>(OtherActor);
+	if (!Projectile)
+	{
+		return; 
+	}
+	
+	if (DestructionHit++ == MushLife)
+	{
+		Destroy();	
+	}
+}

Source/M4_CPP/private/M4_PlayerPawn.cpp

@@ -1,8 +1,9 @@
 #include "M4_PlayerPawn.h"
 #include "EnhancedInputComponent.h"
 #include "M4_Gamemode.h"
+#include "M4_LOG.h"
+#include "M4_Projectile.h"
 #include "GameFramework/PlayerController.h"
-#include "Camera/CameraComponent.h"
 
 AM4_PlayerPawn::AM4_PlayerPawn()
 {
@@ -16,10 +17,16 @@ AM4_PlayerPawn::AM4_PlayerPawn()
     MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComponent"));
     MeshComponent->SetupAttachment(RootComponent);
     MeshComponent->SetMobility(EComponentMobility::Movable);
-    MeshComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
-    MeshComponent->SetCollisionProfileName(UCollisionProfile::Pawn_ProfileName);
-    MeshComponent->SetRelativeScale3D(FVector(1.0f, MeshScale.Y, MeshScale.X));
     
+    MeshComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
+    MeshComponent->SetCollisionObjectType(ECC_Pawn);
+    MeshComponent->SetCollisionResponseToAllChannels(ECR_Block);
+
+    MeshComponent->SetGenerateOverlapEvents(true);
+
+    MeshComponent->OnComponentBeginOverlap.AddDynamic(this,&AM4_PlayerPawn::OnPlayerOverlap);
+    
+    MeshComponent->SetRelativeScale3D(FVector(1.0f, MeshScale.Y, MeshScale.X));
 
     static ConstructorHelpers::FObjectFinder<UStaticMesh> DefaultMeshRef(TEXT("/Game/CTP/04_Mesh/SM_Cube.SM_Cube"));
     if (DefaultMeshRef.Succeeded())
@@ -32,12 +39,18 @@ AM4_PlayerPawn::AM4_PlayerPawn()
     {
         MoveAction = MoveActionRef.Object;
     }
+
+    static ConstructorHelpers::FObjectFinder<UInputAction> ShootActionRef(TEXT("/Game/CTP/03_Input/IA_Shoot.IA_Shoot"));
+    if (ShootActionRef.Succeeded())
+    {
+        ShootAction = ShootActionRef.Object;
+    }
 }
 
 void AM4_PlayerPawn::BeginPlay()
 {
     Super::BeginPlay();
-    SetActorLocation(FVector(0.0f, 0.0f, -400.0f));
+    SetActorLocation(FVector(-400.0f, 0.0f, -400.0f));
 }
 
 void AM4_PlayerPawn::Tick(float DeltaTime)
@@ -51,8 +64,6 @@ void AM4_PlayerPawn::Tick(float DeltaTime)
         NewLocation.Y = FMath::Clamp(NewLocation.Y, GM->Bounds.Min.Y, GM->Bounds.Max.Y);
         SetActorLocation(NewLocation);
     }
-
-    
 }
 
 void AM4_PlayerPawn::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
@@ -64,10 +75,71 @@ void AM4_PlayerPawn::SetupPlayerInputComponent(UInputComponent* PlayerInputCompo
         {
             Input->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AM4_PlayerPawn::Move);
         }
+        
+        if (ShootAction)
+        {
+            Input->BindAction(ShootAction, ETriggerEvent::Triggered, this, &AM4_PlayerPawn::Shoot);
+        }
     }
 }
 
 void AM4_PlayerPawn::Move(const FInputActionInstance& Instance)
 {
     LastMoveValue = Instance.GetValue().Get<FVector2D>().GetSafeNormal();
+}
+
+void AM4_PlayerPawn::Shoot(const FInputActionInstance& Inst)
+{
+       if (Proj) 
+        {
+            UWorld* World = GetWorld();
+
+            if (World)
+            {
+                FActorSpawnParameters SpawnParams;
+                SpawnParams.Owner = this;
+                const FVector InitialLocation = FVector(-400.f, GetActorLocation().Y, GetActorLocation().Z);
+                const FRotator InitialRotation = FRotator(0.f); 
+                AM4_Projectile* Projectile = World->SpawnActor<AM4_Projectile>(Proj, InitialLocation, InitialRotation, SpawnParams);
+                if (Projectile)
+                {
+                    Projectile->FireInDir(InitialLocation); 
+                }
+            }
+        }
+};
+
+void AM4_PlayerPawn::OnPlayerOverlap(
+    UPrimitiveComponent* OverlappedComponent,
+    AActor* OtherActor,
+    UPrimitiveComponent* OtherComp,
+    int32 OtherBodyIndex,
+    bool bFromSweep,
+    const FHitResult& SweepResult)
+{
+    if (!OtherActor || OtherActor == this || bIsInvincible)
+    {
+        return;
+    }
+
+    AM4_CentipedeBody* CentipedeSegment = Cast<AM4_CentipedeBody>(OtherActor);
+    if (CentipedeSegment)
+    {
+        UE_LOG(M4_CPP, Warning, TEXT("Player collided with Centipede Segment!"));
+
+        if (AM4_Gamemode* GM = Cast<AM4_Gamemode>(GetWorld()->GetAuthGameMode()))
+        {
+            GM->LoseLife();
+            UE_LOG(M4_CPP, Warning, TEXT("Player Lives Remaining: %d"), GM->GetLives());
+
+            bIsInvincible = true;
+            GetWorldTimerManager().SetTimer(InvincibleTimerHandle,this, &AM4_PlayerPawn::EndInvincibility, InvinciblityDuration, false);
+        }
+    }
+}
+
+void AM4_PlayerPawn::EndInvincibility()
+{
+    bIsInvincible = false;
+    UE_LOG(M4_CPP, Warning, TEXT("Player invincibility ended."));
 }

Source/M4_CPP/private/M4_Projectile.cpp

@@ -0,0 +1,108 @@
+#include "M4_Projectile.h"
+#include "Components/MeshComponent.h"
+#include "M4_Gamemode.h"
+#include "M4_Mushroom.h"
+#include "Components/SphereComponent.h"
+
+// Sets default values
+AM4_Projectile::AM4_Projectile()
+{
+    PrimaryActorTick.bCanEverTick = true;
+    
+    // Crée d'abord le composant de collision comme root
+    CollisionComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
+    CollisionComp->InitSphereRadius(15.0f);
+    CollisionComp->SetCollisionProfileName(TEXT("Projectile"));
+    CollisionComp->OnComponentBeginOverlap.AddDynamic(this, &AM4_Projectile::OnOverlap);
+	CollisionComp->SetGenerateOverlapEvents(true);
+    RootComponent = CollisionComp;
+    
+    // Ensuite attache le mesh au composant de collision
+    ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
+    ProjectileMeshComponent->SetupAttachment(RootComponent);
+    ProjectileMeshComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision); // Le mesh ne gère pas la collision
+    
+    static ConstructorHelpers::FObjectFinder<UStaticMesh> Mesh(TEXT("/Game/CTP/04_Mesh/SM_Projectile.SM_Projectile"));
+    if(Mesh.Succeeded())
+    {
+        ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
+    }
+
+    static ConstructorHelpers::FObjectFinder<UMaterial> Material(TEXT("/Game/CTP/05_Material/M_Player.M_Player"));
+    if (Material.Succeeded())
+    {
+        ProjectileMat = UMaterialInstanceDynamic::Create(Material.Object, ProjectileMeshComponent);
+    }
+
+    ProjectileMeshComponent->SetMaterial(0, ProjectileMat);       
+    ProjectileMeshComponent->SetRelativeScale3D(FVector(.3f, .3f, .35f));
+    ProjectileMeshComponent->SetMobility(EComponentMobility::Movable);
+    ProjectileMeshComponent->SetRelativeLocation(FVector::ZeroVector);
+
+    // Configure le ProjectileMovementComponent
+    ProjectileMovementComponent = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileMovementComponent"));
+    ProjectileMovementComponent->SetUpdatedComponent(CollisionComp); // Maintenant CollisionComp existe
+    ProjectileMovementComponent->InitialSpeed = 380.f;
+    ProjectileMovementComponent->MaxSpeed = 380.f;
+    ProjectileMovementComponent->bRotationFollowsVelocity = false;
+    ProjectileMovementComponent->bShouldBounce = false;
+    ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
+
+    InitialLifeSpan = 10.f; 
+}
+		///FAIRE SUPER GAFFE AUX INDENTATIONS ET LES FOR LOOPS sont à bien faire.
+		///Ce qui est critique dans notre code doit être vraiment bien mis en évidence sans être obscurci par la boucle.
+		///Gestion des pointeurs à revoir, lisibilité des fonctions critiques
+
+void AM4_Projectile::BeginPlay()
+{
+	Super::BeginPlay();
+	InitialLoc = GetActorLocation();
+}
+
+void AM4_Projectile::OnOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
+{
+	UE_LOG(LogTemp, Warning, TEXT("Projectile OVERLAP: %s"), *OtherActor->GetName());
+
+	if (!OtherActor || OtherActor == this || !OtherComp)
+	{
+		return;
+	}
+
+	AM4_Mushroom* Mushroom = Cast<AM4_Mushroom>(OtherActor);
+	if (Mushroom)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("OVERLAP MUSHROOM!"));
+			
+		FVector NormalImpulse = FVector::ZeroVector;
+		Mushroom->OnHit(OverlappedComponent, this, OtherComp, NormalImpulse, SweepResult);
+		Destroy();
+		return;
+	}
+	
+	AM4_CentipedeBody* CentipedeBody = Cast<AM4_CentipedeBody>(OtherActor);
+	if (CentipedeBody)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("OVERLAP CENTIPEDE BODY!"));
+		UM4_CentipedeController* CentipedeController = GetWorld()->GetSubsystem<UM4_CentipedeController>();
+		if (CentipedeController)
+		{
+			CentipedeController->OnSegmentHit(CentipedeBody);
+		}
+		Destroy();
+	}
+			
+}
+
+void AM4_Projectile::FireInDir(const FVector& ShootDir)
+{
+	SetActorLocation(InitialLoc);
+	ProjectileMovementComponent->Velocity.Z = -1 * ((ShootDir.Z + 380.f) * ProjectileMovementComponent->InitialSpeed);
+	ProjectileMovementComponent->Velocity.X = 0.f;
+}
+
+// Called every frame
+void AM4_Projectile::Tick(float DeltaTime)
+{
+	Super::Tick( DeltaTime);
+}

Source/M4_CPP/public/M4_CentipedeBody.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/StaticMeshActor.h"
+#include "M4_CentipedeBody.generated.h"
+
+UCLASS()
+class M4_CPP_API AM4_CentipedeBody : public AStaticMeshActor
+{
+	GENERATED_BODY()
+
+public:
+	AM4_CentipedeBody();
+
+	UPROPERTY()
+	AM4_CentipedeBody* NextBody;
+
+	UPROPERTY()
+	AM4_CentipedeBody* PreviousBody;
+
+	UPROPERTY(EditAnywhere)
+	bool bIsHead = false;
+
+	void SetAsHead(bool bHead);
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Materials")
+	UMaterialInterface* HeadMaterial;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Materials")
+	UMaterialInterface* BodyMaterial;
+};

Source/M4_CPP/public/M4_CentipedeController.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "M4_CentipedeBody.h"
+#include "Subsystems/WorldSubsystem.h"
+#include "M4_CentipedeController.generated.h"
+
+UCLASS()
+class M4_CPP_API UM4_CentipedeController : public UTickableWorldSubsystem
+{
+	GENERATED_BODY()
+
+public:
+	UM4_CentipedeController();
+
+	virtual void Initialize(FSubsystemCollectionBase& Collection) override;
+	virtual void Deinitialize() override;
+	void StartCentipede(FVector SpawnLocation);
+
+	virtual void Tick(float DeltaTime) override;
+	
+	virtual TStatId GetStatId() const override;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Centipede")
+	int32 BodyCount = 10;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Centipede")
+	float CellSize = 50.f;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Centipede")
+	float MoveInterval = 0.1f;
+    
+	UFUNCTION(BlueprintCallable, Category = "Centipede")
+	void OnSegmentHit(AM4_CentipedeBody* DestroyedSegment);
+
+private:
+	UPROPERTY()
+	TArray<AM4_CentipedeBody*> BodySegments;
+	TArray<TArray<FVector>> SegmentHistory; // Historique pour chaque segment
+	int32 MaxHistorySize = 200;
+	int8 SegmentRemainingCount = 0;
+    
+	UPROPERTY(EditAnywhere, Category = "Centipede")
+	int32 SegmentSpacing = 15; // Distance en nombre de frames entre segments
+
+	float TimeSinceLastMove = 0.f;
+	float CentipedeSpeed = 400.f;
+	bool bFirstTick = true;
+    
+	TArray<FVector> PreviousPositions;
+    
+	TMap<AM4_CentipedeBody*, FVector2D> SegmentDirections;
+
+	void SpawnCentipede();
+	void UpdateHeadStatus();
+	void SpawnMushroomsAtSegmentDeathPos(FVector Location);
+    
+	bool CheckCollision(AM4_CentipedeBody* Segment, FVector2D Direction);
+    
+	FVector2D GetSegmentDirection(AM4_CentipedeBody* Segment);
+	void SetSegmentDirection(AM4_CentipedeBody* Segment, FVector2D Direction);
+	
+	UPROPERTY()
+	class AM4_Gamemode* GM_REF_PTR;
+};

Source/M4_CPP/public/M4_Gamemode.h

@@ -4,6 +4,7 @@
 
 #include "CoreMinimal.h"
 #include "GameFramework/GameModeBase.h"
+#include "M4_CentipedeController.h"
 #include "M4_Gamemode.generated.h"
 
 /**
@@ -20,6 +21,60 @@ public:
 
 	virtual void BeginPlay() override;
 
+	/**
+	 * The movement bounds for the player pawn
+	 */
 	UPROPERTY(EditAnywhere)
 	FBox2D Bounds = FBox2D(FVector2D(-400.0f, -750.0f), FVector2D(-200.0f, 750.0f));
+
+	/**
+	 * Bounds for spawning mushrooms
+	 */
+	UPROPERTY(EditAnywhere)
+	FBox2D MushroomSpawnBounds = FBox2D(FVector2D(-300.0f, -750.0f), FVector2D(550.0f, 750.0f));
+	
+	/**
+	 * Add to the player's score
+	 * @param Amount 
+	 */
+	UFUNCTION(BlueprintCallable)
+	void AddScore(int Amount) { Score += Amount; }
+
+	/**
+	 * Get the player's current score
+	 * @return Current score
+	 */
+	UFUNCTION(BlueprintCallable)
+	int GetScore() const { return Score; }
+
+	/**
+	 * Decrease the player's lives by 1, but not below 0
+	 */
+	UFUNCTION(BlueprintCallable)
+	void LoseLife() { Lives = FMath::Max(0, Lives - 1); }
+
+	/**
+	 * Get the player's current lives
+	 * @return Current lives
+	 */
+	UFUNCTION(BlueprintCallable)
+	int GetLives() const { return Lives; }
+
+	
+private:
+
+	UPROPERTY(EditAnywhere, Category="Centipede")
+	int32 CentipedeBodyCount = 10;
+
+	UPROPERTY()
+	TObjectPtr<UM4_CentipedeController> CentipedeController;
+	
+	int Score = 0;
+	int Lives = 3;
+
+	// default mushroom count
+	int MushroomCount;
+	float CellSize = 50.f;
+
+	
 };

Source/M4_CPP/public/M4_Mushroom.h

@@ -0,0 +1,26 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/StaticMeshActor.h"
+#include "GameFramework/Pawn.h"
+#include "M4_Mushroom.generated.h"
+
+UCLASS()
+class M4_CPP_API AM4_Mushroom : public AStaticMeshActor
+{
+	GENERATED_BODY()
+
+public:
+	AM4_Mushroom();
+	
+	int MushLife;
+	int DestructionHit = 0; 
+	
+	UFUNCTION()
+	void OnHit(UPrimitiveComponent* HitComp,AActor* OtherActor, UPrimitiveComponent* OtherComp,	FVector NormalImpulse,const FHitResult& Hit);
+	
+protected:
+	virtual void BeginPlay() override;
+};

Source/M4_CPP/public/M4_PlayerPawn.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "M4_Projectile.h"
 #include "CoreMinimal.h"
 #include "GameFramework/Pawn.h"
 #include "InputAction.h"
@@ -11,6 +12,7 @@ UCLASS()
 class AM4_PlayerPawn : public APawn
 {
 	GENERATED_BODY()
+	
 public:
 	AM4_PlayerPawn();
 
@@ -18,6 +20,19 @@ public:
 	virtual void Tick(float DeltaTime) override;
 	virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;
 	void Move(const FInputActionInstance& Instance);
+	void Shoot(const FInputActionInstance& Inst);
+	    
+    UPROPERTY(VisibleAnywhere)
+  	TSubclassOf<AM4_Projectile> Proj = AM4_Projectile::StaticClass();
+
+	UFUNCTION()
+	void OnPlayerOverlap(
+		UPrimitiveComponent* OverlappedComponent,
+		AActor* OtherActor,
+		UPrimitiveComponent* OtherComp,
+		int32 OtherBodyIndex,
+		bool bFromSweep,
+		const FHitResult& SweepResult);
 
 protected:
 
@@ -27,7 +42,19 @@ protected:
 	UPROPERTY()
 	UInputAction* MoveAction;
 
+	UPROPERTY()
+	UInputAction* ShootAction;
+	
 	float MoveSpeed = 500.f;
 	FVector2D MeshScale = FVector2D(0.6f, 0.5f);
 	FVector2D LastMoveValue = FVector2D::ZeroVector;
+
+	UPROPERTY()
+	bool bIsInvincible = false;
+
+	UPROPERTY()
+	float InvinciblityDuration = 2.0f;
+
+	FTimerHandle InvincibleTimerHandle;
+	void EndInvincibility();
 };

Source/M4_CPP/public/M4_Projectile.h

@@ -0,0 +1,44 @@
+#include "GameFramework/ProjectileMovementComponent.h"
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "M4_Projectile.generated.h"
+
+class USphereComponent;
+class UMeshComponent;
+
+UCLASS()
+class M4_CPP_API AM4_Projectile : public AActor
+{
+	GENERATED_BODY()
+
+public:
+	
+	AM4_Projectile();
+
+	virtual void Tick( float DeltaTime ) override;
+	virtual void BeginPlay() override;
+	
+	bool CollisionCheck = false; 
+	FVector InitialLoc; 
+	FVector NewLoc; 
+ 
+	UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
+	USphereComponent* CollisionComp;
+	
+	UPROPERTY(VisibleAnywhere, Category = Movement)
+	UProjectileMovementComponent* ProjectileMovementComponent;
+
+	UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
+	UStaticMeshComponent* ProjectileMeshComponent;
+	
+	UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
+	UMaterialInstanceDynamic* ProjectileMat;
+
+    UFUNCTION()
+    void OnOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
+	void FireInDir(const FVector& ShootDir); 
+};
+