jsais pu trop désolé

lib/Agents/Agent.hpp

 	Perception fCurrentPerception;
 	PictureEnvironment* fEnvironment;
 	sf::Color fColor;
+	int fDotSize;
+	int fMoveSize;
 	int fXPos;
 	int fYPos;
 
 	Agent();
-	Agent(PictureEnvironment* iEnvironment);
+	Agent(PictureEnvironment* iEnvironment, int iDotSize, int iMoveSize);
 	virtual void loop();
 
 	virtual void move();
 class RepaintAgent : public Agent
 {
 public:
-	RepaintAgent(PictureEnvironment* iEnvironment);
+	//list of possible movement vectors, to be used to perceive the environment
+	std::vector<std::vector<int>> fMovements;
+	std::vector<int> fValidMovementIndexes;
+	std::vector<int> fCurrentMovement;
+
+	RepaintAgent(PictureEnvironment* iEnvironment, int iDotSize, int iMoveSize);
 	virtual void loop();
 	virtual void move();
 	virtual void paint();
 };
 
+class PullPaintAgent : public RepaintAgent
+{
+public:
+	PullPaintAgent(PictureEnvironment* iEnvironment, int iDotSize, int iMoveSize);
+	virtual void loop();
+	virtual void move();
+};
+
 #endif // AGENT_H

lib/Environment/PictureEnvironment.hpp

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

src/Agents/Agent.cpp

 
 int PERCEPTION_SIZE = 2;
 
-Agent::Agent(PictureEnvironment* iEnvironment)
+Agent::Agent(PictureEnvironment* iEnvironment, int iDotSize, int iMoveSize)
 {
 	//uint32_t WHITE = 0xFFFFFFFF;
 	fEnvironment = iEnvironment;
+	fDotSize = iDotSize;
+	fMoveSize = iMoveSize;
 	fCurrentPerception = Perception(PERCEPTION_SIZE, PERCEPTION_SIZE);
 	//fColor = sf::Color(rand() % 0xFFFFFFFFFFFF);
 	uint32_t vRand = (((double)rand() / RAND_MAX) * 0xFFFFFFFFU);
 	this->paint();
 }
 
-int MOVESIZE = 10;
-
 void Agent::move()
 {
-	double vRand = rand() % (MOVESIZE + 1);
-	fXPos += vRand - MOVESIZE / 2;
-	vRand = rand() % (MOVESIZE + 1);
-	fYPos += vRand - MOVESIZE / 2;
+	double vRand = rand() % (fMoveSize + 1);
+	fXPos += vRand - fMoveSize / 2;
+	vRand = rand() % (fMoveSize + 1);
+	fYPos += vRand - fMoveSize / 2;
 }
 
 void Agent::paint()

src/Agents/PullPaintAgent.cpp

+#include <Agents/Agent.hpp>
+#include <Environment/PictureEnvironment.hpp>
+
+PullPaintAgent::PullPaintAgent(PictureEnvironment* iEnvironment, int iDotSize, int iMoveSize) :
+	RepaintAgent(iEnvironment, iDotSize, iMoveSize)
+{
+	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));
+}
+
+void PullPaintAgent::move()
+{
+	double vRand = rand() % (fMoveSize + 1);
+	fXPos += vRand - fMoveSize / 2;
+	vRand = rand() % (fMoveSize + 1);
+	fYPos += vRand - fMoveSize / 2;
+}
+
+void PullPaintAgent::loop()
+{
+	move();
+	this->paint();
+}

src/Agents/RepaintAgent.cpp

 #include <Agents/Agent.hpp>
 #include <Environment/PictureEnvironment.hpp>
 
-RepaintAgent::RepaintAgent(PictureEnvironment* iEnvironment) :
-	Agent(iEnvironment)
+RepaintAgent::RepaintAgent(PictureEnvironment* iEnvironment, int iDotSize, int iMoveSize) :
+	Agent(iEnvironment, iDotSize, iMoveSize)
 {
 	int vWidth = fEnvironment->getWidth();
 	int vHeight = fEnvironment->getHeight();
 	fYPos = (((double)rand() / RAND_MAX) * vHeight);
 
 	fColor = sf::Color(fEnvironment->getCell(fXPos, fYPos));
-}
 
