Beautiful game. It expects good precision though!
A member registered Oct 10, 2015 · View creator page →
Creator of
Recent community posts
The Game Screen
You could find a better formatted version of this devlog at this link
The Game Screen is the most important of SpaceFloat because it shows the 3D world with which the player can interact. It makes use of the powerful Ashley Engine that helps significantly reduce the complexity of the system.
This Screen creates all the systems it needs within its constructor.
private ReactorController reactorController;
private BulletSystem bulletSystem;
private CameraSystem cameraSystem;
private RenderSystem renderSystem;
public GameScreen() {
reactorController = new ReactorController();
bulletSystem = new BulletSystem();
cameraSystem = new CameraSystem();
renderSystem = new RenderSystem();
}
Like all SpaceFloat Screens, when the show method is called, all the Game Screen dependencies have already been initialized, so it can inject the last dependencies into the systems, add these systems to the Engine and finally create the HUD.
@Override
public void show() {
injectSystemsDependencies();
addSystemsToEngine(getEngine());
createHud(getStage());
}
private void injectSystemsDependencies() {
Camera mainCamera = getCamera();
cameraSystem.setCamera(mainCamera);
renderSystem.setCamera(mainCamera);
ParticleSystem particleSystem = getParticleSystem();
reactorController.setParticleSystem(particleSystem);
renderSystem.setParticleSystem(particleSystem);
}
private void addSystemsToEngine(Engine engine) {
engine.addSystem(reactorController);
engine.addSystem(bulletSystem);
engine.addSystem(cameraSystem);
engine.addSystem(renderSystem);
}
public void createHud(Stage stage) {
HudFactory factory = new HudFactory();
stage.addActor(factory.getFpsActor());
stage.addActor(factory.getVelocityActor());
stage.addActor(factory.getAccelerationActor());
stage.addActor(factory.getEnergyActor());
}
Eventually, the update method becomes nothing more simple:
@Override
public void update(float delta) {
super(delta);
engine.update(delta);
}
To follow the pattern of previous posts, I conclude with an image of the HUD elements!
The Loading Screen
You could find a better formatted version of this devlog at this link
A fundamental use case of the asset manager is in the LoadingScreen. With this tecnique you can load all assets within a directory while showing progress.
public class LoadingScreen extends SpaceFloatScreen {
private static final String TEXTURE_DIRECTORY = "textures/";
private AssetManager assetManager;
private float progress;
@Override
public void show() {
super.show();
assetManager = getAssetManager();
FileHandle[] files = Gdx.files.local(TEXTURE_DIRECTORY).list();
for(FileHandle file : files) {
assetManager.load(file.path(), Texture.class);
}
}
@Override
public void render(float delta) {
assetManager.update();
progress = assetManager.getProgress();
logger.info("Loading assets: " + progress);
if (progress < 1.0f) return;
SpaceFloat.GAME.setScreen(ScreenEnumerator.MAIN);
}
}
I'm also glad to show you the new cargoship which you drive in SpaceFloat!
I'm glad to announce that the codename for the FastTeam's entry is SpaceFloat and it will be a game about a delivery service in the space!
I'm going to continue these devlogs writing about some practices I use with libGDX. So, here is a devlog about the SpaceFloat screen management.
SpaceFloat Screen Management
You could see a better formatted version of this devlog at this link.
SpaceFloat is divided in well-defined screens encapsulated in the ScreenEnumerator, so it's very simple to retrieve a singleton of a screen:
ScreenEnumerator.INFO.getScreen();.
public enum ScreenEnumerator {
INFO(new InfoScreen()),
MAIN(new MainScreen()),
LOADING(new LoadingScreen());
private SpaceFloatScreen screen;
ScreenEnumerator(SpaceFloatScreen screen) {
this.screen = screen;
}
public SpaceFloatScreen getScreen() {
return screen;
}
}
The SpaceFloatGame class, subclass of
Game, is responsible of the application life-cycle, including the current screen. A screen is initialized within the method setScreen(ScreenEnumerator) which, if the screen is not yet initialized, will invoke injectDependencies(SpaceFloatScreen) to inject all required dependencies.
public void setScreen(ScreenEnumerator screenEnumerator) {
SpaceFloatScreen screen = screenEnumerator.getScreen();
if (!screen.isInitialized()) injectDependencies(screen);
setScreen(screen);
}
private void injectDependencies(SpaceFloatScreen screen) {
screen.setAssetManager(assetManager);
screen.setFont(font);
screen.setEngine(engine);
screen.setGame(this);
screen.setInitialized(true);
}Hi! Here are Fahien and pasto, aka the FaSTeam!
The first devlog isn't strictly related to the game we are going to create, but it is about a tool which I think would be useful.
During the preparations for the jam, the team needed to test the effectiveness of its work by creating a prototype application which involves the use of libGDX and Blender.
ProtoFast is the codename of this project. The final product is a simple application which shows a three-dimensional model through a camera movable via mouse or touch screen.
Practically, ProtoFast creates a list of models contained in the local models/ folder. If there are no models in the local folder, it searches in the internal models/ folder. The showcase screen loads the first model from the list and renders it. You can load the next or previous model through the arrows.
Screenshots
The models shown in the screenshots are made by pasto.
