ModuleSceneIntro.cpp

#include "Globals.h"
#include "Application.h"
#include <time.h>
#include "ModuleSceneIntro.h"
#include "ModulePlayer.h"
#include "ModuleAudio.h"
#include "Primitive.h"
#include "PhysBody3D.h" 

ModuleSceneIntro::ModuleSceneIntro(Application* app, bool start_enabled) : Module(app, start_enabled)
{
}

ModuleSceneIntro::~ModuleSceneIntro()
{}

// Load assets
bool ModuleSceneIntro::Start()
{
	LOG("Loading Intro assets");
	bool ret = true;
	App->audio->PlayMusic("musicandfx/song.ogg");
	Mix_VolumeMusic(volume);//15
	lvlfx = App->audio->LoadFx("musicandfx/zap2.wav");
	gamewinfx = App->audio->LoadFx("musicandfx/win.wav");
	deadfx = App->audio->LoadFx("musicandfx/dead.wav");

	//Yellow sensor that moves around, lvl8
	sensor_tricky.Size(30, 1, 15);
	pb_tricky = App->physics->AddBody(sensor_tricky, 0);
	sensor_tricky.color = Yellow;
	pb_tricky->SetPos(2010, 3, 210);
	pb_tricky->GetTransform(&sensor_tricky.transform);
	pb_tricky->SetAsSensor(true);
	pb_tricky->collision_listeners.add(this);

	 // 1 = create a path ; 2 = create a limit path; 3 = create a flag; 4 = create a slider; 
	//5 = create an obstacle; 6 = create a trap; 7 create an invisible road; 8 set the win condition; 
	//9 create the level changer; 10 create a ramp; 11 big wall; 12 end ramp; 13 clued path;
	int circuit0[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,2,2,2,
		2,2,2,1,2,2,2,
		2,2,2,10,2,2,2,
		2,2,2,12,2,2,2,
		2,2,2,1,2,2,2,
		2,2,2,10,2,2,2,
		2,2,2,2,2,2,2,
		2,2,2,9,2,2,2,
		2,2,2,2,2,2,2,
	};
	int circuit1[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,2,2,2,
		2,2,1,1,1,2,2,
		2,2,10,2,1,2,2,
		11,2,12,2,10,2,2,
		2,2,1,2,4,2,2,
		2,2,1,2,1,2,2,
		2,2,1,1,1,2,2,
		2,2,2,9,2,2,2,
		2,2,2,2,2,2,2,
	};

	int circuit2[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,2,2,2,
		2,2,1,1,1,2,2,
		2,2,1,1,1,2,2,
		11,2,13,2,6,2,2,
		2,2,1,2,1,2,2,
		2,2,1,2,1,2,2,
		2,2,1,1,1,2,2,
		2,2,2,9,2,2,2,
		2,2,2,2,2,2,2,
	};

	int circuit3[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,2,2,2,
		2,2,1,13,1,2,2,
		2,2,1,7,1,2,2,
		11,2,6,7,6,2,2,
		2,2,5,7,5,2,2,
		2,2,1,7,1,2,2,
		2,2,1,1,1,2,2,
		2,2,2,9,2,2,2,
		2,2,2,2,2,2,2,
	};

	int circuit4[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,2,2,2,
		2,2,1,1,1,2,2,
		2,7,13,2,13,7,2,
		11,7,6,2,6,7,2,
		2,7,5,2,5,7,2,
		2,2,1,2,1,2,2,
		2,2,1,1,1,2,2,
		2,2,2,9,2,2,2,
		2,2,2,2,2,2,2,
	};

	int circuit5[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,1,1,2,
		2,2,2,2,2,1,2,
		2,1,1,1,1,1,2,
		11,1,2,2,2,2,2,
		2,1,1,1,1,1,2,
		2,2,2,2,2,1,2,
		2,2,1,1,1,1,2,
		2,9,1,2,2,2,2,
		2,2,2,2,2,2,2,
	};

	int circuit6[70]{
		2,2,2,9,2,2,2,
		2,2,2,1,2,2,2,
		2,2,2,6,2,2,2,
		2,2,2,6,2,2,2,
		11,2,2,6,2,2,2,
		2,2,2,5,2,2,2,
		2,2,2,6,2,2,2,
		2,2,2,6,2,2,2,
		2,2,2,6,2,2,2,
		2,2,2,2,2,2,2,
	};
	int circuit7[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,2,2,2,
		2,7,7,1,2,2,2,
		2,7,2,10,2,2,2,
		11,1,1,1,2,2,2,
		2,5,2,2,2,2,2,
		2,1,1,1,1,1,2,
		2,2,2,7,2,10,2,
		2,9,1,1,1,5,2,
		2,2,2,2,2,2,2,
	};
	int circuit8[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,15,15,2,
		2,15,15,15,15,15,2,
		2,15,15,15,15,15,2,
		11,15,15,15,15,15,2,
		2,15,15,15,15,15,2,
		2,15,15,15,15,15,2,
		2,15,15,15,15,15,2,
		2,15,15,15,15,15,2,
		2,2,2,2,2,2,2,
	};

	int circuit9[70]{
		2,2,2,2,2,2,2,
		2,2,2,1,2,2,2,
		2,2,2,14,7,7,2,
		2,2,2,6,6,1,2,
		11,2,2,2,2,1,2,
		2,1,1,1,2,10,2,
		2,10,2,5,4,4,2,
		2,12,2,1,1,2,2,
		2,8,2,2,2,2,2,
		2,2,2,2,2,2,2,
	};
	//load circuit, only for 7-column circuits
	for (int i = 0; i < 10; ++i)
	{
		if (i == 0)
			LoadCircuit(circuit, circuit0, i);
		if (i == 1)
			LoadCircuit(circuit, circuit1, i);
		if (i == 2)
			LoadCircuit(circuit, circuit2, i);
		if (i == 3)
			LoadCircuit(circuit, circuit3, i);
		if (i == 4)
			LoadCircuit(circuit, circuit4, i);
		if (i == 5)
			LoadCircuit(circuit, circuit5, i);
		if (i == 6)
			LoadCircuit(circuit, circuit6, i);
		if (i == 7)
			LoadCircuit(circuit, circuit7, i);
		if (i == 8)
			LoadCircuit(circuit, circuit8, i);
		if (i == 9)
			LoadCircuit(circuit, circuit9, i);
	}
	App->camera->Move(vec3(1.0f, 1.0f, 0.0f));
	App->camera->LookAt(vec3(0, 0, 0));
	lvltime.Start();
	srand(time(NULL));
	return ret;
}

