For the past week I've been trying to assign specific textures to sprites in a vector array via a for loop, with both elements being called from a XML file using PugiXML. With my current code, every sprite except for the last one within the vector array appears to have a white texture incorrectly assigned to it, with only the last one within the vector array having the correct texture assigned to it.
So far, I don't see any flaws within my code, which is confusing me. If anyone happens to see an error that I don't, a reply would be greatly appreciated.
initCollisionObject Function:
void CollisionObject::initCollisionObject(std::string fileName, b2World &_world, float objectX, float objectY, float objectRotation)
{
collisionObjectString = fileName;
collisionObjectImage.loadFromFile(collisionObjectString);
collisionObjectTexture.loadFromImage(collisionObjectImage);
collisionObjectSprite.setTexture(collisionObjectTexture);
width = collisionObjectSprite.getGlobalBounds().width;
height = collisionObjectSprite.getGlobalBounds().height;
x = objectX;
y = objectY;
rotation = objectRotation;
collisionObjectSprite.setOrigin(collisionObjectSprite.getGlobalBounds().width / 2, collisionObjectSprite.getGlobalBounds().height / 2);
collisionObjectSprite.setPosition(x, y);
collisionObjectSprite.setRotation(rotation);
createStaticCollision(_world, x, y, width, height, rotation);
return;
}
for Loop:
for (xml_node collisions = doc.child("level").child("collisions").child("object"); collisions; collisions = collisions.next_sibling("object"))
{
//cout << "Iterated" << endl;
xml_attribute textureAttribute = collisions.attribute("spritesheet");
xml_attribute xPosAttribute = collisions.attribute("x");
xml_attribute yPosAttribute = collisions.attribute("y");
xml_attribute rotationAttribute = collisions.attribute("rotation");
string texture = textureAttribute.as_string();
int xPos = xPosAttribute.as_int();
int yPos = yPosAttribute.as_int();
int rotation = rotationAttribute.as_int();
collisionArray.push_back(collisionObject);
collisionArray[currentCollisionObjectIndex].initCollisionObject(texture, _world, xPos, yPos, rotation);
currentCollisionObjectIndex++;
}
Correct, collisionArray is defined using a CollisionObject class, though it doesn't use pointers as far as I can tell. The only function in that class as of now is the one I posted in the original post, initCollisionObject. The constructor of that class defines only the width, height, x, and y positions of the sprite used in that class.
How collisionArray is defined in the header file:
#ifndef Engine_h
#define Engine_h
#include <iostream>
#include <SFML\Graphics.hpp>
#include <Box2D\Box2D.h>
#include "pugixml.hpp"
#include "Collision.h"
#include "CollisionObject.h"
#include "Player.h"
#include "Enemy.h"
#include "Lighting.h"
using namespace std;
using namespace sf;
using namespace pugi;
class Engine
{
public:
Engine();
~Engine();
void init(sf::RenderWindow &_window, b2World &_world);
void run(sf::RenderWindow &_window, b2World &_world);
void keyEvents(sf::RenderWindow &_window);
void physics(sf::RenderWindow &_window, sf::RenderTexture& _texture, b2World &_world);
void rayCast(sf::RenderWindow& _window, b2World* _world);
private:
Collision collision;
CollisionObject collisionObject;
Player player;
Enemy enemy;
Lighting lighting;
vector<CollisionObject> collisionArray;
int currentCollisionObjectIndex;
int cameraX;
int cameraY;
float closestFraction;
b2Vec2 p1;
b2Vec2 p2;
b2Vec2 intersectionPoint;
xml_document doc;
};
#endif
Sorry for restarting this topic, but I don't think I quite understand how copy constructors work in this type of scenario. Applying one automatically returns a runtime error at the point where the sprites are drawn. I know I'm most likely missing something, but I don't know what it is. Otherwise, I probably just have the entire concept wrong at this point.
Header file:
CollisionObject(const CollisionObject &_collisionObject);
CollisionObject &operator= (const CollisionObject &_collisionObject);
C++ file:
CollisionObject::CollisionObject(const CollisionObject &_collisionObject)
{
collisionObjectString = _collisionObject.collisionObjectString;
cout << "True" << endl;
}
CollisionObject &CollisionObject::operator= (const CollisionObject &_collisionObject)
{
if (this == &_collisionObject)
return *this;
collisionObjectString = _collisionObject.collisionObjectString;
return *this;
}