bitbrain / chunx Goto Github PK

Sometimes a ConcurrentModificationException rises when loading/saving entities.

When fetching the writer and loader of a chunk system before starting the system, a NullPointerException occurs.

Write tests and implement utility classes like:

• MatrixList
• Interpreter
• Iterator

It's currently possible to add entities to a single chunk which bounds doesn't match to the entitiy.

For instance: Chunk has bounds of 200,200 | 400, 400

Now it shouldn't be possible to add an entity at position 900,900, because this point is outside of the chunk.

Create a handler in order to handle chunks. Furthermore, ChunkSaver and ChunkLoader have to be moved to the new handler.

Write a proper implementation of the method retainAll in ConcurrentMatrixList:

@Override
public boolean retainAll(Collection<?> objects) {
    // TODO: Implement retainAll
    return false;
}

Move the concurrent initialization part into the concurrent chunk system for convenience.

When using chunk systems in a concurrent context, the update method will stop and hang on.

When calling .shutdown(), the chunk system should save all current chunks to disk.

When using a ConcurrentChunkSystem instance, a NullPointerException rises sometimes. Even the iterator which provides single chunks shouldn't return null objects.

Create a feature to count the amount of currently cached targets:

int amount = chunkSystem.getAmount();

When a target moves outside the cache it's gonna be unloaded. After re-visiting the chunk, it spawns at a wrong position. Sometimes, it doesn't spawn at all.

Currently you have to define your own movement detector instance in a class. To save work time, it should be done by the ChunkSystem itself, by invoking the detector.

Problem: the detector must be updated on some kind of update() method. That's the reason why it's currently not handled by chunx itself.

The progress of chunk loading can not be obtained correctly.

Somehow there are too many objects in each chunk.

Sometimes when an entity is created, it doesn't have any listeners (red ones). As a result, they don't get unloaded by the system.

There rises often a NullPointerException in the onMove() method. Caused by a null reference of a chunk.

This null reference occurs because there is no chunk at the calculated index. Therefore, the index is calculated wrongly.

It is possible to leave ChunkTarget and ContentProvider empty (in the configuration). As a result, a NullPointerException is thrown.

When changing the dimensions of a chunk in the configuration file, the chunk system doesn't align correctly on the new center position.

The problem occurs exactly when the x and y index of the cache size differs.

Write tests and implement the core classes of chunkx, containing:

• ChunkSystem
• Chunks
• Chunk debugging
• Chunk handling

Create a basic framework structure (interfaces only) to prepare basic implementation.

The framework itself looks something like this:

Write tests and implement the movement system of chunx.

java.io.IOException: Bad file descriptor is thrown when moving too fast in different directions, because a chunk is saved which is currently loaded and vise versa:

java.io.IOException: Bad file descriptor
    at java.io.FileOutputStream.writeBytes(Native Method)
    at java.io.FileOutputStream.write(FileOutputStream.java:297)
    at java.io.ObjectOutputStream$BlockDataOutputStream.drain(ObjectOutputStream.java:1870)
    at java.io.ObjectOutputStream$BlockDataOutputStream.setBlockDataMode(ObjectOutputStream.java:1779)
    at java.io.ObjectOutputStream.writeNonProxyDesc(ObjectOutputStream.java:1283)
    at java.io.ObjectOutputStream.writeClassDesc(ObjectOutputStream.java:1228)
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1424)
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1175)
    at java.io.ObjectOutputStream.writeFatalException(ObjectOutputStream.java:1570)
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:350)
    at de.myreality.chunx.io.SimpleChunkSaver.save(SimpleChunkSaver.java:94)
    at de.myreality.chunx.caching.CachedChunkHandler.saveChunk(CachedChunkHandler.java:174)
    at de.myreality.chunx.caching.CachedChunkHandler.unloadChunk(CachedChunkHandler.java:192)
    at de.myreality.chunx.caching.CachedChunkHandler.unloadChunks(CachedChunkHandler.java:203)
    at de.myreality.chunx.caching.CachedChunkHandler.handleChunks(CachedChunkHandler.java:114)
    at de.myreality.chunx.caching.SimpleCachedChunkSystem.update(SimpleCachedChunkSystem.java:97)

When overriding equals() and hashCode() in any ChunkTarget object, the handler is not set properly anymore.

Test and implement all i/o classes to provide chunk saving and loading.

When a target moved outside of the current chunk system, move it back to the outest chunk in the pre cache of the chunk system. Afterwards remove the target from the content provider and add it to the chunk.

For this purpose, a vector v is created between the last and the new position of the object. Afterwards the object is moved back to the border of the cache:

By doing so, it's ensured that moveable entities never leave their path but still staying in the chunk system. If the chunk unloads and loads again later, the target will appear and continue moving, as always.

Create a basic iterator for matrix lists which iterates through the matrix horizontally.