kevinwmiller / ocs Goto Github PK

There should be a better solution to this line in the PackedArray class:
PackedArray() {elements.reserve(100000);}

Maybe add some sort of queuing system so elements are only added/removed after looping.

When running the test program, I'm getting this:
OCS_Test: Commands_Test.cc:116: void cmdtest::TEST_DESTROY_OBJECT_COMMAND(): Assertion `objManager.getTotalObjects() == 2' failed.

I checked the total number of objects, and it goes down to 1 after calling execute() on the same command twice. So it shouldn't be deleting an object with an invalid ID.

It could be an issue with PackedArray, or something else.

Allow the use of string based names to identify objects in addition to IDs. It would be optional to register a name. Ideally, you could do it on object creation, so it could be done in 1 line.

Currently, I'm managing parallel maps along with all of the ObjectManager instances for my game, and it would make sense to include this feature in OCS.

auto id = objects.createObject("Prototype");
level.registerObjectName(id, "obj1");
...
auto id = level.getObjectIdFromName("obj1");
auto comp = objects.getComponent<Position>(id);

Would become:

auto id = objects.createObject("Prototype", "obj1");
...
auto comp = objects.getComponent<Position>("obj1");

The casing style of the methods in PackedArray are inconsistent. I would propose switching everything to camelCase instead of snake_case. This would probably cause a lot of other code to have to change though.

Add support for removing, adding, assigning, etc. components using their bound string name. This will allow for better networking/file support.

Note: Could also add the ability to get components with their name, but it would have to be the base Component class reference, because you can't just change types in code on runtime.

Iterating over a few component types currently looks like this:

for (auto& velocity: objects.getComponentArray<Velocity>())
{
    auto ownerId = velocity.getOwnerID();
    auto position = objects.getComponent<Position>(ownerId);
    auto size = objects.getComponent<Size>(ownerId);
    auto aabb = objects.getComponent<AABB>(ownerId);
    if (position && size && aabb)
    {
        // Do stuff with components
    }
}

I wonder if there is an easier way that requires less typing, while still being cache efficient for the primary component type. One possible way is to integrate systems so that they process one object or tuple at a time (still keeping the order of the primary component type), and have the system manager use some filtering code and automatically call this when being updated.

A temporary solution could be to have a macro write most of the code for you:

ocs_forEachObject(Velocity, velocity, Position, position, Size, size, AABB, aabb)
{
    // Do stuff with components
}

But that would require a variadic macro that does something different for each parameter. So you'd have to have a version for each amount of parameters. And getting the curly braces right would be tricky, unless you had a "begin" and "end" for the loop.

This would be part of the ObjectManager. It would check if the component exists, add a new one if it doesn't, or set it if it does.

This would cover most use cases, since add/set won't always work depending on if the component already exists. Most of the time you'd want to just replace it.

Update: Unless you can show me use cases for "add" and "set" when there is an "assign", then you could probably remove them from the public interface.

Make binding names to component types cleaner and easier to do. One possible way is to have a static getName function for components. This way, you could optionally define getName, and inside of the registerComponent function, it would bind the name if needed.

Edit: This would probably only work if you initially added all of the components though.

Add support for safe component "handles" instead of using raw pointers to vector elements which could be invalidated. They could contain a pointer/reference to the PackedArray instance, and an ID to the element in the internal vector.

A possibly more generic solution would be to add a smart handle to PackedArray, which would contain "this" and the ID. But it would work like a normal pointer, with the * and -> operators.

Basically, just try to solve this problem:

auto obj1 = objects.createObject();
auto obj2 = objects.createObject();

objects.addComponents<Position>(obj1);
auto pos1 = object.getComponent<Position>(obj1);

objects.addComponents<Position>(obj2);
auto pos2 = object.getComponent<Position>(obj2);

pos1->x = 0; // This *could* fail, if the component array resized after adding the second component

Maybe also add things to the Wiki.

It would be great if you could update components using an object's ID, the component's name as a string, and a string to deserialize data from. It already supports binding names to components.

Also, "update" means creating a new component if it doesn't exist, and then setting the component (calling deserialize). This would be more convenient than having the user do these steps all the time.

The reason I need this feature is for the level loading code in my game. That way I can just override the components with everything in the level file, since objects will vary across levels. It would probably be useful in other cases too, such as synchronizing components/objects across a network.