-int MOVESIZE_PAINT = 10;
+	//Initalize list of possible movement vectors
+	fMovements = std::vector<std::vector<int>>();
+	fValidMovementIndexes = std::vector<int>();
+	fCurrentMovement = std::vector<int>();
+	for (int i = -fMoveSize; i <= fMoveSize; i++)
+	{
+		for (int j = -fMoveSize; j <= fMoveSize; j++)
+		{
+			fMovements.push_back({ i, j });
+		}
+	}
+}
 
 void RepaintAgent::move()
 {
-	double vRand = rand() % (MOVESIZE_PAINT + 1);
-	fXPos += vRand - MOVESIZE_PAINT / 2;
-	vRand = rand() % (MOVESIZE_PAINT + 1);
-	fYPos += vRand - MOVESIZE_PAINT / 2;
-}
+	fValidMovementIndexes.clear();
+	int tolerance = 5;
+	for (int i = 0; i < static_cast<int>(fMovements.size()); i++)
+	{
+		sf::Uint32 va = fEnvironment->getCellOriginal(fXPos + fMovements.at(i).at(0), fYPos + fMovements.at(i).at(1));
+		sf::Uint32 vb = (int)fColor.toInteger();
+		//std::cout << std::hex << va << " : " << std::hex << vb << "\n";
+		//std::cout << std::hex << (va << 8 >> 24) << " : " << (vb << 8 >> 24) << "\n";
+		//std::cout << abs((int)(va << 8 >> 24) - (int)(vb << 8 >> 24)) << "\n\n";
+		bool vcomp =
+			abs((int)(va >> 24) - (int)(vb >> 24)) <= tolerance &&			 //R
+			abs((int)(va << 8 >> 24) - (int)(vb << 8 >> 24)) <= tolerance && //G
+			abs((int)(va << 16 >> 24) - (int)(vb << 16 >> 24)) <= tolerance; //B
 
-int BRUSH_SIZE_PAINT = 20;
+		//if ((double)std::min(va, vb) / std::max(va, vb) > 0.7)
+		if (vcomp)
+		{
+			//std::cout << vcomp << "\n";
+			//std::string j;
+			//std::cin >> j;
+			fValidMovementIndexes.push_back(i);
+		}
+	}
+	if (fValidMovementIndexes.size() > 0)
+	{
+		int vRandIndex = rand() % static_cast<int>(fValidMovementIndexes.size());
+		fCurrentMovement = fMovements.at(fValidMovementIndexes.at(vRandIndex));
+		fXPos += fCurrentMovement.at(0);
+		fYPos += fCurrentMovement.at(1);
+	}
+}
 
 void RepaintAgent::paint()
 {
-	int vHalfBrush = BRUSH_SIZE_PAINT / 2;
+	int vHalfBrush = fDotSize / 2;
 	int vXLoopIndex = fXPos - vHalfBrush;
 	int vYLoopIndex = fYPos - vHalfBrush;
 	while (vXLoopIndex < (fXPos + vHalfBrush))
 
 void RepaintAgent::loop()
 {
-	fEnvironment->getPerception(&fCurrentPerception, fXPos, fYPos);
 	move();
 	this->paint();
 }

src/Environment/PictureEnvironment.cpp

 		std::cout << "\n COULDNT LOAD PICTURE\n";
 	}
 	fImage = fTextureImage.copyToImage();
+	fOriginalImage = fTextureImage.copyToImage();
 
 	//memccpy(&fFilePath, &iFilePath, *iFilePath., 10);
 	fPlatform = iPlatform;
 	fInitialSize.y = 600.0f * screenScalingFactor;
 	//fShape = sf::RectangleShape(fSize);
 	fShape = sf::RectangleShape(DEFAUMT_SIMZE);
-
+	fAgents = std::vector<std::unique_ptr<Agent>>();
 	fShape.setFillColor(sf::Color::White);
 
 	fShape.setTexture(&fTextureImage);
 	return fImage.getSize().x;
 }
 
-uint32_t PictureEnvironment::getCell(int iX, int iy)
+sf::Uint32 PictureEnvironment::getCell(int iX, int iY)
 {
-	return fImage.getPixel(iX, iy).toInteger();
+	bool doable = iX >= 0 && iX < getWidth() && iY >= 0 && iY < getHeight();
+	uint32_t v_Ret = 0;
+	if (doable)
+	{
+		v_Ret = fImage.getPixel(iX, iY).toInteger();
+	}
+	return v_Ret;
 }
 
-void PictureEnvironment::makeAgents(int iNumber)
+sf::Uint32 PictureEnvironment::getCellOriginal(int iX, int iY)
 {
+	bool doable = iX >= 0 && iX < getWidth() && iY >= 0 && iY < getHeight();
+	uint32_t v_Ret = 0;
+	if (doable)
+	{
+		v_Ret = fOriginalImage.getPixel(iX, iY).toInteger();
+	}
+	return v_Ret;
+}
 
-	fAgents = std::vector<std::unique_ptr<Agent>>();
+void PictureEnvironment::makeAgents(int iNumber, int iDotSize, int iMoveSize)
+{
+	for (int i = 0; i < iNumber; i++)
+	{
+		fAgents.push_back(std::make_unique<Agent>(this, iDotSize, iMoveSize));
+	}
+}
 
+void PictureEnvironment::makeRepaintAgents(int iNumber, int iDotSize, int iMoveSize)
+{
 	for (int i = 0; i < iNumber; i++)
 	{
-		fAgents.push_back(std::make_unique<Agent>(this));
+		fAgents.push_back(std::make_unique<RepaintAgent>(this, iDotSize, iMoveSize));
 	}
 }
 
-void PictureEnvironment::makeRepaintAgents(int iNumber)
+void PictureEnvironment::makePullPaintAgents(int iNumber, int iDotSize, int iMoveSize)
 {
-	fAgents = std::vector<std::unique_ptr<Agent>>();
 	for (int i = 0; i < iNumber; i++)
 	{
-		fAgents.push_back(std::make_unique<RepaintAgent>(this));
+		fAgents.push_back(std::make_unique<PullPaintAgent>(this, iDotSize, iMoveSize));
 	}
 }
 

src/Main.cpp

 	std::cout << "Hello World!" << std::endl;
 #endif
 	//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 = "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(10000);
-	vEnvironment.makeRepaintAgents(500);
+	//vEnvironment.makeAgents(10000, 1, 10);
+	vEnvironment.makeRepaintAgents(300, 20, 10);
+	vEnvironment.makePullPaintAgents(200, 20, 10);
 	//int i = 0;
 	while (vEnvironment.loop())
 	{