コード例 #1
0
ファイル: World.cpp プロジェクト: Rubix117/Starlight
	World::World(const int &ROWS, const int &COLS, const int &SMOOTH_LEVEL, const int &GRASS_CHANCE) :
		Map(ROWS, COLS), 
		SMOOTH_LEVEL(SMOOTH_LEVEL), 
		GRASS_CHANCE(GRASS_CHANCE)
	{	
		for(int y = 0; y < ROWS; y++)
		{
			for(int x = 0; x < COLS; x++)
			{
				Tile::TileType type = GetRandomTileType();
				At(x, y) = Tile(x, y, type);
			}
		}

		for(int i = 0; i < SMOOTH_LEVEL; i++)
		{
			if(i == SMOOTH_LEVEL - 1)
			{
				CreateBorder();
			}
			CellularAutomata();
		}

		int numDungeonsToCreate = GameMath::Random(ROWS/2, ROWS/3);
		for (int i = 0; i < numDungeonsToCreate; i++)
		{
			Vector2 newDungeonCoords;
			bool otherDungeonNear = true;

			while(otherDungeonNear)
			{
				otherDungeonNear = false;
				newDungeonCoords = *GetFreeTileCoords(COLS, ROWS);

				const int DUNGEON_PADDING = 3;
				int x = newDungeonCoords.x - DUNGEON_PADDING;
				int y = newDungeonCoords.y - DUNGEON_PADDING;
				int xMax = newDungeonCoords.x + DUNGEON_PADDING;
				int yMax = newDungeonCoords.y + DUNGEON_PADDING;

				for (; y < yMax; y++)
				{
					for (; x < xMax; x++)
					{
						if(!IsOutOfBounds(x, y) && At(x, y).type == Tile::DOOR 
							&& (x != newDungeonCoords.x && y != newDungeonCoords.y))
						{
							otherDungeonNear = true;
							break;
						}
					}
				}
			}

			At(newDungeonCoords).type = Tile::DOOR;
		}

		entryCoords = GetFreeTileCoords(COLS, ROWS);
		spawnCoords = entryCoords;
	}
