void GameCompleteScreen::setup(sf::View view
							   , int sheepHerded)
{
	mBackground.setPosition(view.getCenter());

	sf::Vector2f textPos(view.getCenter());

	float fontSize = mTitleText.getCharacterSize();
	textPos.y -= fontSize;
	mTitleText.setPosition(textPos);
	textPos.y += fontSize;

	mSheepStatText.setString("Sheep Herded " + std::to_string(sheepHerded));
	sf::FloatRect bounds = mSheepStatText.getLocalBounds();
	mSheepStatText.setOrigin(bounds.width / 2.f
							, 0.f);

	fontSize = mSheepStatText.getCharacterSize();
	mSheepStatText.setPosition(textPos);
	textPos.y += fontSize;

	int inc = mMenuText.at(0).getCharacterSize();

	textPos.y += inc;

	for(sf::Text& text : mMenuText)
	{
		text.setPosition(textPos);
		textPos.y += inc;
	}
}
void Map::Drawbackground(sf::View& ViewRef, E_Ground Ground)
{
	int MinX, MaxX, MinY, MaxY;
	if (WCR.inMapMaker)
	{
		MinX = (int)((WCR.MMPtr->MapMakrView.getCenter().x - (WCR.MMPtr->MapMakrView.getSize().x / 2)) / CellSize);
		MaxX = (int)((WCR.MMPtr->MapMakrView.getCenter().x + (WCR.MMPtr->MapMakrView.getSize().x / 2)) / CellSize);
		MinY = (int)((WCR.MMPtr->MapMakrView.getCenter().y - (WCR.MMPtr->MapMakrView.getSize().y / 2)) / CellSize);
		MaxY = (int)((WCR.MMPtr->MapMakrView.getCenter().y + (WCR.MMPtr->MapMakrView.getSize().y / 2)) / CellSize);
	}
	else
	{
		MinX = (int)((ViewRef.getCenter().x - ViewRef.getSize().x / 2) / CellSize);
		MaxX = (int)((ViewRef.getCenter().x + ViewRef.getSize().x / 2) / CellSize);
		MinY = (int)((ViewRef.getCenter().y - ViewRef.getSize().y / 2) / CellSize);
		MaxY = (int)((ViewRef.getCenter().y + ViewRef.getSize().y / 2) / CellSize);
	}
	WCR.LimitVariable(0, MapWidth - 1, MinX);
	WCR.LimitVariable(0, MapWidth - 1, MaxX);
	WCR.LimitVariable(0, MapHeight - 1, MinY);
	WCR.LimitVariable(0, MapHeight - 1, MaxY);
	for (int LID = 0; LID < BackgroundMatrix.size(); LID++)
	{
		if (WCR.MMPtr->OnlyShowThisLayer->IsActive() && WCR.inMapMaker && OrderedBackgroundLayers[LID] != WCR.MMPtr->curTileLayer)
			continue;//Skip, not the layer we want.
		int BL_ = BackgroundLayers[OrderedBackgroundLayers[LID]];
		if (Ground == E_vForeground)
		{
			if (BL_ >= 0)
				continue;//Not up to yet
		}
		else if (Ground == E_vMiddleground)
		{
			if (BL_ < 0)
				break;//Gone past
			if (BL_ != 0)
				continue;//Go till found.
		}
		else if (Ground == E_vBackground)
		{
			if (BL_ < 1)
				break;//Gone past
		}
		
		BL_ = OrderedBackgroundLayers[LID];
		for (int i = MinX; i <= MaxX; i++)
			for (int ii = MinY; ii <= MaxY; ii++)
			{
				if (BackgroundMatrix[BL_][i][ii].tileID != -1)//Not empty space.
				{
					WCR.MMPtr->TileSets[BackgroundMatrix[BL_][i][ii].tileSetID].Tiles[BackgroundMatrix[BL_][i][ii].tileID].setPosition(i * CellSize, ii * CellSize);
					WCR.RenderRef.draw(WCR.MMPtr->TileSets[BackgroundMatrix[BL_][i][ii].tileSetID].Tiles[BackgroundMatrix[BL_][i][ii].tileID]);
				}
			}
	}
}
Beispiel #3
0
inline bool isInsideView(const sf::View& targetView, const sf::FloatRect& boundingBox)
{
	sf::FloatRect view(targetView.getCenter().x - targetView.getSize().x / 2.f,
		targetView.getCenter().y - targetView.getSize().y / 2.f,
		targetView.getSize().x,
		targetView.getSize().y);

	view.left -= VIEW_MARGIN;
	view.top -= VIEW_MARGIN;
	view.width += 2 * VIEW_MARGIN;
	view.height += 2 * VIEW_MARGIN;
	return view.intersects(boundingBox);
}
Beispiel #4
0
void drawInViewSprites(sf::RenderWindow &window, sf::View &view,gameMap &map, std::vector< std::vector < sf::Sprite > > &sprites )
{
    int leftX = floor((view.getCenter().x - view.getSize().x/2)/(map.getTile(0).getTileDims().x));
    int rightX = ceil((view.getCenter().x + view.getSize().x/2)/(map.getTile(0).getTileDims().x));
    int upY = floor((view.getCenter().y - view.getSize().y/2)/(map.getTile(0).getTileDims().y));
    int downY = ceil((view.getCenter().y + view.getSize().y/2)/(map.getTile(0).getTileDims().y));
for(int y = upY; y<downY; y++)
{
    for(int x = leftX; x<rightX; x++)
    {
        window.draw(sprites[y][x]);
    }
}
}
Beispiel #5
0
void BonusesPanelUpdate(BonusesPanel& panel, sf::View view) {
	float view_top = view.getCenter().y - view.getSize().y / 2.f;
	float view_left = view.getCenter().x - view.getSize().x / 2.f;
	panel.sprite.setPosition(view_left + PanelXPos, view_top + PanelYPos);
	sf::FloatRect panel_box = panel.sprite.getGlobalBounds();
	float cell_x = panel_box.left + PanelLeftBorderWidth;
	float cell_y = panel_box.top + PanelTopBorderHeight;
	float delimeter = 0;
	for (size_t i = 0; i < panel.items->size(); i++) {
		if (i != 0) {
			delimeter = CellDelimeterHeight;
		}
		panel.items[0][i]->visual->sprite.setPosition(cell_x, cell_y + (CellHeight * i) + delimeter);
	}
}
Beispiel #6
0
void Interface::update(sf::View v)
{
	//Positions the text relative to the view:
	_text[CLOCK].setPosition(
		((v.getCenter().x - (v.getSize().x / 2)) + 5),  //X
		((v.getCenter().y - (v.getSize().y / 2)) + 5)); //Y

	_text[CLOCK_BESTTIME].setPosition(
		(_text[CLOCK].getPosition().x), //X
		(_text[CLOCK].getPosition().y + (_text[CLOCK].getGlobalBounds().height + 2))); //Y	

	_text[FPS].setPosition(
		((v.getCenter().x + (v.getSize().x / 2)) - (_text[FPS].getGlobalBounds().width + 5)),   //X
		((v.getCenter().y + (v.getSize().y / 2)) - (_text[FPS].getGlobalBounds().height + 5))); //Y
}
void EffectsHandler::Update(float elapsed, sf::View &view, sf::RenderWindow &rw)
{
    if (effectsList.empty())
    {
        return;
    }
    
    for (std::list<Effect>::iterator it = effectsList.begin(); it != effectsList.end(); it++)
    {
        switch (*it)
        {
            case ZoomIn:
                if (view.getSize().x > rw.getSize().x/2)
                {
                    view.setSize(view.getSize().x-(ZOOM_SPEED_X*elapsed), view.getSize().y-(ZOOM_SPEED_Y*elapsed));
                    view.setCenter(view.getCenter().x, view.getCenter().y-(ZOOM_POS_ABOVE_MIDDLE*elapsed));
                }
                else effectsList.erase(it++);
                break;
                
            case ZoomOut:
                if (view.getSize().x <= rw.getDefaultView().getSize().x &&
                    view.getSize().y <= rw.getDefaultView().getSize().y)	//seems silly to take &window just for getdefaultview.
                {
                    view.setSize(view.getSize().x+(ZOOM_SPEED_X*elapsed), view.getSize().y+(ZOOM_SPEED_Y*elapsed));
                    view.setCenter(view.getCenter().x, view.getCenter().y+(ZOOM_POS_ABOVE_MIDDLE*elapsed));
                }
                else
                {
                    effectsList.erase(it++);
                    view = rw.getDefaultView();
                }
                break;
                
            case Pause:
                totalelapsed += elapsed;
                if (totalelapsed > 1.0f)
                {
                    effectsList.erase(it++);
                    totalelapsed = 0;
                }
                break;
                
            default:
                break;
        }
    }
}
Beispiel #8
0
void Minimap::DrawTheMinimap(sf::RenderWindow& window, Game& game, sf::View view)
{
	if (ShouldBeUpdated)
	{
		UpdateTheMinimap(game.map);
		ShouldBeUpdated = false;
	}

	MinimapSprite.setPosition(sf::Vector2f(window.getSize().x - 200.f, 50.f));
	window.draw(MinimapSprite);

	MinimapBackground.setPosition(sf::Vector2f(window.getSize().x - 200.f, 50.f));
	

	window.draw(MinimapBackground);
	
	for (int j = 0; j < game.MOBs.size(); j++)
	{
		AllyMobSprite.setPosition(sf::Vector2f(game.MOBs[j]->position.x * MINIMAP_WIDTH / MAP_DIM / TEX_DIM + window.getSize().x - 200.f - 4, game.MOBs[j]->position.y * MINIMAP_WIDTH / MAP_DIM / TEX_DIM + 50.f));
		window.draw(AllyMobSprite);
	}
	for (int j = 0; j < game.structures.size(); j++)
	{
		AllyPlantSprite.setPosition(sf::Vector2f(game.structures[j].position.x * MINIMAP_WIDTH / MAP_DIM + window.getSize().x - 200.f - 4, game.structures[j].position.y * MINIMAP_WIDTH / MAP_DIM + 50.f));
		window.draw(AllyPlantSprite);
	}

	sf::Vector2f ViewSize = view.getSize();
	sf::Vector2f ViewCornerPosition = view.getCenter() - ViewSize / 2.0f;
	MinimapFOVIndicator.setPosition(ViewCornerPosition.x * MINIMAP_WIDTH / MAP_DIM / TEX_DIM + window.getSize().x - 200.f, ViewCornerPosition.y * MINIMAP_WIDTH / MAP_DIM / TEX_DIM + 50.f);
	MinimapFOVIndicator.setSize(sf::Vector2f(ViewSize.x * MINIMAP_WIDTH / MAP_DIM / TEX_DIM, ViewSize.y * MINIMAP_WIDTH / MAP_DIM / TEX_DIM));
	window.draw(MinimapFOVIndicator);

}
/* ----------------------------------------------------------------------
 * Author: Julian
 * Date: 25 March 2014
 * Description: Renders the light manager
 * ----------------------------------------------------------------------
 */
