deux trois trucs

lib/Agents/Agent.hpp

 
 	Agent();
 	Agent(PictureEnvironment* iEnvironment);
-	void loop();
+	virtual void loop();
 
-private:
-	void move();
+	virtual void move();
+	virtual void paint();
+};
+
+class RepaintAgent : public Agent
+{
+public:
+	RepaintAgent(PictureEnvironment* iEnvironment);
+	virtual void loop();
+	virtual void move();
+	virtual void paint();
 };
 
 #endif // AGENT_H

lib/Agents/Perception/Perception.hpp

 public:			 // Access specifier
 	int fWidth;	 // Attribute (int variable)
 	int fHeight; // Attribute
-	std::vector<bool> fMovements;
+	std::vector<uint32_t> fSurroundings;
 
 	Perception();
 	Perception(int iWidth, int iHeight);
+	void setXY(uint32_t iValue, int iX, int iY);
+	uint32_t getXY(int iX, int iY);
 };
 
 #endif // PERCEPTION_H

lib/Environment/PictureEnvironment.hpp

 	sf::Texture fTextureImage;
 	sf::Image fImage;
 
-	std::list<Agent> fAgents;
+	std::vector<std::unique_ptr<Agent>> fAgents;
 	std::list<Agent>::iterator fAgentsIterator;
 
 	PictureEnvironment(std::string& iFilePath, sf::RenderWindow* iWindow, util::Platform* iPlatform);
-	Perception getPerception(int iX, int iY);
+	void getPerception(Perception* ioPercept, int iX, int iY);
 	void makeAgents(int iNumber);
-	void paint(int iX, int iY, const sf::Color Color);
+	void makeRepaintAgents(int iNumber);
+	bool paint(int iX, int iY, const sf::Color Color);
+
+	uint32_t getCell(int iX, int iY);
 
 	int getWidth();
 	int getHeight();

src/Agents/Agent.cpp

 #include <Agents/Agent.hpp>
+#include <Agents/Perception/Perception.hpp>
 #include <Environment/PictureEnvironment.hpp>
 
 Agent::Agent()
 {
 }
 
+int PERCEPTION_SIZE = 2;
+
 Agent::Agent(PictureEnvironment* iEnvironment)
 {
 	//uint32_t WHITE = 0xFFFFFFFF;
 	fEnvironment = iEnvironment;
-
+	fCurrentPerception = Perception(PERCEPTION_SIZE, PERCEPTION_SIZE);
 	//fColor = sf::Color(rand() % 0xFFFFFFFFFFFF);
 	uint32_t vRand = (((double)rand() / RAND_MAX) * 0xFFFFFFFFU);
 
 
 void Agent::loop()
 {
-	fEnvironment->getPerception(fXPos, fYPos);
+	fEnvironment->getPerception(&fCurrentPerception, fXPos, fYPos);
 	move();
+	this->paint();
 }
 
-int MOVESIZE = 5;
+int MOVESIZE = 10;
 
 void Agent::move()
 {
-	fXPos += (fXPos > MOVESIZE) ? (rand() % MOVESIZE) - (MOVESIZE / 2) : MOVESIZE;
-	fYPos += (fYPos > MOVESIZE) ? (rand() % MOVESIZE) - (MOVESIZE / 2) : MOVESIZE;
-	fEnvironment->paint(fXPos, fYPos, fColor);
+	fXPos += ((double)rand() / RAND_MAX) * MOVESIZE - ((double)MOVESIZE / 2);
+	fYPos += ((double)rand() / RAND_MAX) * MOVESIZE - ((double)MOVESIZE / 2);
 }
+
+void Agent::paint()
+{
+	fEnvironment->paint(fXPos, fYPos, fColor);
+}

src/Agents/Perception/Perception.cpp

 
 Perception::Perception(int iX, int iY)
 {
-	fMovements = std::vector<bool>(iX * iY);
+	fSurroundings = std::vector<uint32_t>(iX * iY);
 	fWidth = iX;
 	fHeight = iY;
+}
+
+void Perception::setXY(uint32_t iValue, int iX, int iY)
+{
+	fSurroundings[iX * iY] = iValue;
+}
+
+uint32_t Perception::getXY(int iX, int iY)
+{
+	return fSurroundings[iX * iY];
 }

src/Agents/RepaintAgent.cpp

+#include <Agents/Agent.hpp>
+#include <Environment/PictureEnvironment.hpp>
+
+RepaintAgent::RepaintAgent(PictureEnvironment* iEnvironment) :
+	Agent(iEnvironment)
+{
+	int vWidth = fEnvironment->getWidth();
+	int vHeight = fEnvironment->getHeight();
+
+	fXPos = (((double)rand() / RAND_MAX) * vWidth);
+	fYPos = (((double)rand() / RAND_MAX) * vHeight);
+
+	fColor = sf::Color(fEnvironment->getCell(fXPos, fYPos));
+}
+
+int MOVESIZE_PAINT = 10;
+
+void RepaintAgent::move()
+{
+	double vRand = rand() % (MOVESIZE_PAINT + 1);
+	fXPos += vRand - MOVESIZE_PAINT / 2;
+	vRand = rand() % (MOVESIZE_PAINT + 1);
+	fYPos += vRand - MOVESIZE_PAINT / 2;
+}
+
+int BRUSH_SIZE_PAINT = 20;
+
+void RepaintAgent::paint()
+{
+	int vHalfBrush = BRUSH_SIZE_PAINT / 2;
+	int vXLoopIndex = fXPos - vHalfBrush;
+	int vYLoopIndex = fYPos - vHalfBrush;
+	while (vXLoopIndex < (fXPos + vHalfBrush))
+	{
+		while (vYLoopIndex < fYPos + vHalfBrush)
+		{
+			fEnvironment->paint(vXLoopIndex, vYLoopIndex, fColor);
+			vYLoopIndex++;
+		}
+		vYLoopIndex = fYPos - vHalfBrush;
+		vXLoopIndex++;
+	}
+}
+
+void RepaintAgent::loop()
+{
+	fEnvironment->getPerception(&fCurrentPerception, fXPos, fYPos);
+	move();
+	this->paint();
+}

src/Environment/PictureEnvironment.cpp

 #include <Environment/PictureEnvironment.hpp>
 
 const sf::Vector2f DEFAUMT_SIMZE = sf::Vector2f(800, 600);
-int PERCEPTION_SIZE = 4;
 
 PictureEnvironment::PictureEnvironment()
 {
 	fShape.setTexture(&fTextureImage);
 }
 
-Perception PictureEnvironment::getPerception(int iX, int iY)
+void PictureEnvironment::getPerception(Perception* ioPercept, int iX, int iY)
 {
-	Perception vPerception = Perception(PERCEPTION_SIZE, PERCEPTION_SIZE);
-	iX++;
-	iY++;
-	return vPerception;
+	int vPerceptHalfWidth = ioPercept->fWidth / 2;
+	int vPerceptHalfHeight = ioPercept->fHeight / 2;
+	int vLoopX = iX - vPerceptHalfWidth;
+	int vLoopY = iY - vPerceptHalfHeight;
+	while (vLoopX < iX + vPerceptHalfWidth)
+	{
+		vLoopX++;
+		while (vLoopY < iY + vPerceptHalfHeight)
+		{
+			if (vLoopX > 0 && vLoopX < getWidth() && vLoopY > 0 && vLoopY < getHeight())
+			{
+				ioPercept->setXY(
+					fImage.getPixel(vLoopX, vLoopY).toInteger(),
+					1,
+					1);
+			}
+			vLoopY++;
+		}
+		vLoopY = iX - vPerceptHalfHeight;
+	}
 }
 
 bool PictureEnvironment::loop()
 				fWindow->close();
 		}
 		// fAgentsIterator = fAgents.begin();
