LibGDX game jam first weekend

// One batch
public SpriteBatch batch;
 
// One camera, orthographic to handle 2d, and a viewport
public Camera camera;
public Viewport viewport;
 
// Arthemis gameworld
public World arthWorld;
 
// Screens
public SplashScreen splashScreen;
public GameScreen gameScreen;
 
// Handle all assets
public AssetManager assetManager;

@Override
public void create () {
	assetManager = new AssetManager();
 
	// create all screens
	splashScreen = new SplashScreen(this);
	gameScreen = new GameScreen(this);
 
	// Create camera
	camera = new OrthographicCamera();
	((OrthographicCamera)camera).setToOrtho(false);
	viewport = new StretchViewport(width, height, camera);
	camera.position.set(viewport.getWorldWidth() / 2f, viewport.getWorldHeight() / 2f, 0);
 
	batch = new SpriteBatch();
 
	WorldConfiguration config = new WorldConfigurationBuilder()
			.with(new SortedRenderSystem(this), new PhysicsSystem(20), new InputSystem(this, 20))
			//.with(new RenderSys(), new EditingSys(), new ScriptSys())
			.register(new GameLoopSystemInvocationStrategy(20))
			.build();
	arthWorld = new World(config);
	setScreen(splashScreen);
 
	testData();
}

public class GameLoopSystemInvocationStrategy extends SystemInvocationStrategy {
 
 
    private float timeToProgress;
    private float accumulator  = 0;
    private float simAccumulator = 0;
 
    private final Array logicMarkedSystems;
    private final Array otherSystems;
 
    private boolean systemsSorted = false;
 
    public GameLoopSystemInvocationStrategy(float logicFPS) {
        timeToProgress = 1 / logicFPS;
        logicMarkedSystems = new Array();
        otherSystems = new Array();
    }
 
    @Override
    protected void process(Bag systems) {
        if (!systemsSorted) {
            sortSystems(systems);
        }
        accumulator += world.delta;
        while (accumulator >= timeToProgress) {
            for (int i = 0; i < logicMarkedSystems.size; i++) {
                /**
                 * Make sure your systems keep the current state before calculating the new state
                 * else you cannot interpolate later on when rendering
                 */
                logicMarkedSystems.get(i).process();
                updateEntityStates();
            }
            accumulator -= timeToProgress;
            simAccumulator = 0;
        }
        for (int i = 0; i < otherSystems.size; i++) {
            /**
             * Use the kept state from the logic above and interpolate with the current state within your render systems.
             */
            otherSystems.get(i).process();
            updateEntityStates();
        }
    }
 
    private void sortSystems(Bag systems) {
        if (!systemsSorted) {
            Object[] systemsData = systems.getData();
            for (int i = 0, s = systems.size(); s > i; i++) {
                BaseSystem system = (BaseSystem) systemsData[i];
                if (system instanceof LogicRenderMarker) {
                    logicMarkedSystems.add(system);
                } else {
                    otherSystems.add(system);
                }
            }
            systemsSorted = true;
        }
    }
}

public abstract class SortedIteratingSystem extends BaseEntitySystem {
 
    private final Array sortedEntities = new Array();
    private Comparator comparator;
 
    public SortedIteratingSystem(Aspect.Builder aspect) {
        super(aspect);
    }
 
    public void setComparator(Comparator comparator) {
        this.comparator = comparator;
    }
 
    protected abstract void process(Entity entity);
 
    @Override
    protected final void processSystem() {
        for (int i = sortedEntities.size - 1; i >= 0; i--) {
            process(sortedEntities.get(i));
        }
    }
 
    @Override
    protected void inserted(int entityId) {
        sortedEntities.add(world.getEntity(entityId));
        sortedEntities.sort(comparator);
    }
 
    @Override
    protected void removed(int entityId) {
        sortedEntities.removeValue(world.getEntity(entityId), false);
        sortedEntities.sort(comparator);
    }
}

public class SortedRenderSystem extends SortedIteratingSystem {
 
    private LibGDXJamSpace jamSpace;
    private ComponentMapper transform2d;
    private ComponentMapper texture;
 
    public SortedRenderSystem(LibGDXJamSpace jamSpace) {
        super(Aspect.all(Transform2DComp.class, TextureComp.class));
        setComparator(new ZComparator());
        this.jamSpace = jamSpace;
    }
 
    @Override
    protected void begin() {
        if (jamSpace.batch != null) {
            jamSpace.camera.update();
            jamSpace.batch.setProjectionMatrix(jamSpace.camera.combined);
            jamSpace.batch.begin();
        }
    }
 
    @Override
    protected void process(Entity entity) {
        if (jamSpace.batch != null) {
            TextureComp textureComp = texture.get(entity);
            Transform2DComp transformComp = transform2d.get(entity);
            if (textureComp.sprite != null) {
                textureComp.sprite.setPosition(transformComp.position.x, transformComp.position.y);
                textureComp.sprite.setScale(transformComp.scale.x, transformComp.scale.y);
                textureComp.sprite.setRotation(transformComp.rotation);
                textureComp.sprite.draw(jamSpace.batch);
            }
        }
    }
 
    @Override
    protected void end() {
        if (jamSpace.batch != null) {
            jamSpace.batch.end();
        }
    }
 
    private class ZComparator implements Comparator {
        @Override
        public int compare(Entity e1, Entity e2) {
            return (int)Math.signum(transform2d.get(e1).zValue - transform2d.get(e2).zValue);
        }
    }
}