void LightManager::render(const sf::View& camera)
{
	// Set the view of the camera
	sf::Vector2f cameraPos(camera.getCenter() - sf::Vector2f(context.window->getSize() / 2u));
	context.window->setView(camera);

	// Clear the window to see light only
	//context.window->clear(sf::Color::White);

	// Clear the light texture
	lightTexture.clear();

	// Render all the lights
	for(auto&& light : lightList)
		light.render(camera, lightTexture);

	// Render the dusk color over the light texture
	sf::RectangleShape shape(sf::Vector2f(context.window->getSize()));
	shape.setFillColor(duskColor);
	lightTexture.draw(shape);

	// Render the light texture on the rest of the window with BlendMultiply!
	lightTexture.display();
	sf::Sprite sprite(lightTexture.getTexture());
	sprite.setPosition(cameraPos);
	context.window->draw(sprite, sf::BlendMultiply);
}
Beispiel #10
0
 void rysuj_tekst( sf::RenderWindow & okno, sf::String _tresc, float x, float y )
 {
     double kamera_xHud = kamera.getCenter().x - kamera.getSize().x/2;
     double kamera_yHud = kamera.getCenter().y - kamera.getSize().y/2;
     tekst.setString( _tresc );
     tekst.setPosition( kamera_xHud + x, kamera_yHud + y );
     okno.draw( tekst );
 }