コード例 #2
0
void UTerrainManager::DiscoverCave(int32 x, int32 y) {
	if (IsOutOfBounds(x, y))
		return;

	ATile* t = GetTile(x, y);
	if (!t->IsVisible)
	{
		t->IsVisible = true;
		DiscoverCave(x - 1, y);
		DiscoverCave(x + 1, y);
		DiscoverCave(x, y - 1);
		DiscoverCave(x, y + 1);
		DiscoverCave(x - 1, y + 1);
		DiscoverCave(x + 1, y + 1);
		DiscoverCave(x + 1, y - 1);
		DiscoverCave(x - 1, y - 1);
	}
	if (t->IsWall()) {
		if (UpdateWallAtTile(t))
			CollapseTile(t);
	}
	else {
		t->GetStaticMeshComponent()->SetStaticMesh(t->GroundMesh);
		t->GetStaticMeshComponent()->SetMaterial(0, this->BiomeMaterials[t->TextureIndex()]);
	}
}
コード例 #3
0
void CPFA_loop_functions::PowerLawFoodDistribution() {
  argos::Real foodOffset     = 3.0 * FoodRadius;
  size_t      foodPlaced     = 0;
  size_t      powerLawLength = 1;
  size_t      maxTrials      = 200;
  size_t      trialCount     = 0;

  std::vector<size_t> powerLawClusters;
  std::vector<size_t> clusterSides;
  argos::CVector2     placementPosition;

  for(size_t i = 0; i < PowerRank; i++) {
    powerLawClusters.push_back(powerLawLength * powerLawLength);
    powerLawLength *= 2;
  }

  for(size_t i = 0; i < PowerRank; i++) {
    powerLawLength /= 2;
    clusterSides.push_back(powerLawLength);
  }

  for(size_t h = 0; h < powerLawClusters.size(); h++) {
    for(size_t i = 0; i < powerLawClusters[h]; i++) {
      placementPosition.Set(RNG->Uniform(ForageRangeX), RNG->Uniform(ForageRangeY));

      while(IsOutOfBounds(placementPosition, clusterSides[h], clusterSides[h])) {
	trialCount++;
	placementPosition.Set(RNG->Uniform(ForageRangeX), RNG->Uniform(ForageRangeY));

	if(trialCount > maxTrials) {
	  argos::LOGERR << "PowerLawDistribution(): Max trials exceeded!\n";
	  break;
	}
      }

      for(size_t j = 0; j < clusterSides[h]; j++) {
	for(size_t k = 0; k < clusterSides[h]; k++) {
	  foodPlaced++;
	  FoodList.push_back(placementPosition);
	  FoodColoringList.push_back(argos::CColor::BLACK);
	  placementPosition.SetX(placementPosition.GetX() + foodOffset);
	}

	placementPosition.SetX(placementPosition.GetX() - (clusterSides[h] * foodOffset));
	placementPosition.SetY(placementPosition.GetY() + foodOffset);
      }
    }
  }

  FoodItemCount = foodPlaced;
}
コード例 #4
0
void CPFA_loop_functions::RandomFoodDistribution() {
  FoodList.clear();

  argos::CVector2 placementPosition;

  for(size_t i = 0; i < FoodItemCount; i++) {
    placementPosition.Set(RNG->Uniform(ForageRangeX), RNG->Uniform(ForageRangeY));

    while(IsOutOfBounds(placementPosition, 1, 1)) {
      placementPosition.Set(RNG->Uniform(ForageRangeX), RNG->Uniform(ForageRangeY));
    }

    FoodList.push_back(placementPosition);
    FoodColoringList.push_back(argos::CColor::BLACK);
  }
}
コード例 #5
0
void CPFA_loop_functions::ClusterFoodDistribution() {

  argos::Real     foodOffset  = 3.0 * FoodRadius;
  size_t          foodToPlace = NumberOfClusters * ClusterWidthX * ClusterLengthY;
  size_t          foodPlaced = 0;
  argos::CVector2 placementPosition;

  FoodItemCount = foodToPlace;

  for(size_t i = 0; i < NumberOfClusters; i++) {
    placementPosition.Set(RNG->Uniform(ForageRangeX), RNG->Uniform(ForageRangeY));

    while(IsOutOfBounds(placementPosition, ClusterLengthY, ClusterWidthX)) {
      placementPosition.Set(RNG->Uniform(ForageRangeX), RNG->Uniform(ForageRangeY));
    }

    for(size_t j = 0; j < ClusterLengthY; j++) {
      for(size_t k = 0; k < ClusterWidthX; k++) {

	foodPlaced++;
	/*
	  #include <argos3/plugins/simulator/entities/box_entity.h>

	  string label("my_box_");
	  label.push_back('0' + foodPlaced++);

	  CBoxEntity *b = new CBoxEntity(label,
	  CVector3(placementPosition.GetX(), placementPosition.GetY(), 0.0),
	  CQuaternion(),
	  true,
	  CVector3(0.1, 0.1, 0.001),
	  1.0);
	  AddEntity(*b);
	*/

	FoodList.push_back(placementPosition);
	FoodColoringList.push_back(argos::CColor::BLACK);
	placementPosition.SetX(placementPosition.GetX() + foodOffset);

      }

      placementPosition.SetX(placementPosition.GetX() - (ClusterWidthX * foodOffset));
      placementPosition.SetY(placementPosition.GetY() + foodOffset);
    }
  }
}
コード例 #6
0
ファイル: World.cpp プロジェクト: Rubix117/Starlight
	Tile::TileType World::GetAvgTileTypeAround(const int &xCoord, const int &yCoord)
	{
		int adjacentGrass = 0;
		int adjacentRocks = 0;
		int adjacentTrees = 0;

		for(int y = yCoord-1; y <= yCoord+1; y++)
		{
			for(int x = xCoord-1; x <= xCoord+1; x++)
			{
				if(IsOutOfBounds(x, y) == false)
				{
					if(At(x, y).type == Tile::GRASS) 
					{
						adjacentGrass++;
					}
					else if(At(x, y).type == Tile::ROCK)
					{
						adjacentRocks++;
					}
					else
					{
						adjacentTrees++;
					}
				}
			}
		}

		if(adjacentGrass > (adjacentRocks + adjacentTrees))
		{
			return Tile::GRASS;
		}
		else if(adjacentRocks > adjacentTrees)
		{
			return Tile::ROCK;
		}
		else
		{
			return Tile::TREE;
		}
	}
