Beispiel #1
0
TEST(AbilitySpawn, LoadAndAttatch)
{
	ECS::World* world = CreateWorld();
	g_world = world;
	g_networkEntityMap.clear();

	ECS::Entity* testity = world->GetEntityManager()->CreateEntity();
	world->GetGroupManager()->RegisterEntity("AbilitySpawnPoint", testity);
	RootForce::AbilitySpawnSystem* system = new RootForce::AbilitySpawnSystem(world, &g_engineContext, g_engineContext.m_resourceManager->GetWorkingDirectory());
	world->GetSystemManager()->AddSystem<RootForce::AbilitySpawnSystem>(system);
	g_engineContext.m_resourceManager->LoadScript("AbilityBall");
	g_engineContext.m_resourceManager->LoadScript("AbilitySpawnPoint");
	//Test so that loading an ability pack works
	{
		system->LoadAbilities("Fake"); //Load a fake pack, should give a logg message but no crash

		system->LoadAbilities("Standard"); //Load existing pack
	}

	{
		system->AttachComponentToPoints();

		RootForce::AbilitySpawnComponent* component = world->GetEntityManager()->GetComponent<RootForce::AbilitySpawnComponent>(testity);
		EXPECT_NE(component, nullptr); //Make sure that the component was attached correctly by checking so that it is not null
	}

	world->GetEntityManager()->RemoveAllEntitiesAndComponents();
	world->GetTagManager()->UnregisterAll();
	world->GetGroupManager()->UnregisterAll();
	g_engineContext.m_physics->RemoveAll();
	delete world;
}
Beispiel #2
0
TEST(AbilitySpawn, ProcessEmptyEntity)
{
	ECS::World* world = CreateWorld();
	g_world = world;
	g_networkEntityMap.clear();

	ECS::Entity* testity = world->GetEntityManager()->CreateEntity();
	RootForce::AbilitySpawnSystem* system = new RootForce::AbilitySpawnSystem(world, &g_engineContext, g_engineContext.m_resourceManager->GetWorkingDirectory());
	world->GetSystemManager()->AddSystem<RootForce::AbilitySpawnSystem>(system);
	// Will test that an empty entity (an entity missing the necessary components does not crash the system
	system->Process();
	world->GetEntityManager()->RemoveAllEntitiesAndComponents();
	world->GetTagManager()->UnregisterAll();
	world->GetGroupManager()->UnregisterAll();
	g_engineContext.m_physics->RemoveAll();
	delete world;
}
Beispiel #3
0
TEST(AbilitySpawn, ProcessEntity)
{
	ECS::World* world = CreateWorld();
	g_world = world;
	g_networkEntityMap.clear();

	ECS::Entity* testity = world->GetEntityManager()->CreateEntity();
	world->GetGroupManager()->RegisterEntity("AbilitySpawnPoint", testity);
	RootForce::AbilitySpawnSystem* system = new RootForce::AbilitySpawnSystem(world, &g_engineContext, g_engineContext.m_resourceManager->GetWorkingDirectory());
	world->GetSystemManager()->AddSystem<RootForce::AbilitySpawnSystem>(system);

	g_engineContext.m_resourceManager->LoadScript("AbilityBall");
	g_engineContext.m_resourceManager->LoadScript("AbilitySpawnPoint");

	system->LoadAbilities("Standard"); //Load existing pack
	system->AttachComponentToPoints();

	RootForce::Renderable* rendcomp;
	RootForce::AbilitySpawnComponent* spawncomp;

	{
		system->Process();
		rendcomp = world->GetEntityManager()->GetComponent<RootForce::Renderable>(testity);
		spawncomp = world->GetEntityManager()->GetComponent<RootForce::AbilitySpawnComponent>(testity);
		EXPECT_NE(rendcomp, nullptr); //Make sure that a new render component was created in the process since the point had no active ability

		EXPECT_NE(spawncomp->CurrentAbility.Name, ""); //Check that we got an ability to spawn, if the name is empty there is no ability
	}

	{
		spawncomp->Claimed = true;
		system->Process();
		rendcomp = world->GetEntityManager()->GetComponent<RootForce::Renderable>(testity);
		EXPECT_EQ(spawncomp->Timer, 30.0f); //Check that the timer has been set after the ability was claimed
		EXPECT_EQ(spawncomp->CurrentAbility.Name, ""); //Check that there is no ability present at the point
		EXPECT_EQ(rendcomp, nullptr); //Check that the render component has been removed correctly
	}

	world->GetEntityManager()->RemoveAllEntitiesAndComponents();
	world->GetTagManager()->UnregisterAll();
	world->GetGroupManager()->UnregisterAll();
	g_engineContext.m_physics->RemoveAll();
	delete world;
}
Beispiel #4
0
TEST(PlayerControlSystem, Process)
{
	ECS::World* world = CreateWorld();
	world->SetDelta(1.0f);
	g_world = world;
	g_networkEntityMap.clear();

	// Initialize the keybindings we need for the test(not the complete list that is normally used)
	std::vector<RootForce::Keybinding> keybindings(6);
	keybindings[0].Bindings.push_back(SDL_SCANCODE_UP);
	keybindings[0].Bindings.push_back(SDL_SCANCODE_W);
	keybindings[0].Action = RootForce::PlayerAction::MOVE_FORWARDS;
	keybindings[0].Edge = true;

	keybindings[1].Bindings.push_back(SDL_SCANCODE_DOWN);
	keybindings[1].Bindings.push_back(SDL_SCANCODE_S);
	keybindings[1].Action = RootForce::PlayerAction::MOVE_BACKWARDS;
	keybindings[1].Edge = true;

	keybindings[4].Bindings.push_back(SDL_SCANCODE_SPACE);
	keybindings[4].Action = RootForce::PlayerAction::JUMP_PRESSED;
	keybindings[4].ActionUp = RootForce::PlayerAction::JUMP_RELEASED;
	keybindings[4].Edge = true;

	keybindings[5].Bindings.push_back((SDL_Scancode)RootEngine::InputManager::MouseButton::LEFT);
	keybindings[5].Action = RootForce::PlayerAction::ACTIVATE_ABILITY_PRESSED;
	keybindings[5].ActionUp = RootForce::PlayerAction::ACTIVATE_ABILITY_RELEASED;
	keybindings[5].Edge = true;

	keybindings.push_back(RootForce::Keybinding());
	keybindings[keybindings.size()-1].Bindings.push_back(SDL_SCANCODE_1);
	keybindings[keybindings.size()-1].Action = RootForce::PlayerAction::SELECT_ABILITY1;
	keybindings[keybindings.size()-1].Edge = true;

	keybindings.push_back(RootForce::Keybinding());
	keybindings[keybindings.size()-1].Bindings.push_back(SDL_SCANCODE_2);
	keybindings[keybindings.size()-1].Action = RootForce::PlayerAction::SELECT_ABILITY2;
	keybindings[keybindings.size()-1].Edge = true;

	keybindings.push_back(RootForce::Keybinding());
	keybindings[keybindings.size()-1].Bindings.push_back(SDL_SCANCODE_3);
	keybindings[keybindings.size()-1].Action = RootForce::PlayerAction::SELECT_ABILITY3;
	keybindings[keybindings.size()-1].Edge = true;


	RootForce::PlayerControlSystem* system = new RootForce::PlayerControlSystem(world);
	system->SetInputInterface(g_engineContext.m_inputSys);
	system->SetLoggingInterface(g_engineContext.m_logger);
	system->SetPhysicsInterface(g_engineContext.m_physics);
	system->SetKeybindings(keybindings);

	// Call the OnCreate script
	g_engineContext.m_script->SetGlobalNumber("UserID", 0);
	g_engineContext.m_script->SetGlobalNumber("IsClient", true);
	g_engineContext.m_script->SetFunction(g_engineContext.m_resourceManager->LoadScript("Player"), "OnCreate");
	//g_engineContext.m_script->AddParameterUserData(testity, sizeof(ECS::Entity*), "Entity");
	g_engineContext.m_script->AddParameterNumber(0);
	g_engineContext.m_script->AddParameterNumber(RootForce::Network::ReservedActionID::CONNECT);
	g_engineContext.m_script->ExecuteScript();

	ECS::Entity* testity = world->GetTagManager()->GetEntityByTag("Player");

	RootEngine::InputManager::InputInterface* ii = g_engineContext.m_inputSys;

	RootForce::PlayerActionComponent* action = world->GetEntityManager()->GetComponent<RootForce::PlayerActionComponent>(testity);

	//Fake event to test different keys
	SDL_Event falseevent;
	falseevent.type = SDL_KEYDOWN;
	falseevent.key.repeat = false;

	//Movement test
	{
		
		falseevent.key.keysym.scancode = SDL_SCANCODE_UP;
		ii->HandleInput(falseevent);

		system->Process();

		//Pushing just forward should set movepower to 1
		EXPECT_EQ(action->MovePower, 1);

		falseevent.key.keysym.scancode = SDL_SCANCODE_DOWN;
		ii->HandleInput(falseevent);
		falseevent.key.keysym.scancode = SDL_SCANCODE_UP;
		ii->HandleInput(falseevent);

		system->Process();

		//Pushing back and forth at the same time should cancel each other out
		EXPECT_EQ(action->MovePower, 0);

		
		falseevent.key.keysym.scancode = SDL_SCANCODE_DOWN;
		ii->HandleInput(falseevent);

		system->Process();

		//We have now released the up key and should be moving backwards
		EXPECT_EQ(action->MovePower, -1);
	}


	//Jump test
	{
		falseevent.key.keysym.scancode = SDL_SCANCODE_SPACE;
		falseevent.type = SDL_KEYDOWN;
		ii->HandleInput(falseevent);

		system->Process();

		EXPECT_GT(action->JumpTime, 0);
	}

	//Orientation test
	{
		SDL_Event falseMouseEvent;
		falseMouseEvent.type = SDL_MOUSEMOTION;
		falseMouseEvent.motion.x = 5;
		falseMouseEvent.motion.y = 140;
		falseMouseEvent.motion.xrel = 5;
		falseMouseEvent.motion.yrel = 140;
		ii->HandleInput(falseMouseEvent);

		system->Process();

		EXPECT_LT(action->Angle.y, 0);
		EXPECT_GT(action->Angle.x, 0);
	}

	world->GetEntityManager()->RemoveAllEntitiesAndComponents();
	world->GetTagManager()->UnregisterAll();
	world->GetGroupManager()->UnregisterAll();
	g_engineContext.m_physics->RemoveAll();
	delete world;
}