Beispiel #11
0
void set_up(sf::RenderWindow& window, sf::View& view, sf::Text& winner, std::list<Cycle*>& player)
{
	sf::Vector2u size = window.getSize();
	if (size.x * 3 < size.y * 4)
	{
		view.setSize(v2f(800, (800.f * size.y) / size.x));
		window.setView(view);
	}
	else if (size.x * 3 > size.y * 4)
	{
		view.setSize(v2f((600.f * size.x) / size.y, 600.f));
		window.setView(view);
	}
	for (auto p : player)
		p->set_text_pos(view.getCenter());
	winner.setPosition(view.getCenter());
}
Beispiel #12
0
void Renderer::setView(sf::View const& view)
{
    m_renderer->setView(view);
    m_screenRect = m_renderer->getViewport(view);
    auto center = view.getCenter();
    m_screenRect.left = center.x - m_screenRect.width / 2.f;
    m_screenRect.top = center.y - m_screenRect.height / 2.f;
}
Beispiel #13
0
        sf::Vector2f getViewPosition(sf::View& view)
        {
            sf::Vector2f center = view.getCenter();

            sf::Vector2f half   = view.getSize() / 2.0f;

            return center - half;
        }
Beispiel #14
0
 void aktualizuj_hud()
 {
     aktualizuj_kamere();
     double kamera_xHud = kamera.getCenter().x - kamera.getSize().x/2;
     double kamera_yHud = kamera.getCenter().y - kamera.getSize().y/2;
     ustaw_pozycjePaskaHp( kamera_xHud+10 , kamera_yHud + 5 );
     ustaw_pozycjePaskaBonusu( kamera_xHud+30 , kamera_yHud + 440 );
     aktualizuj_timer( 1 );
 }