コード例 #7
0
bool UTerrainManager::IsWall(int32 x, int32 y) {
	if (IsOutOfBounds(x, y))
		return true;
	ATile* t = GetTile(x, y);
	return !t->IsVisible || t->IsWall();
}
コード例 #8
0
ATile* UTerrainManager::GetTile(int32 x, int32 y) {
	if (IsOutOfBounds(x, y))
		return nullptr;
	return Tiles[GetTerrainIndex(x, y)];
}
コード例 #9
0
void UTerrainManager::CollapseTile(ATile* t) {
	SpawnRubble(t);
	//RubbleSpawned ? .Invoke(this, new TileEventArgs(t));
	for (int x = t->X - 1; x < t->X + 2; ++x)
	{
		for (int y = t->Y - 1; y < t->Y + 2; ++y)
		{
			if (IsOutOfBounds(x, y) || (x == t->X && y == t->Y))
				continue;
			if (!GetTile(x, y)->IsVisible)
			{
				DiscoverCave(x, y);
				OnCaveDiscovered.Broadcast();
			}
			if (UpdateWallAtTile(x, y))
			{
				CollapseTile(x, y);
			}
		}
	}
	int spiders = 2;
	for (int i = 5; i < spiders; ++i)
	{
		SpawnObject(t->X, t->Y, FString("SmallSpider"));
	}
	int numberOfCrystals = 0;
	int numberOfOre = 0;
	switch (t->Cror)
	{
		//crystals
	case 1:
	case 3:
		numberOfCrystals = 1;
		break;

	case 5:
	case 7:
		numberOfCrystals = 3;
		break;

	case 9:
	case 0xB:
		numberOfCrystals = 5;
		break;

	case 0xD:
	case 0x13:
		numberOfCrystals = 11;
		break;

	case 0x11:
	case 0x17:
		numberOfCrystals = 25;
		break;

		//Ore
	case 2:
	case 4:
		numberOfOre = 1;
		break;
	case 6:
	case 8:
		numberOfOre = 3;
		break;
	case 0xA:
	case 0xC:
	case 0x10:
		numberOfOre = 5;
		break;
	case 0xE:
	case 0x14:
		numberOfOre = 11;
		break;
	case 0x12:
	case 0x18:
		numberOfOre = 25;
		break;
	}
	for (int i = 0; i < numberOfCrystals; ++i)
		SpawnObject(t->X, t->Y, FString("PowerCrystal"));
	for (int i = 0; i < numberOfOre; ++i)
		SpawnObject(t->X, t->Y, FString("Ore"));
	OnWallColapsed.Broadcast(t);
}
コード例 #10
0
bool UTerrainManager::IsTileVisible(FVector position) {
	int32 x, y;
	GetTilePosFromWorld(position, x, y);
	return !IsOutOfBounds(x, y) && GetTile(x, y)->IsVisible;
}
コード例 #11
0
void UTerrainManager::BuildTerrain(TArray<uint8>* levelData) {
	this->Tiles.SetNumZeroed(this->levelSizeX * this->levelSizeY);
	for (int x = 0; x < levelSizeX; ++x)
	{
		for (int y = 0; y < levelSizeY; ++y)
		{
			int c = GetMapFileIndex(x, y);
			uint8 surfValue = levelData[LevelFile::Surf][c];
			uint8 duggValue = levelData[LevelFile::Dugg][c];
			uint8 pathValue = 0;
			if (levelData[LevelFile::Path].Num() != 0)
				pathValue = levelData[LevelFile::Path][c];
			uint8 crorValue = 0;
			if (levelData[LevelFile::Cror].Num() != 0)
				crorValue = levelData[LevelFile::Cror][c];
			uint8 fallValue = 0;
			if (levelData[LevelFile::Fall].Num() != 0)
				fallValue = levelData[LevelFile::Fall][c];
			uint8 height = 0;
			if (levelData[LevelFile::High].Num() != 0)
				height = levelData[LevelFile::High][c];
			FVector4 heights = FVector4(height, height, height, height);


			if (levelData[LevelFile::High].Num() != 0)
			{
				if (!IsOutOfBounds(x + 1, y))
					heights.Y = levelData[LevelFile::High][GetMapFileIndex(x + 1, y)];
				if (!IsOutOfBounds(x, y + 1))
					heights.Z = levelData[LevelFile::High][GetMapFileIndex(x, y + 1)];
				if (!IsOutOfBounds(x + 1, y + 1))
					heights.W = levelData[LevelFile::High][GetMapFileIndex(x + 1, y + 1)];
			}
			FActorSpawnParameters sp;
			sp.Name = FName(TEXT("Tile"), GetTerrainIndex(x, y));
			ATile* t = pWorld->SpawnActor<ATile>(sp);
			t->SetParameters(x, y, surfValue, duggValue, pathValue, crorValue, fallValue);
			if (levelData[LevelFile::Tuto].Num() != 0)
			{
				//int tuto = levelData[LevelFile::Tuto][c];
				//if (tutoTiles.Length <= tuto)
				//{
				//	var oldTuto = tutoTiles;
				//	tutoTiles = new List<Tile>[tuto + 4];
				//	Array.Copy(oldTuto, tutoTiles, oldTuto.Length);
				//}
				//if (tutoTiles[tuto] == nullptr)
				//	tutoTiles[tuto] = new List<Tile>();
				//tutoTiles[tuto].Add(t);
			}
			this->Tiles[GetTerrainIndex(x, y)] = t;
		}
	}
	for (int x = 0; x < levelSizeX; ++x)
	{
		for (int y = 0; y < levelSizeY; ++y)
		{
			if (UpdateWallAtTile(x, y))
			{
				CollapseTile(x, y);
			}
		}
	}
}
コード例 #12
0
ファイル: Game.cpp プロジェクト: Josh-HB/EndlessRunnerShooter
void Game::Run()
{
    //TIme Step
    sf::Clock clock;
    sf::Time timeSinceLastUpdate = sf::Time::Zero;
    const sf::Time timePerFrame = sf::seconds( 1.f / 60.f );

    //main Character
    std::shared_ptr<Hero> hero = std::make_shared<Hero>(sf::Vector2f(200.f,200.f), 32.f, 1.f, *this);
    mDrawableList.push_back(hero);

    //main Platform
    std::shared_ptr<Platform> platform = std::make_shared<Platform>(1, sf::Vector2f(50.f, 500.f), 400.f, 100.f, *this);
    mDrawableList.push_back(platform);

    //main loop
    while (mWindow->isOpen())
    {
        timeSinceLastUpdate += clock.restart();

        //std::cout << 1.f / timeSinceLastUpdate.asSeconds() << "\n";

        while( timeSinceLastUpdate > timePerFrame )
        {
            timeSinceLastUpdate -= timePerFrame;

            //event loop / non-blocking
            sf::Event event;
            while (mWindow->pollEvent(event))
            {
                if (event.type == sf::Event::Closed)
                    mWindow->close();
                if(event.type == sf::Event::MouseButtonPressed)
                {
                    if(event.mouseButton.button == sf::Mouse::Left)
                        hero->Shooting();
                }
                if(event.type == sf::Event::KeyPressed)
                {
                    if(event.key.code == sf::Keyboard::Space)
                        hero->Jump();
                }
            }

            mDrawableList.insert(mDrawableList.end(), mNewDrawables.begin(), mNewDrawables.end());
            mNewDrawables.clear();
            for(std::vector<IDrawablePtr>::iterator it = mDrawableList.begin(); it != mDrawableList.end();)
            {
                (*it)->Update(timePerFrame.asSeconds(), *mWindow);
                if(IsOutOfBounds(*it))// || HasLifetimeExpired(*it, currentTime))
                {
                    it = mDrawableList.erase(it);
                }
                else
                {
                    it++;
                }
            }
        }

        mWindow->clear();
        mWindow->draw(mBgSprite);		
        for(std::vector<IDrawablePtr>::iterator it = mDrawableList.begin(); it != mDrawableList.end(); ++it)
        {
            (*it)->Draw(*mWindow);
        }
        mWindow->display();
    }
}
コード例 #13
0
void OvrScrollManager::Frame( float deltaSeconds, unsigned int controllerState )
{
	// --
	// Controller Input Handling
	bool forwardScrolling = false;
	bool backwardScrolling = false;

	if( CurrentScrollType == HORIZONTAL_SCROLL )
	{
		forwardScrolling = ( controllerState & ( BUTTON_LSTICK_RIGHT | BUTTON_DPAD_RIGHT ) ) != 0;
		backwardScrolling = ( controllerState & ( BUTTON_LSTICK_LEFT | BUTTON_DPAD_LEFT ) ) != 0;
	}
	else if( CurrentScrollType == VERTICAL_SCROLL )
	{
		forwardScrolling = ( controllerState & ( BUTTON_LSTICK_DOWN | BUTTON_DPAD_DOWN ) ) != 0;
		backwardScrolling = ( controllerState & ( BUTTON_LSTICK_UP | BUTTON_DPAD_UP ) ) != 0;
	}

	if ( forwardScrolling || backwardScrolling )
	{
		CurrentScrollState = SMOOTH_SCROLL;
	}
	SetEnableAutoForwardScrolling( forwardScrolling );
	SetEnableAutoBackwardScrolling( backwardScrolling );

	// --
	// Logic update for the current scroll state
	switch( CurrentScrollState )
	{
		case SMOOTH_SCROLL:
		{
			// Auto scroll during wrap around initiation.
			if( ( !RestrictedScrolling ) || // Either not restricted scrolling
				( RestrictedScrolling && ( TouchDirectionLocked != NO_LOCK ) ) ) // or restricted scrolling with touch direction locked
			{
				if ( TouchIsDown )
				{
					if ( ( Position < 0.0f ) || ( Position > MaxPosition ) )
					{
						// When scrolled out of bounds and touch is still down,
						// auto-scroll to initiate wrap around easily.
						float totalDistance = 0.0f;
						for ( int i = 0; i < Deltas.GetNum(); ++i )
						{
							totalDistance += Deltas[i].d;
						}

						if ( totalDistance < -EPSILON_VEL )
						{
							Velocity = -1.0f;
						}
						else if ( totalDistance > EPSILON_VEL )
						{
							Velocity = 1.0f;
						}
						else
						{
							Velocity = PrevAutoScrollVelocity;
						}
					}
					else
					{
						Velocity = 0.0f;
					}

					PrevAutoScrollVelocity = Velocity;
				}
			}

			if ( !IsScrolling() && IsOutOfBounds() )
			{
				CurrentScrollState = BOUNCE_SCROLL;
				const float bounceBackVelocity = ScrollBehavior.BounceBackVelocity;
				if ( Position < 0.0f )
				{
					Velocity = bounceBackVelocity;
				}
				else if ( Position > MaxPosition )
				{
					Velocity = -bounceBackVelocity;
				}
				Velocity = GetModifiedVelocity( Velocity );
			}
		}
		break;

		case BOUNCE_SCROLL:
		{
			if( !IsOutOfBounds() )
			{
				CurrentScrollState = SMOOTH_SCROLL;
				if( Velocity > 0.0f ) // Pulled at the beginning
				{
					Position = 0.0f;
				}
				else if( Velocity < 0.0f ) // Pulled at the end
				{
					Position = MaxPosition;
				}
				Velocity = 0.0f;
			}
		}
		break;
	}

	// --
	// Scrolling physics update
	AccumulatedDeltaTimeInSeconds += deltaSeconds;
	OVR_ASSERT( AccumulatedDeltaTimeInSeconds <= 10.0f );
	while( true )
	{
		if( AccumulatedDeltaTimeInSeconds < 0.016f )
		{
			break;
		}

		AccumulatedDeltaTimeInSeconds -= 0.016f;
		if( CurrentScrollState == SMOOTH_SCROLL || CurrentScrollState == BOUNCE_SCROLL ) // While wrap around don't slow down scrolling
		{
			Velocity -= Velocity * ScrollBehavior.FrictionPerSec * 0.016f;
			if( fabsf(Velocity) < EPSILON_VEL )
			{
				Velocity = 0.0f;
			}
		}

		Position += Velocity * 0.016f;
		if( CurrentScrollState == BOUNCE_SCROLL )
		{
			if( Velocity > 0.0f )
			{
				Position = Alg::Clamp( Position, -ScrollBehavior.Padding, MaxPosition );
			}
			else
			{
				Position = Alg::Clamp( Position, 0.0f, MaxPosition + ScrollBehavior.Padding );
			}
		}
		else
		{
			Position = Alg::Clamp( Position, -ScrollBehavior.Padding, MaxPosition + ScrollBehavior.Padding );
		}
	}
}