// Load assets
bool ModuleSceneIntro::CleanUp()
{
	LOG("Unloading Intro scene");
	return true;
}

// Update
update_status ModuleSceneIntro::Update(float dt)
{
	
	PaintingAndManaging();
	//The player has 30 seconds until the game gives a clue
	if (lvltime.Read() / 1000 >= 30)
	{
		App->player->clue = true;
	}
	//If the player doesnt arrive in time the level will restart
	if (App->player->Nmap == 7)
	{
		if (run == true)
		{
			timetrial.Start();
			run = false;
		}
		if (timetrial.Read() / 1000 == 18 && win == true)
		{

			App->player->Restart(7);
		}
	}
	if (App->player->Nmap == 8)
	{
		if (trick == true)
		{
			changing.Start();
			trick = false;
		}
		if (changing.Read() / 1000 == 3)
		{
			randomize = rand() % 37;
			sensor_tricky.SetPos(p[randomize].x, 3, p[randomize].y);
			pb_tricky->SetTransform(&sensor_tricky.transform);
			trick = true;
		}
		
	}
	return UPDATE_CONTINUE;
}

void ModuleSceneIntro::OnCollision(PhysBody3D* body1, PhysBody3D* body2)
{
	//Victory of the game sensor

	if ((body1 == pb_victory) && (body2 == (PhysBody3D*)App->player->vehicle) || (body2 == pb_victory) && (body2 == (PhysBody3D*)App->player->vehicle))
	{
		if (win)
		{
			Mix_VolumeMusic(0);
			App->audio->PlayFx(gamewinfx);
			App->player->playerTime.Stop();
			reset.Start();
			win = false;
			App->player->controls = false;
			App->player->reset = 10;
			if (App->input->GetKey(SDL_SCANCODE_R) != KEY_DOWN)
			{
				App->player->Stop();
			}
		}	
		if (reset.Read() >= 5000)
		{
			App->player->Nmap = 0;
			App->player->WinAchieved();
		}

	}
	if ((body1 == pb_tricky) && (body2 == (PhysBody3D*)App->player->vehicle) || (body2 == pb_tricky) && (body2 == (PhysBody3D*)App->player->vehicle))
	{
		App->audio->PlayFx(lvlfx);
		lvltime.Start();
		App->player->reset++;
		App->player->Nmap++;
		App->player->Restart(App->player->Nmap);
		count++;
	}

	//Map limits sensors
	for (int i = 0; i < s_limits.Count(); i++)
	{
		if ((body1 == pb_limits[i]) && (body2 == (PhysBody3D*)App->player->vehicle) && win == true || (body2 == pb_limits[i]) && (body1 == (PhysBody3D*)App->player->vehicle) && win == true)
		{
			App->audio->PlayFx(deadfx);
			App->player->Restart(App->player->Nmap);

		}
	}
	//Level changer sensors
	for (int i = 0; i < s_endlvl.Count(); i++)
	{
		if ((body1 == pb_endlvl[i]) && (body2 == (PhysBody3D*)App->player->vehicle) || (body2 == pb_endlvl[i]) && (body1 == (PhysBody3D*)App->player->vehicle))
		{
			if (count == 0)
			{
				App->audio->PlayFx(lvlfx);
				lvltime.Start();
				App->player->reset++;
				App->player->Nmap++;
				App->player->Restart(App->player->Nmap);
				count++;
			}
		}
	}
	
}
void ModuleSceneIntro::CreateFloor(vec3 scale, int posX, int posZ, int cir)
{
	Cube cubes;
	PhysBody3D* pb_cube;

	Cube cubes2;
	PhysBody3D* pb_cube2;
	

	switch (cir)
	{
	case 1:
		//Floor
		cubes.Size(scale.x, scale.y, scale.z);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		
		break;
	case 2:
		//Limit
		cubes2.Size(scale.x, scale.y, scale.z);
		s_limits.PushBack(cubes2);
		pb_cube2 = App->physics->AddBody(cubes2, 0);
		pb_cube2->SetPos(posX, 1, posZ);
		pb_limits.PushBack(pb_cube2);		
		break;
	case 3:	
		//Flag
		LOG("%i, %i", posX, posZ);
		break;
	case 4:
		//Limit
		cubes2.Size(scale.x, scale.y, scale.z);
		s_limits.PushBack(cubes2);
		pb_cube2 = App->physics->AddBody(cubes2, 0);
		pb_cube2->SetPos(posX, 1, posZ);
		pb_limits.PushBack(pb_cube2);
		//Slider
		cubes.Size(scale.x, 8, scale.y);
		/*cubes.color = Green;*/
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 100);
	
		pb_cube->SetPos(posX, 14.5, posZ);
		App->physics->AddConstraintSlider(*pb_cube, false);
		pb_cube->sliders = true;
		pb_cube->paiting = true;
		pb_cube->clued = true;
		pb_cubes.PushBack(pb_cube);
		break;
	case 5:
		
		//Floor
		cubes.Size(scale.x, scale.y, scale.z);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX,1, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);

		//Obstacle
		cubes.Size(15, 8, 2);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 3, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		break;

	case 6:
		//floor
		cubes.Size(scale.x, scale.y, scale.z);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cubes.PushBack(pb_cube);

		//limit
		cubes2.Size(scale.x, scale.y, scale.z);
		s_limits.PushBack(cubes2);
		pb_cube2 = App->physics->AddBody(cubes2, 0);
		pb_cube2->SetPos(posX, 1.1, posZ);
		pb_cube->paiting = true;
		pb_limits.PushBack(pb_cube2);
		break;

	case 7:
		//invisible floor
		cubes.Size(scale.x, scale.y, scale.z);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = false;
		pb_cubes.PushBack(pb_cube);
		break;
	case 8:
		//floor
		cubes.Size(scale.x, scale.y, scale.z);
		cubes.color = Yellow;
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		App->player->Nmap = 0;

		//victory sensor
		sensor_victory.Size(30, 1, 15);
		pb_victory = App->physics->AddBody(sensor_victory, 0);
		pb_victory->SetPos(posX, 3, posZ);
		pb_victory->GetTransform(&sensor_victory.transform);
		pb_victory->SetAsSensor(true);
		pb_victory->collision_listeners.add(this);
		break;
	case 9:

		//floor
		cubes.Size(scale.x, scale.y, scale.z);
		cubes.color = Yellow;
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);

		//change lvl
		cubes2.Size(scale.x, scale.y, scale.z);
		cubes2.color = Yellow;
		s_endlvl.PushBack(cubes2);
		pb_cube2 = App->physics->AddBody(cubes2, 0);
		pb_cube2->SetPos(posX, 3, posZ);
		pb_endlvl.PushBack(pb_cube2);


		break;

	case 10:
		//Limit
		cubes2.Size(scale.x, scale.y, scale.z);
		s_limits.PushBack(cubes2);
		pb_cube2 = App->physics->AddBody(cubes2, 0);
		pb_cube2->SetPos(posX, 1, posZ);
		pb_limits.PushBack(pb_cube2);

		//ramp begin
		cubes.Size(scale.x, scale.y, scale.z-15);
		cubes.SetRotation(-15, vec3(1, 0, 0));
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 3, posZ-10);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		break;

	case 11:
		//Big Wall
		cubes.Size(1, 100, 500);
		cubes.color = Black;
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);

		break;

	case 12:
		//Limit
		cubes2.Size(scale.x, scale.y, scale.z);
		s_limits.PushBack(cubes2);
		pb_cube2 = App->physics->AddBody(cubes2, 0);
		pb_cube2->SetPos(posX, 1, posZ);
		pb_limits.PushBack(pb_cube2);

		//ramp end
		cubes.Size(scale.x, scale.y, scale.z-15);
		cubes.SetRotation(10, vec3(1, 0, 0));
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 3, posZ+10);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		break;
	case 13:
		//Clued floor
		cubes.Size(scale.x, scale.y, scale.z);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = true;
		pb_cube->clued = true;
		pb_cubes.PushBack(pb_cube);
		break;
	case 14:
		//Floor
		cubes.Size(scale.x, scale.y, scale.z);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		//ramp begin
		cubes.Size(scale.x, scale.y, scale.z - 15);
		cubes.SetRotation(-15, vec3(1, 0, 0));
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 3, posZ - 10);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		break;
	case 15:
		//Floor
		cubes.Size(scale.x, scale.y, scale.z);
		s_cubes.PushBack(cubes);
		pb_cube = App->physics->AddBody(cubes, 0);
		pb_cube->SetPos(posX, 1, posZ);
		pb_cube->paiting = true;
		pb_cubes.PushBack(pb_cube);
		break;
	default:
		break;
	}	
}