Beispiel #15
0
void Level::logic(sf::View& camera, unsigned int delta)
{
	// Perform actions.
	ActionInterface::logic(*this);

	// Remove all dead entities.
	for(list<Entity*>::iterator it = mDeadEntities.begin(); it != mDeadEntities.end(); it++)
		mRemoveEntity(*it);
	mDeadEntities.clear();

    // Perform all entity logic.
	for(list<Entity*>::iterator it = mEntities.begin(); it != mEntities.end(); it++)
		(*it)->logic(*this, delta);

    // If all items have been picked up, display a floating text and give a bonus.
    if(mPickups.empty() && !mPickupAward)
    {
    	addFloatingText("Level Cleared!", mPlayer.getPosition(), sf::Color::Yellow, 30);
    	distributeChangeScore(250);
    	mPickupAward = true;
    }

    // Perform floating text logic if the interval is passed.
    if(mFloatingTextTimer.getTime() >= FLOATINGTEXT_TIMER_INTERVAL)
    {
    	list<list<sf::Text>::iterator > removeList;
    	for(list<sf::Text>::iterator it = mFloatingTexts.begin(); it != mFloatingTexts.end(); ++it)
    	{
    		it->move(0, -FLOATINGTEXT_MOVE_STEP);
    		sf::Color c = it->getColor();
    		it->setColor(sf::Color(c.r, c.g, c.b, c.a - 3));
    		if(it->getColor().a == 0)
    			removeList.push_back(it);
    	}
    	for(list<list<sf::Text>::iterator >::iterator it = removeList.begin(); it != removeList.end(); ++it)
    		mFloatingTexts.erase(*it);
    	mFloatingTextTimer.start();
    }

	// Center the player on the screen.
	camera.setCenter(mPlayer.getX() + (mPlayer.getWidth() / 2), mPlayer.getY() + (mPlayer.getHeight() / 2));

	// Make sure that the camera doesn't go out of bounds.
	sf::Vector2f center = camera.getCenter(),
				 half(camera.getSize().x / 2, camera.getSize().y / 2);
	if(center.x - half.x < 0)
		center.x = half.x;
	if(center.x + half.x > mMap.getWidth())
		center.x = mMap.getWidth() - half.x;
	if(center.y - half.y < 0)
		center.y = half.y;
	if(center.y + half.y > mMap.getHeight())
		center.y = mMap.getHeight() - half.y;
	camera.setCenter(center);
}
Beispiel #16
0
CameraNode::CameraNode(sf::View &camera) :
    SceneNode(Category::Camera),
    mCamera(camera),
    mOriginalCenter(camera.getCenter()),
    mShaking(false),
    mShakingDuration(sf::Time::Zero),
    mShakingET(sf::Time::Zero),
    mSplashing(false),
    mTransparency(128.f)
{
}
Beispiel #17
0
 void credits( sf::RenderWindow & okno )
 {
     sf::RectangleShape tlo_credits;
     tlo_credits.setFillColor( sf::Color::Black );
     tlo_credits.setPosition( kamera.getCenter().x - kamera.getSize().x/2,
                              kamera.getCenter().y - kamera.getSize().y/2 );
     tlo_credits.setSize( sf::Vector2f( 640, 480 ) );
     okno.draw( tlo_credits );
     rysuj_tekst( okno, "Square War Alpha 0.9", 320, 20 );
     rysuj_tekst( okno, "Autorzy:\nOlek Szatko\nMarcin Kula\nRafal Kot", 320, 240 );
 }
