Zachowane obiektów przy zmianie rozmiaru okna - sfml

Question

Witam, mam taki fragment kodu mojej przyszłej gry:

Program::signals Program::game() {

	Player player(50, sf::Vector2f(m_window.getSize().x - (m_window.getSize().x / 2), 
		m_window.getSize().y - (m_window.getSize().y / 10)),
		sf::Color::Green, sf::Color::White);

	while (true) {

		sf::Event event;
		while (m_window.pollEvent(event)) {

			if (event.type == sf::Event::Closed) {
				return signals::EXIT;
			}

			if (event.type == sf::Event::Resized) {
				player.setPosition(sf::Vector2f(event.size.width - (event.size.width / 2),
					event.size.height - (event.size.height / 10)));
			}

		}

		m_window.clear(sf::Color::Black);
		m_window.draw(player);
		m_window.display();
	}

	return signals::NONE;
}

Myślę że całość nie ma większego znaczenia, np. signals to zastosowany typ wyliczeniowy w mojej strukturze gry.

Kwestia dotyczy tego fragmentu:

if (event.type == sf::Event::Resized) {
				player.setPosition(sf::Vector2f(event.size.width - (event.size.width / 2),
					event.size.height - (event.size.height / 10)));
			}

Gracz ma swoje położenie, środek ekranu w szerokości i na wysokości ok. 1/10 ekranu od dołu. Tak to wygląda na starcie:

Taki też jest konstruktor obiektu:

Player player(50, sf::Vector2f(m_window.getSize().x - (m_window.getSize().x / 2), m_window.getSize().y - (m_window.getSize().y / 10)), sf::Color::Green, sf::Color::White);

Hipotetycznie dostosowuje też położenie gracza w przypadku zmiany rozmiaru okna ( jak już pokazałem ). Jednak mimo wszystko obiekt nadal jest wtedy skalowany:

Jak widać jest podwójnie źle bo nie tylko się skaluje ale jeszcze ma dziwne położenie.

Będę bardzo wdzięczny za wyjaśnienie mi co zawaliłem ;)

Comments

Czego oczekujesz od programu? Napisz w szczegółach, co ma się dziać podczas zmiany rozmiaru okna.

---

Kod klasy Player też by się przydał.

---

@Patrycjerz

Chodzi mi o to żeby rozmieszczenie obiektu było uniwersalne dla każdego rozmiaru okna. Może dam przykład:

Odległość prawej krawędzi figury od prawej krawędzi okna wynosi 10px, teraz zmieniamy rozmiar okna ( zwężamy szerokość ):

tu część figury nawet wyszła poza obszar wyświetlania. Ale to nic... bezwarunkowo ma być 10px od prawej krawędzi okna - Zawsze, nawet jak ma być niewidoczna bo wyszła poza obszar okna.

 

To też było moim celem, podczas zmiany rozmiaru okna ponownie wyznaczam pozycje kwadratu. Jednak on mi się dalej skaluje. A nie to jest moim celem.

 

---

@Hipcio

Mogę dać ale wydaję mi się że jest to najzwyklejsza klasa dziedzicząca po sf::Drawable ( no i jeszcze jednej mojej abstrakcyjnej )

.h :

#ifndef SQUARE_H
#define SQUARE_H

#include <iostream>
#include <SFML/Graphics.hpp>

///-------------------------------------------------------------------------------------

class AbstractSquareObj : public sf::Drawable {
public:
	AbstractSquareObj(int dim, sf::Vector2f pos, sf::Color color);

	float getLeftX();
	float getRightX();
	float getUpY();
	float getDownY();
	void setPosition(sf::Vector2f pos);

	virtual void update(sf::RenderWindow& window, float deltaTime) = 0;
	virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;

	AbstractSquareObj() = delete;
	virtual ~AbstractSquareObj() = default;

protected:

	sf::RectangleShape m_square; 
};

///-------------------------------------------------------------------------------------

class Player : public AbstractSquareObj {
public:
	Player(int dim, sf::Vector2f pos, sf::Color color, sf::Color outColor);
	virtual void update(sf::RenderWindow& window, float deltaTime);

	Player() = delete;
	virtual ~Player() = default;
};

///-------------------------------------------------------------------------------------

class Opponent : public AbstractSquareObj {
public:
	Opponent(int dim, sf::Vector2f pos, sf::Color color);
	virtual void update(sf::RenderWindow& window, float deltaTime);

	Opponent() = delete;
	virtual ~Opponent() = default;
};

///-------------------------------------------------------------------------------------

#endif

.cpp :

#include <iostream>
#include <SFML/Graphics.hpp>
#include "Square.h"

///--------------------------------------AbstractSquareObj-------------------------------

AbstractSquareObj::AbstractSquareObj(int dim, sf::Vector2f pos, sf::Color color) {
	m_square.setSize(sf::Vector2f(dim, dim));
	m_square.setOrigin(m_square.getSize().x / 2, m_square.getSize().y / 2);
	m_square.setPosition(pos);
	m_square.setFillColor(color);
}

///--------------------------------------------------------------------------------------

void AbstractSquareObj::draw(sf::RenderTarget& target, sf::RenderStates states) const {
	target.draw(m_square);
}

///-------------------------------------------------------------------------------------

void  AbstractSquareObj::setPosition(sf::Vector2f pos) {
	m_square.setPosition(pos);
}

///--------------------------------------------------------------------------------------

float AbstractSquareObj::getLeftX() {
	return m_square.getPosition().x - (m_square.getSize().x / 2);
}

float AbstractSquareObj::getRightX() {
	return m_square.getPosition().x + (m_square.getSize().x / 2);
}

float AbstractSquareObj::getUpY() {
	return m_square.getPosition().y - (m_square.getSize().y / 2);
}

float AbstractSquareObj::getDownY() {
	return m_square.getPosition().y + (m_square.getSize().y / 2);
}

///----------------------------------------------Player-----------------------------

Player::Player(int dim, sf::Vector2f pos, sf::Color color, sf::Color outColor) 
	    : AbstractSquareObj(dim, pos, color) {

	m_square.setOutlineThickness(-(dim / 10));
	m_square.setOutlineColor(outColor);
}

void Player::update(sf::RenderWindow& window, float deltaTime) {

	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
		m_square.move(sf::Vector2f(-1*deltaTime, 0));
	}

	else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
		m_square.move(sf::Vector2f(1 * deltaTime, 0));
	}
}

///---------------------------------------------Opponent-------------------------------

Opponent::Opponent(int dim, sf::Vector2f pos, sf::Color color)
        : AbstractSquareObj(dim,pos,color) {
	
}

void Opponent::update(sf::RenderWindow& window, float deltaTime) {
	//...
}

///------------------------------------------------------------------------------------

 

Answer 1

Musisz zmieniać dynamicznie rozmiar widoku (sf::View). Mogłoby to wyglądać mniej więcej tak:

sf::View view = window.getDefaultView(); // poza pętlą główną gry
// ...
while (window.pollEvent(event))
{
	// ...
	if (event.type == sf::Event::Resized)
	{
		view.setSize(window.getSize().x, window.getSize().y);
		view.setCenter(DEFAULT_SIZE_X - window.getSize().x / 2, DEFAULT_SIZE_Y - window.getSize().y / 2);
		window.setView(view);
	}
}

Gdzie `DEFAULT_SIZE_X` i `DEFAULT_SIZE_Y` to domyślne rozmiary okna. Założyłem, że widok jest przyczepiony swoim prawym-dolnym rogiem.