void ModuleSceneIntro::PaintingAndManaging()
{
	Cube* floor_cube = new Cube(5000.0f, 0.0f, 800.0f);
	floor_cube->color = Green;
	floor_cube->Render();
	
	
	sensor_tricky.Render();
	if (pb_cubes.Count() != 0 && s_cubes.Count() != 0 && s_cubes.Count() == pb_cubes.Count()) 
	{
		for (int i = 0; i < s_cubes.Count(); i++) 
		{
			pb_cubes[i]->GetTransform(&s_cubes[i].transform);

			//We paint only the cubes that we need to paint
			if(pb_cubes[i]->paiting == true)
			{
				s_cubes[i].Render();
			}
				//If the cube is a constraint slider we apply up and down an impulse
			if (pb_cubes[i]->sliders == true)
			{
				if (move)
				{
					slide.Start();
					move = false;					
				}
				if (slide.Read() <= 500)
				{
					pb_cubes[i]->GetBody()->applyCentralImpulse(btVector3(0, 800, 0));
				}
				if (slide.Read() >= 1000 && slide.Read() <= 1500)
				{
					pb_cubes[i]->GetBody()->applyCentralImpulse(btVector3(0, -800, 0));
				}
				if(slide.Read() >= 2000)
				{
					move = true;
				}
			}
			//The cubes that have the clue ability will change color when the game gives the clue
			if (pb_cubes[i]->clued == true)
			{
				if (App->player->clue == true || App->player->help == true)
				{										
						s_cubes[i].color = Green;												
				}
				else
				{
					s_cubes[i].color = White;
				}
			}
		}

	}
		delete floor_cube;
	floor_cube = nullptr;
}

