import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
public void enter(NhgEntry nhgEntry) {
    NhgLogger.log(this, "Engine is closing.");
    nhgEntry.onClose();

    ImmutableBag<BaseSystem> systems = nhgEntry.nhg.entities.getEntitySystems();
    for (BaseSystem bs : systems) {
        if (bs instanceof Disposable) {
            ((Disposable) bs).dispose();
        }
    }

    nhgEntry.nhg.assets.dispose();
    nhgEntry.nhg.threading.terminate();
    Gdx.app.exit();
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
protected boolean injectField (Object target, Field field, Class<?> type) throws ReflectiveOperationException {
	boolean alreadyInjected = super.injectField(target, field, type);
	if (alreadyInjected) return true;

	//artemis already handles injecting objects inside systems
	if (target instanceof BaseSystem) return false;

	if (BaseSystem.class.isAssignableFrom(type)) {
		field.setAccessible(true);
		field.set(target, engine != null ? engine.getSystem(type.asSubclass(BaseSystem.class)) : config.getSystem(type.asSubclass(BaseSystem.class)));
		return true;
	}

	if (ComponentMapper.class.isAssignableFrom(type)) {
		field.setAccessible(true);
		if (engine == null)
			delayedCompMapperToInject.add(new BiHolder<>(target, field));
		else
			injectComponentMapper(target, field);

		return true;
	}

	return false;
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
private boolean hasSystemClass(Class<? extends BaseSystem> systemClass, Array<BaseSystem> entitySystems) {
    boolean res = false;

    for (BaseSystem es : entitySystems) {
        if (systemClass.isInstance(es)) {
            res = true;
        }
    }

    return res;
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
public Array<BaseSystem> onConfigureEntitySystems() {
    Array<BaseSystem> systems = new Array<>();
    systems.add(new TestNodeSystem());

    return systems;
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
/** Register all systems in this world. */
private void registerAllSystemEvents( )
{
    for (BaseSystem entitySystem : world.getSystems()) {
        registerEvents(entitySystem);
    }
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Test
public void Registration_AllTypesWithNoListeners_NoExceptions() {
    config.setSystem(new BaseSystem() {
        @Override
        protected void processSystem() {
        }
    });
    config.setSystem(new Manager() {
    });
    final World w = new World(config);
    w.getSystem(EventSystem.class).registerEvents(new Object() {});
    w.getSystem(EventSystem.class).dispatch(new SimpleEvent());
    // no exception? happy!
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
/**
 * Get profiler for given system
 * @return profiler or null
 */
public static SystemProfiler getFor (BaseSystem system) {
	Object[] items = profilers.items;
	for (int i = 0; i < profilers.size; i++) {
		SystemProfiler profiler = (SystemProfiler)items[i];
		if (profiler.system == system) {
			return profiler;
		}
	}
	return null;
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
public void initialize(BaseSystem baseSystem, World world) {
	system = baseSystem;
	if (name == null) {
		name = toString();
	}
	if (color == null) {
		calculateColor(toString().hashCode(), color = new Color());
	}
	SystemProfiler.add(this);
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
private void processProfileSystems(Bag<BaseSystem> systems) {
    final Object[] systemsData = systems.getData();
    for (int i = 0, s = systems.size(); s > i; i++) {
        if (disabled.get(i))
            continue;

        updateEntityStates();
        processProfileSystem(profilers[i], (BaseSystem) systemsData[i]);
    }

    updateEntityStates();
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
private void createSystemProfilers() {
    final ImmutableBag<BaseSystem> systems = world.getSystems();
    profilers = new SystemProfiler[systems.size()];
    for (int i = 0; i < systems.size(); i++) {
        profilers[i] = createSystemProfiler(systems.get(i));
    }
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
private SystemProfiler createSystemProfiler(BaseSystem system) {
    SystemProfiler old = SystemProfiler.getFor(system);
    if (old == null) {
        old = SystemProfiler.createFor(system, world);
    }
    return old;
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
/**
 * Finishes loading scene and inflate all entities. This must be called manually if scene wasn't loaded
 * using {@link VisAssetManager} loadSceneNow methods.
 */
public void init () {
	engine.setInvocationStrategy(new BootstrapInvocationStrategy());
	engine.process();
	engine.setInvocationStrategy(new InvocationStrategy());

	for (BaseSystem system : engine.getSystems()) {
		if (system instanceof AfterSceneInit) {
			((AfterSceneInit) system).afterSceneInit();
		}
	}
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
public BaseSystem create (EntityEngineConfiguration config, RuntimeContext context, SceneData data) {
	try {
		return ClassReflection.newInstance(systemClass);
	} catch (ReflectionException e) {
		throw new IllegalStateException("Failed to create system using reflection", e);
	}
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
public <C extends BaseSystem> C getSystem (Class<C> clazz) {
	if (built)
		throw new IllegalStateException("This configuration was already build and it's contents cannot be accessed!");

	for (int i = 0; i < systems.size; i++) {
		BaseSystem system = systems.get(i);
		if (system.getClass() == clazz) return clazz.cast(system);
	}

	throw new IllegalStateException("Failed to get system: '" + clazz + "', system not added!");
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
public WorldConfiguration build () {
	if (built) throw new IllegalStateException("Cannot built configuration twice!");
	built = true;
	WorldConfiguration config = new WorldConfiguration();

	for (BaseSystem system : systems) {
		config.setSystem(system);
	}

	return config;
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
protected void process () {
	BaseSystem[] systemsData = systems.getData();
	for (int i = 0, s = systems.size(); s > i; i++) {
		if (disabled.get(i))
			continue;

		if (systemsData[i] instanceof BootstrapSystem) {
			updateEntityStates();
			systemsData[i].process();
		}
	}

	updateEntityStates();
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
public <C extends BaseSystem> C getSystem (Class<C> clazz) {
	if (built)
		throw new IllegalStateException("This configuration was already build and it's contents cannot be accessed!");

	for (int i = 0; i < elements.size; i++) {
		BaseSystem system = elements.get(i).system;
		if (system.getClass() == clazz) return clazz.cast(system);
	}

	throw new IllegalStateException("Failed to get system: '" + clazz + "', system not added!");
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
public Array<BaseSystem> onConfigureEntitySystems() {
    return super.onConfigureEntitySystems();
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
public Array<BaseSystem> onConfigureEntitySystems() {
    return new Array<>();
}
 

import com.artemis.BaseSystem; //导入依赖的package包/类
@Override
public void enter(NhgEntry nhgEntry) {
    NhgLogger.log(this, "Engine is not initialized.");

    // Setup the ECS world.
    WorldConfigurationBuilder configurationBuilder = new WorldConfigurationBuilder();

    // Configure user entity systems
    Array<BaseSystem> entitySystems = nhgEntry.onConfigureEntitySystems();

    // Configure the most important systems last, especially RenderingSystem which
    // should be the last because it renders all the changes happened in all other
    // systems.
    if (!hasSystemClass(InputSystem.class, entitySystems)) {
        entitySystems.add(new InputSystem(nhgEntry.nhg.assets));
    } else {
        NhgLogger.log(this, "InputSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(PhysicsSystem.class, entitySystems)) {
        entitySystems.add(new PhysicsSystem());
    } else {
        NhgLogger.log(this, "PhysicsSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(CameraSystem.class, entitySystems)) {
        entitySystems.add(new CameraSystem());
    } else {
        NhgLogger.log(this, "CameraSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(LightingSystem.class, entitySystems)) {
        entitySystems.add(new LightingSystem());
    } else {
        NhgLogger.log(this, "LightingSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(ParticleRenderingSystem.class, entitySystems)) {
        entitySystems.add(new ParticleRenderingSystem(nhgEntry.nhg.entities));
    } else {
        NhgLogger.log(this, "ParticleRenderingSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(ModelRenderingSystem.class, entitySystems)) {
        entitySystems.add(new ModelRenderingSystem(nhgEntry.nhg.entities, nhgEntry.nhg.messaging));
    } else {
        NhgLogger.log(this, "ModelRenderingSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(UiSystem.class, entitySystems)) {
        entitySystems.add(new UiSystem(nhgEntry.nhg.entities));
    } else {
        NhgLogger.log(this, "ModelRenderingSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(DebugRenderingSystem.class, entitySystems)) {
        entitySystems.add(new DebugRenderingSystem(nhgEntry.nhg.entities));
    } else {
        NhgLogger.log(this, "DebugRenderingSystem already registered, ignoring registration.");
    }

    if (!hasSystemClass(RenderingSystem.class, entitySystems)) {
        entitySystems.add(new RenderingSystem());
    } else {
        NhgLogger.log(this, "RenderingSystem already registered, ignoring registration.");
    }

    for (BaseSystem bes : entitySystems) {
        configurationBuilder.with(bes);
    }

    nhgEntry.nhg.entities.setEntityWorld(new World(configurationBuilder.build()));
    nhgEntry.getFsm().changeState(EngineStates.INITIALIZED);
}