-		std::list<Agent>::iterator vAgentsIterator = fAgents.begin();
-		fAgents.begin();
+		std::vector<std::unique_ptr<Agent>>::iterator vAgentsIterator = fAgents.begin();
 		while (vAgentsIterator != fAgents.end())
 		{
-
 			//std::cout << "loop" << vAgentsIterator->fColor->toInteger() << " at " << &vAgentsIterator << "\n";
-			vAgentsIterator->loop();
+			vAgentsIterator->get()->loop();
 			vAgentsIterator++;
 		}
 		fTextureImage.loadFromImage(fImage);
 	return fImage.getSize().x;
 }
 
+uint32_t PictureEnvironment::getCell(int iX, int iy)
+{
+	return fImage.getPixel(iX, iy).toInteger();
+}
+
 void PictureEnvironment::makeAgents(int iNumber)
 {
 
-	fAgents = std::list<Agent>();
+	fAgents = std::vector<std::unique_ptr<Agent>>();
 
 	for (int i = 0; i < iNumber; i++)
 	{
-		Agent vTmpAgent = Agent(this);
-		fAgents.push_back(vTmpAgent);
-		//std::cout << "pushback" << vTmpAgent.fColor.toInteger() << " at " << &vTmpAgent << "\n"
-		//		  << " size : " << fAgents.size() << "\n";
+		fAgents.push_back(std::make_unique<Agent>(this));
 	}
-	std::list<Agent>::iterator vAgentsIterator = fAgents.begin();
-	while (vAgentsIterator != fAgents.end())
-	{
+}
 
-		//std::cout << "loop" << vAgentsIterator->fColor->toInteger() << " at " << &vAgentsIterator << "\n";
-		vAgentsIterator++;
+void PictureEnvironment::makeRepaintAgents(int iNumber)
+{
+	fAgents = std::vector<std::unique_ptr<Agent>>();
+	for (int i = 0; i < iNumber; i++)
+	{
+		fAgents.push_back(std::make_unique<RepaintAgent>(this));
 	}
 }
 
 	std::cin >> i;
 }
 
-void PictureEnvironment::paint(int iX, int iY, const sf::Color iColour)
+bool PictureEnvironment::paint(int iX, int iY, const sf::Color iColour)
 {
-	//std::cout << "juste avant : " << iX << " et " << iY;
-	fImage.setPixel(iX, iY, iColour);
+
+	bool doable = iX > 0 && iX < getWidth() && iY > 0 && iY < getHeight();
+	if (doable)
+	{
+		fImage.setPixel(iX, iY, iColour);
+	}
+	return doable;
 }

src/Main.cpp

 #if defined(_DEBUG)
 	std::cout << "Hello World!" << std::endl;
 #endif
-	std::string filepath = "C:\\Users\\VroumVroumMachine\\Pictures\\dickbutt.jpg";
+	//std::string filepath = "C:\\Users\\VroumVroumMachine\\Pictures\\dickbutt.jpg";
 	//std::string filepath = "C:\\Users\\VroumVroumMachine\\Pictures\\caisseenre.png";
+	std::string filepath = "C:\\Users\\VroumVroumMachine\\Pictures\\RepAgents\\PA315024.jpg";
 	//std::string filepath = "content/sfml.png";
 	sf::RenderWindow window;
 
 
 	PictureEnvironment vEnvironment(filepath, &window, &platform);
 
-	vEnvironment.makeAgents(1000);
+	//vEnvironment.makeAgents(100);
+	vEnvironment.makeRepaintAgents(50);
 	//int i = 0;
 	while (vEnvironment.loop())
 	{
 		;
-		usleep(30);
+		usleep(10);
 	}
 
 	//vEnvironment.displayLockInput();