int ModuleSceneIntro::Size(int * vec)
{
	int count = 0;
		for (int i = 0; vec[i] <= 15 && vec[i] >= 1; ++i)
		{
			count++;
		}
	return count;
}

void ModuleSceneIntro::LoadCircuit(int * lvlcircuit, int * circuitx, int poscircuit)
{
	// distance between circuits
	int desp = poscircuit * 8 * 30;
	
	//choosing the right circuit
	for (int i = 0; i < Size(circuitx); ++i)
	{
		lvlcircuit[i] = circuitx[i];
	}
	//create map
	for (int j = 0; j < 10; j++) {
		for (int i = 0; i < 7; i++) {
			CreateFloor(vec3(30, 1, 30), 30 * i + desp, 30 * j, circuit[(7 * j) + i]);
			if (circuit[(7 * j) + i] == 15)
			{
				p[saving].x = 30 * i + desp;
				p[saving].y = 30 * j;
				saving++;
			}
			
		}
	}
	//create sensors
	if (pb_limits.Count() != 0 && s_limits.Count() != 0 && s_limits.Count() == pb_limits.Count())
	{
		for (int i = 0; i < s_limits.Count(); i++)
		{
			pb_limits[i]->SetAsSensor(true);
			pb_limits[i]->collision_listeners.add(this);
		}

		for (int i = 0; i < s_endlvl.Count(); i++)
		{
			pb_endlvl[i]->SetAsSensor(true);
			pb_endlvl[i]->collision_listeners.add(this);
		}
	}
}

void ModuleSceneIntro::LevelSelector(int lvlnumber)
{
	lvltime.Start();
	switch (lvlnumber)
	{
	case 0:		
		App->player->reset = 0;
		App->player->Nmap = 0;		
		break;
	case 1:
		App->player->reset = 1;
		App->player->Nmap = 1;
		break;
	case 2:
		App->player->reset = 2;
		App->player->Nmap = 2;
		break;
	case 3:
		App->player->reset = 3;
		App->player->Nmap = 3;
		break;
	case 4:
		App->player->reset = 4;
		App->player->Nmap = 4;
		break;
	case 5:
		App->player->reset = 5;
		App->player->Nmap = 5;
		break;
	case 6:
		App->player->reset = 6;
		App->player->Nmap = 6;
		break;
	case 7:
		App->player->reset = 7;
		App->player->Nmap = 7;
		break;
	case 8:
		App->player->reset = 8;
		App->player->Nmap = 8;
		break;
	case 9:
		App->player->reset = 9;
		App->player->Nmap = 9;
		break;
	default:
		break;
	}
	App->player->Restart(App->player->Nmap);
}