Beispiel #18
0
sf::FloatRect viewRect(sf::View const& view)
{
    sf::Vector2f const viewCenter(view.getCenter());
    sf::Vector2f const viewSize(view.getSize());
    sf::FloatRect const viewRect(
        viewCenter.x - viewSize.x / 2,
        viewCenter.y - viewSize.y / 2,
        viewSize.x,
        viewSize.y);
    return viewRect;
}
Beispiel #19
0
void gridLine(sf::View view, float xSep, float ySep, sf::Color c, std::vector<sf::Vertex> &Line) {
	float Left = view.getCenter().x - view.getSize().x / 2;
	float Right = view.getCenter().x + view.getSize().x / 2;
	float Top = view.getCenter().y - view.getSize().y / 2;
	float Bottom = view.getCenter().y + view.getSize().y / 2;
	int noOfLinesX = Right / xSep - (Left - fmod(Left, xSep)) / xSep + 1;
	int noOfLinesY = Bottom / ySep - (Top - fmod(Top, ySep)) / ySep + 1;
	float x = Left - fmod(Left, xSep);
	for(int i = 0; i < noOfLinesX; i++) {
		Line.emplace_back(sf::Vector2f(x, Top), c);
		Line.emplace_back(sf::Vector2f(x, Bottom), c);
		x += xSep;
	}
	x = Top - fmod(Top, ySep);
	for(int i = 0; i < noOfLinesY; i++) {
		Line.emplace_back(sf::Vector2f(Left, x), c);
		Line.emplace_back(sf::Vector2f(Right, x), c);
		x += ySep;
	}
//	window.draw(&Line[0], Line.size(), sf::Lines);
}
Beispiel #20
0
sf::FloatRect Helper::getViewBounds(const sf::View &view)
{
    sf::FloatRect rt;
    rt.left = view.getCenter().x - view.getSize().x/2;
    rt.top  = view.getCenter().y - view.getSize().y/2;
    rt.width  = view.getSize().x;
    rt.height = view.getSize().y;

//    std::cout << "View bounds" << rt.left << " " << rt.top << " " << rt.width << " " << rt.height << std::endl;

    return rt;
}
void GamePlay::screenMovement(Player &p, sf::View &v, sf::Sprite &s) //!< screen movement function to keep in track with player
{
	//!screen move right
	if(p.getPos().getX() > v.getCenter().x + 40)v.move(2.75f,0.f);
	if(p.getPos().getX() > v.getCenter().x + 40 && p.getBuff() == 1)v.move(4.f,0.f);
	//!screen move left
	if(p.getPos().getX() < v.getCenter().x - 40)v.move(-2.75f,0.f);
	if(p.getPos().getX() < v.getCenter().x - 40  && p.getBuff() == 1)v.move(-4.f,0.f);
	//!screen move up
	if(p.getPos().getY() < v.getCenter().y + 110)v.move(0.f,-5.f);
	//!screen move down
	if(p.getPos().getY() > v.getCenter().y + 120) v.move(0.f,5.f);

	//!keeps background static
	s.setPosition(v.getCenter().x-400.f ,v.getCenter().y -300.f);

	//!keeps messages in place
	message[1].setPosition(v.getCenter().x-295.f ,v.getCenter().y -225.f);
	message[2].setPosition(v.getCenter().x+175.f ,v.getCenter().y -225.f);
	message[3].setPosition(v.getCenter().x+120.f ,v.getCenter().y -200.f);
}
Beispiel #22
0
void Tilemap::update(const sf::View& view, int margin)
{
	sf::IntRect newView((view.getCenter().x - (view.getSize().x / 2.f)) / tilesize,
						(view.getCenter().y - (view.getSize().y / 2.f)) / tilesize,
						(view.getSize().x) / tilesize,
						(view.getSize().y) / tilesize); // @TODO Handle rotations & all the shizzle because SFML.

	sf::IntRect maprect(0, 0, wid, hei);

	newView = clip(newView, maprect);

	const sf::Vector2i topleft(newView.left, newView.top),
			           bottomright(newView.left + newView.width, newView.top + newView.height);
	if (wasTilemapChanged || !vboview.contains(topleft) || !vboview.contains(bottomright)) // if a VBO update is required
	{
		vboview = sf::IntRect(newView.left - margin,
				              newView.top - margin,
				              newView.width + (margin * 2),
				              newView.height + (margin * 2));
		vboview = clip(vboview, maprect);

		vbo = buildVertexArray(vboview);
	}
}
Beispiel #23
0
void MeshScene::SetView(const sf::View& view)
{
	//we only want to do this if the aspect ratio has changed
	//to avoid unnecessary calls to tan
	const float aspect = view.getSize().x / view.getSize().y;
	if (m_camera->GetAspectRatio() != aspect)//potentially rendered moot by float comparison...
	{
		m_camera->SetAspectRatio(aspect);
		const float angle = std::tan(m_camera->GetFOV() / 2.f * 0.0174532925f);
		m_cameraZ = (static_cast<float>(view.getSize().y) / 2.f) / angle;
		m_cameraZ *= -m_sceneScale;
	}
	//set position
	m_camera->SetPosition(-view.getCenter().x * m_sceneScale,
						view.getCenter().y * m_sceneScale,
						m_cameraZ);

	//update viewport
	sf::Vector2u winSize = m_renderWindow.getSize();
	GLuint x = static_cast<GLuint>(view.getViewport().left * static_cast<float>(winSize.x));
	GLuint y = static_cast<GLuint>((1.f - view.getViewport().top) * static_cast<float>(winSize.y));
	GLuint w = static_cast<GLuint>(view.getViewport().width * static_cast<float>(winSize.x));
	GLuint h = static_cast<GLuint>(view.getViewport().height * static_cast<float>(winSize.y));

	//invert position
	y -= h;
	glViewport(x, y, w, h);

	//update directional light
	if (m_useDirectionalLight)
	{
		glm::vec3 pos = m_camera->GetPosition();
		m_directionalLight->SetPosition(-pos.x + lightPosOffset.x, -pos.y + lightPosOffset.y, directionalLightNear);
		m_directionalLight->SetTarget(-pos.x + lightTargetOffset.x, -pos.y + lightTargetOffset.y, directionalLightFar);
	}
}
Beispiel #24
0
void Wall::setType(Wall::Type type, const sf::View &view) {
    float width = abs(view.getSize().x),
            height = abs(view.getSize().y),
            x = view.getCenter().x,
            y = view.getCenter().y;

    if (type == Left) {
        setPosition(-0.5, y);
        setSize(1, height);
    } else if (type == Right) {
        setPosition(width + 0.5, y);
        setSize(1, height);
    } else if (type == Top){
        setPosition(x, height + 0.25);
        setSize(width, 0.5);
    } else if (type == Bottom) {
        setPosition(x, -0.25);
        setSize(width, 0.5);
    } else {
        _type = None;
        return ;
    }
    _type = type;
}
Beispiel #25
0
bool entity_ojectInView(tmx::MapObject& object, sf::View& view)
{
	return createRect(object.GetPosition(), object.GetSize()).intersects((createRect(view.getCenter() - view.getSize() / 1.5f, view.getSize() * 1.5f)));
}
Beispiel #26
0
sf::View updateView(sf::View view)
{
    // Calculate view movement
    int x = view.getCenter().x;
    int y = view.getCenter().y;

    float percX = gameEvents.lastMouseWindow.x / window_width;
    float percY = gameEvents.lastMouseWindow.y / window_height;

    if(gameEvents.isAHeld)
    {
        x -= SCROLL_SPEED;
    }
    else if(percX >= 0.0f && percX <= DEFAULT_SCROLL_BORDER && global_scrollBordersEnabled)
    {
        x -= SCROLL_SPEED_MODIFIER * SCROLL_SPEED;
    }

    if(gameEvents.isDHeld)
    {
        x += SCROLL_SPEED;
    }
    else if(percX >= 1.0f - DEFAULT_SCROLL_BORDER && percX <= 1.0f && global_scrollBordersEnabled)
    {
        x += SCROLL_SPEED_MODIFIER * SCROLL_SPEED;
    }

    if(gameEvents.isWHeld)
    {
        y -= SCROLL_SPEED;
    }
    else if(percY >= 0.0f && percY <= DEFAULT_SCROLL_BORDER && global_scrollBordersEnabled)
    {
        y -= SCROLL_SPEED_MODIFIER * SCROLL_SPEED;
    }

    if(gameEvents.isSHeld)
    {
        y += SCROLL_SPEED;
    }
    else if(percY >= 1.0f - DEFAULT_SCROLL_BORDER && percY <= 1.0f && global_scrollBordersEnabled)
    {
        y += SCROLL_SPEED_MODIFIER * SCROLL_SPEED;
    }

    // Check for horizontal boundaries
//    if(x < window_width/2 - BOX_SIZE/2)
//    {
//        x = window_width/2 - BOX_SIZE/2;
//    }
//
//    if(x > MAX_WORLD_WIDTH * BOX_SIZE - window_width/2 - BOX_SIZE/2)
//    {
//        x = MAX_WORLD_WIDTH * BOX_SIZE - window_width/2 - BOX_SIZE/2;
//    }

    // Check for vertical boundaries
    if(y > MAX_WORLD_HEIGHT * BOX_SIZE + GROUND_STARTING_HEIGHT - window_height/2 - BOX_SIZE/2)
    {
        y = MAX_WORLD_HEIGHT * BOX_SIZE + GROUND_STARTING_HEIGHT - window_height/2 - BOX_SIZE/2;
    }

    // 53 Blocks to the top!

    view.setCenter(x, y);
    return view;
}
void Map::DrawMap(sf::View& ViewRef)
{
	int MinX, MaxX, MinY, MaxY;
	if (WCR.inMapMaker)
	{
		MinX = (int)((WCR.MMPtr->MapMakrView.getCenter().x - (WCR.MMPtr->MapMakrView.getSize().x / 2)) / CellSize);
		MaxX = (int)((WCR.MMPtr->MapMakrView.getCenter().x + (WCR.MMPtr->MapMakrView.getSize().x / 2)) / CellSize);
		MinY = (int)((WCR.MMPtr->MapMakrView.getCenter().y - (WCR.MMPtr->MapMakrView.getSize().y / 2)) / CellSize);
		MaxY = (int)((WCR.MMPtr->MapMakrView.getCenter().y + (WCR.MMPtr->MapMakrView.getSize().y / 2)) / CellSize);
	}
	else
	{
		MinX = (int)((ViewRef.getCenter().x - ViewRef.getSize().x / 2) / CellSize);
		MaxX = (int)((ViewRef.getCenter().x + ViewRef.getSize().x / 2) / CellSize);
		MinY = (int)((ViewRef.getCenter().y - ViewRef.getSize().y / 2) / CellSize);
		MaxY = (int)((ViewRef.getCenter().y + ViewRef.getSize().y / 2) / CellSize);
	}
	WCR.LimitVariable(0, MapWidth - 1, MinX);
	WCR.LimitVariable(0, MapWidth - 1, MaxX);
	WCR.LimitVariable(0, MapHeight - 1, MinY);
	WCR.LimitVariable(0, MapHeight - 1, MaxY);
	//sf::Drawable* DrawPtr;
	for (int i = MinX; i <= MaxX; i++)
		for (int ii = MinY; ii <= MaxY; ii++)
		{
			if (MapMatrix[i][ii].tileID != -1)//Not empty space.
			{
				if (!(WCR.inMapMaker && WCR.MMPtr->HideObjectSprites->IsActive()))
				{
					WCR.MMPtr->TileSets[MapMatrix[i][ii].tileSetID].Tiles[MapMatrix[i][ii].tileID].setPosition(i * CellSize, ii * CellSize);
					WCR.RenderRef.draw(WCR.MMPtr->TileSets[MapMatrix[i][ii].tileSetID].Tiles[MapMatrix[i][ii].tileID]);
				}
				if (WCR.inMapMaker)
					if (WCR.MMPtr->viewObjectTypes)
					{
						sf::RectangleShape DrawRect;
						DrawRect.setSize(sf::Vector2f(32, 32));						
						switch (MapMatrix[i][ii].objectType)
						{
						case 0:DrawRect.setFillColor(sf::Color::White); break;//Invis
						case 1:DrawRect.setFillColor(sf::Color::Blue); break;//Solid
						case 2:DrawRect.setFillColor(sf::Color::Green); break;//Bouncy
						case 3:DrawRect.setFillColor(sf::Color::Red); break;//Death
						case 4:DrawRect.setFillColor(sf::Color::Yellow); break;//Next Level
						case 5:DrawRect.setFillColor(sf::Color::Cyan); break;//Ice
						}
						DrawRect.setFillColor(sf::Color(DrawRect.getFillColor().r, DrawRect.getFillColor().g, DrawRect.getFillColor().b, 100));
						DrawRect.setPosition(i * CellSize, ii * CellSize);
						WCR.RenderRef.draw(DrawRect);
						if (MapMatrix[i][ii].pixelPerfect)
						{
							sf::CircleShape DrawCirc;
							DrawCirc.setRadius(8);
							DrawCirc.setPosition(i * CellSize + 8, ii * CellSize + 8);
							sf::Color MyCol_ = sf::Color::Black;
							MyCol_.a = 100;
							DrawCirc.setFillColor(MyCol_);

							WCR.RenderRef.draw(DrawCirc);
						}
					}
			}
		}
}
Beispiel #28
0
bool update()
{
	sf::Event event;
	while(window->pollEvent(event)) {
		switch (event.type) {
		case sf::Event::Closed:
			return false;
		case sf::Event::KeyPressed:
			switch(event.key.code) {
			case sf::Keyboard::Up:
				camera.move(0,-1);
				break;
			case sf::Keyboard::Down:
				camera.move(0,1);
				std::cout << camera.getCenter().x;
				break;
			case sf::Keyboard::Left:
				camera.move(-1,0);
				break;
			case sf::Keyboard::Right:
				camera.move(1,0);
				break;
			case sf::Keyboard::F1:
				for(int i = 0; i<10; i++) {
					updateCreatures();
				}
				break;
			case sf::Keyboard::F2:
				for(int i = 0; i<100; i++) {
					updateCreatures();
				}
				break;
			case sf::Keyboard::F3:
				fastForward(10);
				break;
			case sf::Keyboard::F4:
				fastForward(50);
				break;
			}
			break;
		case sf::Event::MouseMoved:
			if(sf::Mouse::isButtonPressed(sf::Mouse::Button::Left)) {
				camera.move(mousepos-window->mapPixelToCoords(sf::Mouse::getPosition(),camera));
			}
			mousepos = window->mapPixelToCoords(sf::Mouse::getPosition(),camera);
			break;
		case sf::Event::MouseWheelMoved:
			if(event.mouseWheel.delta>0) {
				camera.zoom(1.15);
			} else if(event.mouseWheel.delta<0) {
				camera.zoom(0.85);
			}
			break;
		case sf::Event::MouseButtonPressed:
			if(mouseclock.getElapsedTime().asMilliseconds()<333) {
				auto center = window->mapPixelToCoords(sf::Vector2i(event.mouseButton.x,event.mouseButton.y),camera);
				camera.setCenter(center);
				camera.setSize(sf::Vector2f(SCREEN_W,SCREEN_H));
			}
			prev_click = mouseclock.restart();
			break;
		}
	}
	double ftest = 0;
	avg = 0;
	for(auto& creature: creatures) {
		creature->foodPool(food);
		creature->update();
		for(auto fd = food.begin(); fd<food.end(); fd++) {
			if(distance(creature->getPos(),*fd)<15) {
				fd = food.erase(fd);
				creature->increaseFitness(1.f);
			}
		}
		avg += creature->getFitness();
		if(creature->getFitness()>ftest) {
			ftest = creature->getFitness();
		}
	}
	pavg = avg;
	avg = avg/creatures.size();
	if(avg>bestavg) {
		best_so_far = vpop->getPopulationRef();
	} else if(avg < bestavg*0.85) {
		vpop->revertPopulation(best_so_far);
	}

	while(food.size()<FOOD_CAP) {
		food.push_back(sf::Vector2f(20 + rand() % (AREA_W-40), 10 + rand() % (AREA_H-20)));
	}

	if(counter>1) {
		counter--;
	} else {
		updateCreatures();
		counter = 60*evolution_rate;
		std::cout << "Generation: " << gen++;
		std::cout << " fittest: " << ftest;
		std::cout << " average: " << avg << std::endl;
	}
	return true;
}
void LevelLoader::render(sf::RenderWindow &window, sf::View view)
{
    sf::Texture errtexture;
    errtexture.loadFromFile("error.png");
    sf::Sprite errsprite;
    errsprite.setTexture(errtexture);
    for(int i = 0; i < width; i++) {
        for(int j = 0; j < height; j++) {
            if(map_t[i][j].getX() < view.getCenter().x + view.getSize().x/2 && map_t[i][j].getX() + tilesize > view.getCenter().x - view.getSize().x/2 && map_t[i][j].getY() < view.getCenter().y + view.getSize().y/2 && map_t[i][j].getY() + tilesize > view.getCenter().y - view.getSize().y/2) {
                int tempInt = 0;
                if(map_t[i][j].ID == 1) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 2) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 3) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 4) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 5) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 6) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 7) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 8) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                tempInt++;
                if(map_t[i][j].ID == 9) {
                    map_t[i][j].setSprite(sprites[tempInt]);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                if(map_t[i][j].ID == 0) {
                    map_t[i][j].setSprite(errsprite);
                    map_t[i][j].setPosition(i * tilesize, j * tilesize);
                }
                window.draw(map_t[i][j].getSprite());
            }
        }
    }
}
void LightDirectionEmission::render(const sf::View &view, sf::RenderTexture &lightTempTexture, sf::RenderTexture &antumbraTempTexture, const std::vector<QuadtreeOccupant*> &shapes, sf::Shader &unshadowShader, float shadowExtension) {
	lightTempTexture.setView(view);

	LightSystem::clear(lightTempTexture, sf::Color::White);

	// Mask off light shape (over-masking - mask too much, reveal penumbra/antumbra afterwards)
	for (int i = 0; i < shapes.size(); i++) {
		LightShape* pLightShape = static_cast<LightShape*>(shapes[i]);

		// Get boundaries
		std::vector<LightSystem::Penumbra> penumbras;
		std::vector<int> innerBoundaryIndices;
		std::vector<int> outerBoundaryIndices;
		std::vector<sf::Vector2f> innerBoundaryVectors;
		std::vector<sf::Vector2f> outerBoundaryVectors;

		LightSystem::getPenumbrasDirection(penumbras, innerBoundaryIndices, innerBoundaryVectors, outerBoundaryIndices, outerBoundaryVectors, pLightShape->_shape, _castDirection, _sourceRadius, _sourceDistance);

		if (innerBoundaryIndices.size() != 2 || outerBoundaryIndices.size() != 2)
			continue;

		LightSystem::clear(antumbraTempTexture, sf::Color::White);

		antumbraTempTexture.setView(view);

		sf::ConvexShape maskShape;

		float maxDist = 0.0f;

		for (int j = 0; j < pLightShape->_shape.getPointCount(); j++)
			maxDist = std::max(maxDist, vectorMagnitude(view.getCenter() - pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(j))));

		float totalShadowExtension = shadowExtension + maxDist;

		maskShape.setPointCount(4);

		maskShape.setPoint(0, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[0])));
		maskShape.setPoint(1, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[1])));
		maskShape.setPoint(2, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[1])) + vectorNormalize(innerBoundaryVectors[1]) * totalShadowExtension);
		maskShape.setPoint(3, pLightShape->_shape.getTransform().transformPoint(pLightShape->_shape.getPoint(innerBoundaryIndices[0])) + vectorNormalize(innerBoundaryVectors[0]) * totalShadowExtension);

		maskShape.setFillColor(sf::Color::Black);

		antumbraTempTexture.draw(maskShape);

		sf::VertexArray vertexArray;

		vertexArray.setPrimitiveType(sf::PrimitiveType::Triangles);

		vertexArray.resize(3);

		{
			sf::RenderStates states;
			states.blendMode = sf::BlendAdd;
			states.shader = &unshadowShader;

			// Unmask with penumbras
			for (int j = 0; j < penumbras.size(); j++) {
				unshadowShader.setParameter("lightBrightness", penumbras[j]._lightBrightness);
				unshadowShader.setParameter("darkBrightness", penumbras[j]._darkBrightness);

				vertexArray[0].position = penumbras[j]._source;
				vertexArray[1].position = penumbras[j]._source + vectorNormalize(penumbras[j]._lightEdge) * totalShadowExtension;
				vertexArray[2].position = penumbras[j]._source + vectorNormalize(penumbras[j]._darkEdge) * totalShadowExtension;

				vertexArray[0].texCoords = sf::Vector2f(0.0f, 1.0f);
				vertexArray[1].texCoords = sf::Vector2f(1.0f, 0.0f);
				vertexArray[2].texCoords = sf::Vector2f(0.0f, 0.0f);

				antumbraTempTexture.draw(vertexArray, states);
			}
		}

		antumbraTempTexture.display();

		// Multiply back to lightTempTexture
		sf::RenderStates antumbraRenderStates;
		antumbraRenderStates.blendMode = sf::BlendMultiply;

		sf::Sprite s;

		s.setTexture(antumbraTempTexture.getTexture());

		lightTempTexture.setView(lightTempTexture.getDefaultView());

		lightTempTexture.draw(s, antumbraRenderStates);

		lightTempTexture.setView(view);
	}

	for (int i = 0; i < shapes.size(); i++) {
		LightShape* pLightShape = static_cast<LightShape*>(shapes[i]);

		if (pLightShape->_renderLightOverShape) {
			pLightShape->_shape.setFillColor(sf::Color::White);

			lightTempTexture.draw(pLightShape->_shape);
		}
	}

	// Multiplicatively blend the light over the shadows
	sf::RenderStates lightRenderStates;
	lightRenderStates.blendMode = sf::BlendMultiply;

	lightTempTexture.setView(lightTempTexture.getDefaultView());

	lightTempTexture.draw(_emissionSprite, lightRenderStates);

	lightTempTexture.display();
}