Posted by on No comments
Welcome to the official page of Spacecraft Tactics!
Do you want to learn more about the game?
-> About The Game, Development Timeline, Youtube
Are you interested in creating your own mods?
-> Modding Guide, Api Documentation, Maven Repository
Server status
-> Server Status
Game Music Tracks
-> Bandcamp or extio.de
Steam Store Page
-> https://store.steampowered.com/app/2642080/Spacecraft_Tactics
Posted by on No comments
| 2023-11-27 | Release | The game has been released on November 27 2023 after 7 years of work! |
| 2023-10 |
Sole Proprietorship, |
I have successfully founded my sole proprietorship (yes, this takes 3 months in Germany!) and am now registered in the Steamworks Developer Program. The game is now in release candidate state and will probably release end of November! Test machines setup to check all kind of hardware + OS combinations (not my developer workstation): |
| 2023-06 | Feature Freeze |
We are now feature complete! This means only bug fixes and improvements like balancing changes are to be expected. |
| 2023-05 | More modes finished |
The following additional game modes have now been implemented:
|
| 2023-03 | Campaign: Development finished | After a lot of playthroughs, features are complete, balancing works out and most bugs should be fixed! |
| 2022-11 | Campaign: All chapters finished | The campaign can now be played from the start to the end! |
| 2022-07 | Detailed technical presentation |
Technical breakdown or how a video game works Video: Technical Presentation, see External Links |
| 2022-02 | Tutorial |
In-game tutorial is now available
|
| 2022-01 | Music and sound effects |
Most of the ingame music and sound effects have been produced
|
| 2021-10 | Campaign first chapter | First chapter of the campaign has been finished |
| 2020-10 | Development of campaign "The Last Outpost" started |
|
| 2020-05 | Mission prototype |
Video: Mission Prototype, see External Links
|
| 2020-01 | Full mod support |  |
| 2019-11 | Scene editor |
Video: Scene Editor, see External Links |
| 2019-08 | AI |  |
| 2019-03 | Lobby and match making | 
|
| 2019-01 | Spaceship Editor | Video: Spaceship Editor, see External Links |
| 2018-11 | Audio production started |  |
| 2018-05 | Bringing more and more game subsystems and entities together. Controllable entities. |
|
| 2018-01 | Almost looking like a game! |  |
| 2017-11 | First version of meshes and fields |
Video: First version of meshes and fields, see External Links |
| 2017-09 | Bringing together many features and sub-systems: First playable network test! |
Video: First Playable Network Test, see External Links |
| 2017-07 | Composite Entity Collisions |
Video: Asteroids Armageddon Test, see External Links |
| 2017-06 | Viewport | 
Video: Viewports, First Development Version, see External Links |
| 2017-05 | Path finding | 
Video: Path Finding Demonstration, see External Links |
| 2017-03 | Entity management, basic game elements like spawn points and first game viewport work. And of course, many many implementations in all areas. |    |
| 2017-02 | Further development of client side engine and game server. Initial creation of UI menu and lobby modules. |    |
| 2017-01 | Prototype of engine and renderer. Simple spacecraft editor. |   |
| 2016-08-22 | Development started |  |
Posted by on No comments
Hi,
I can't believe it, the game has been released!
Every person has a list of things they want to do in their life. Releasing my own game is on my list, and I've now done it!
I would like to thank all the people who supported me during the development of the game with their understanding, suggestions and tests. My family, colleagues, but especially the following friends who have tested the game with me again and again: Ekty, Moztr, Shutdown
So it's not over yet, I'm determined to continue to support and improve my game in the future!
Posted by on No comments
Hi,
I can't believe it, after 7 intense years of development, the game will release in about 2 weeks on 2023-11-27!
When I started developing the game, the initial idea was having a project for 1 year. Only static turn-based tactical battles, staying mostly in a FTL-like view and micromanaging ship systems from there. But the vision for the game was quickly getting more and more ambitious, away from static battles to controlling ships in a dynamic 2D world while still keeping all of the micro management without overwhelming the player at the same time. By centering the game around a campaign with ship progression and RPG elements. By developing a game design that allows all different kinds of game modes. And of course also by providing a much better replayability by including a ship- and scene editor and even providing the possibility to implement own code in groovy programming language.
I worked on the project alone the entire time and only in my free time, alongside my full-time job in a technical management position, which in itself is very demanding both in terms of expertise and time. There were times when my agenda for the game definitely felt a bit too ambitious, and as is probably usual in such projects, there were a lot of ups and downs.
Now the development is finished. I'm still doing final tests and polishing some details, but the game is pretty stable already and the campaign plays exactly as I imagined.
I am aware that the game is rather niche, some elements, especially in the campaign, can be considered hardcore and therefore may not appeal to every player. But I hope that a community will form that has a lot of fun with the game and perhaps shares its own ships, scenes or even creates mods for the game.
I feel like an actor who has put a lot into a new play and now has doubts before the premiere.
Personally, I'm happy with the result and would definitely do it again despite all the effort!
Posted by on No comments
Spacecraft Tactics is a 2D turn-based tactical space game. Save the last rebel outpost in the campaign. Develop a strategy, execute it in tactical battles and micromanage your ship. Play various game modes single or multiplayer. Create your own ships, scenes or mods and share them.
Posted by on No comments
Spacecraft Tactics is designed from ground up to be modular for easy creation of mods. In fact, most of the game core modules and also all game modes (e.g. the campaign) are implemented as mods to make sure that the mod interface is providing everything that is needed.
There are several types of mods possible:
Mods can be published in Steam Workshop.
There is a video available on youtube that describes how to create and publish mods including groovy programming. It demonstrates that based on the AI Battles game mode, which can be also downloaded from Steam workshop.
There is a detailed technical presentation available how the game works under the hoods. It is recommended to watch at least some relevant sections of it for a general understanding about the game's internals.
It is available as a video on youtube, link see "Technical Presentation" at External Links
Slides can be downloaded here: Spacecraft_Tactics_Technical_Overview.pdf
First copy your mod to the game installation folder:
Steam Workshop
See screenshot
You can do initial uploads as well as updates. In case of an update there is already a Workshop ID displayed.achievements.xml Definition of achievements
actions.xml Defined actions of entities in the game client
entities.xml Defines all entities (use shipped Entity Editor program)
i18n.xml Internationalization / Localization file (use shipped I18n Editor program)
mod.xml Main definition and configuration of the mod. This file is mandatory to edit.
shipClasses.xml Definition of ship classes
Overriding existing files and definitions with your mod is an important concept.
Files with the same name in the same relative folder override files from other mods.
Similarly, using the same identifiers in the various definitions (entities.xml, shipClasses.xml, i18n.xml, ...) override definitions from previously loaded mods, including game core.
Game Core is always loaded first. The order of loading of all other mods is determined by the loadingPriority element in mod.xml. Mods with higher values are loaded after mods with lower values and therefore can override all mods loaded before. All shipped official mods have priority 100.
Example 1: You want to create a tileset mod that overrides the existing tilesets from game core.
Just place a file with the same filename in the same relative folder as in the original mod. For example ./gfx/tilesets/official_0.png.
This example works for all gfx and sounds.
Example 2: You want to customize entities and default ship classes.
Just copy the definition from game core to your shipClasses.xml and apply your changes.
Note, when connecting to a game server in multiplayer all entity definitions and ship classes of that server are transferred to and used by the client.
Note 2, Entity Editor app provides a functionality for convenience to override entities. See the respective section below.
This example works for achievements, actions, entities, i18n and ship classes.
mod.xml is the main definition and configuration file of your mod.
The template copied from mod-template contains all possible elements but only all essential configuration options are active, all optional elements are commented out.
You must configure all elements that are highlighted in red color, everything else is optional and only needs to be configured if your mod makes use of it.
This is a screenshot of the main window:
First you need to enter the name of your new entity. This is only a technical name that is not shown to the user.
Last you need to select the corresponding live entity type. It is important that the types of entity definition and live entity (the actual implementation) fit. If in doubt, select the entry with similar name. 
Overriding entities from game core
To override a entity from game core, your defined entity must have the same UUID (universal unique identifier). There is a functionality available for convenience to take over all properties from the existing entity.
Select the entity you want to override 
You can bundle scenes (also known as stages, levels, scenarios) and ships with your mod. These scenes and ships can then either be selected by players when starting custom game mode or they can be hidden and loaded programmatically as part of your game mode (requires groovy scripting).
There is also a video available on youtube that explains how to create scenes: https://youtu.be/YypyebMDrlc
)
Import: Load a ship from file systemSpacecraft Tactics has been designed from the ground up to be modular and support mods created by the community. Develop your own mods in groovy programming language, ranging from simple scripts for your scenes up to full conversions!
Most shipped game modes, including the campaign, are actually groovy mods!
The following chapters describe how to set up a project, where to find resources and documentation and will also go through code examples.
Spacecraft Tactics integrates Apache Groovy 3. Groovy is a programming language for the Java platform. It integrates seamless in the Spacecraft Tactics game engine and server core, which are developed in Java 11. You can implement groovy classes in 95% java syntax, at the same time groovy also allows you more flexibility by being an optionally typed and dynamic language and it also extends the java standard library.
In theory all you need is a text editor to implement your own scripts. Spacecraft Tactics loads and compiles your code when starting the game.
Of course using a proper IDE and making use of a maven project template will make your life much easier. This is described in the next chapters.
It is also recommended to watch the mod howto video: https://youtu.be/P-ty9cu-oC8
... and also at least parts of the technical presentation to get a better understanding about the internals of the game: https://youtu.be/RlJRBo442dY
The API documentation can be found at the following location:
https://www.spacecraft-tactics.com/apidocs/index.html
There is also a source jar of the shared library available that includes javadocs, see next chapter. This makes it possible that you see the documentation in your IDE while you are using the API.
Apache Maven is a software project management and comprehension tool. It is best known as a widespread java build system.
All Spacecraft Tactics artifacts that are needed for developing your mods can be found in our public maven repository:
https://spacecraft-tactics.com/repository/
It includes the following artifacts:
There is a project template shipped with the game, containing a working pom.xml as well as all other mod files that are required. See also Copy files and Folder structure and explanations
There are many popular choices out there how to develop java- and groovy code.
The following guide explains how to install + set up Eclipse IDE and import your project:
You can use the following -D switch when starting the game to add your mod folder to the search path. This way you don't need to copy your mod every time to the game folder when you want to test it. It contains a comma separated (without space) list of mod base folders. In your case this is the folder where the pom.xml is. When using this property you have to also add the game core folder. Minimal example:
-Dmodslocation=/home/xx/spacecraft-folder/bin,/home/xx/your-new-mod-folder
However, you need to start the client .jar with java directly instead of using the .exe or .sh launcher that is shipped with the game.
Change your current working directory (CWD) to the game folder and use the following command (change the paths):
Linux: ./jre-linux/bin/java -Dfile.encoding="UTF-8" -XX:+UseShenandoahGC -Dmodslocation=/home/xx/spacecraft-folder/bin,/home/xx/your-new-mod-folder -jar ./bin/spacecraft-game-client.jar Windows: ...
If you want to debug your code using a debug socket, add these options before the -jar parameter: -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=127.0.0.1:8000
Spacecraft Tactics has by default the Java Security Manager active. This is the most important line of defense against malicious mods code (a shame that it has been deprecated in later java versions, containers are not the answer for plugin interfaces!). In case you want to connect to the java process via JMX or use Java Flight Recorder, you can disable Security Manager by adding this parameter: -DsecurityManager=false
Attention! Don't load untrusted mods with security manager disabled, you will be fully exposed!
See Publishing
Scripting entities are an easy way to enrich your scenes with own logic. They can be placed in the scene editor to your scene and also receive some parameters entered in the scene editor.
Use cases are
General declaration of scripting entities:
@ScriptingCompositeEntityFactorySelectable(custom0Label = "123", custom1Label = "234")
public class Xyz extends AbstractScriptingEntity {
If you add the @ScriptingCompositeEntityFactorySelectable annotation, your scripting entity will be shown in the scene editor when selecting the scripting entity. There are 5 custom fields a user in the scene editor can fill to provide parameters to your scripting entity. You can give these custom fields a label (i18n id) that the user understands what to enter.
Other than that, scripting entities extend de.extio.spacecraft.shared.model.entity.builtin.live.AbstractScriptingEntity
The full example can be found in the source jar of the shared library, class de.extio.spacecraft.shared.model.entity.builtin.live.scripting.ShowDialog
@Override
protected void onClientCompositeEntityRadiusEntered(final AbstractCompositeEntity compositeEntity) {
final SpaceShip localShip = EngineFacade.instance().getGame().getLocalPlayerSpaceShip();
if (localShip == null || !compositeEntity.getUuid().equals(localShip.getUuid())) {
return;
}
Method onClientCompositeEntityRadiusEntered() is called on the client side on each turn when a new composite entity has entered the radius of the scripting entity. The radius can be entered when placing the scripting entity in scene editor.
In this example we are checking whether the composite entity that has entered the radius is the ship of the current player playering the game on the local game client. Never compare entities with == operator but always by equality of their UUID.
ClientDialogMessage dialogMessage;
if (StringUtils.isEmpty(this.custom0)) {
dialogMessage = new ClientDialogMessage(ImmutableList.of("lo-7"), ImmutableList.<List<String>> of());
}
else {
final List<String> displayIds = Arrays.asList(this.custom0.split(","));
dialogMessage = new ClientDialogMessage(displayIds, ImmutableList.<List<String>> of());
}
EngineFacade.instance().dispatchMessage(dialogMessage);
This example then creates and sends a ClientDialogMessage, which can be used to display a certain message in the dialog window that appears on the upper part of the screen. In our example it accepts multiple lines of text comma separated and it display a fallback text "lo-7" (all are localization ids) if there were no texts entered in scene editor in the properties of the scripting entity.
The full example can be found in the game folder under ./mods/last-outpost/storage/src/ , class de.extio.spacecraft.mod.last_outpost.stages.common.ActivateMission
@Override
protected void onServerCompositeEntityRadiusEntered(AbstractCompositeEntity compositeEntity, GameSession gameSession) {
Similar to the previous example. we are using onServerCompositeEntityRadiusEntered() this time which is the counterpart on server side. Note that any server method passes a GameSession, this is a very important context object. You can access all game session related data and also managers from there.
if (! (compositeEntity instanceof SpaceShip) || ((SpaceShip) compositeEntity).getCrewControlByPlayer().isEmpty()) {
return;
}
This time we are filtering for SpaceShips that are controlled by any player.
this.radius = 0;
We can set the radius of the scripting entity programmatically to 0. After that it will no longer receive any callbacks related to radius. This is useful if you want to execute an action only once.
GameActionMessage message = new GameActionMessage("StageController_Activate");
message.setParameters(ImmutableMap.<String, Object>of("missionName", this.custom0));
ServerFacade.instance().publishInternalMessage(gameSession, message, false);
The action in this entity is then sending a GameActionMessage to a module that is specific to last-outpost mod.
The full example can be found in the game folder under ./mods/mp-official/storage/src/ , class de.extio.spacecraft.mod.mp_official.arena.entity.ArenaBorder
@Override
public void onServerTurnPass2PostComposites(GameSession gameSession) {
super.onServerTurnPass2PostComposites(gameSession);
AbstractCompositeEntity parent = gameSession.getServerWorldManager().findBy(this.getParentCompositeEntity());
Area2 arena = this.getArea(parent);
this.sendViewportEffectEvent(gameSession, arena);
if (! gameSession.editorMode) {
this.bounceShips(gameSession, arena)
}
}
onServerTurnPass2PostComposites() is executed on server side after all logic of all composites and entities has been executed at the end of a turn. It is a post-processing step in the pipeline. See also the javadoc.
The game logic in this script has 2 main functionalities:
private sendViewportEffectEvent(GameSession gameSession, Area2 arena) {
int i = 0;
for (Area2 side : WorldUtils.getSides(arena)) {
final ViewPortEffectEvent viewPortEffectEvent = new ViewPortEffectEvent(0, // 0 = infinite TTL, see comment about exclusiveId
DrawEffectRenderingBoEffects.RECT_FILLED,
COLOR,
side.getPosition().add(1),
null,
null,
null,
ImmutableList.<CoordI2>of(side.getDimension().substract(2)),
null,
null,
0,
0.0d);
final GameActionMessage gameActionMessage = new GameActionMessage("viewPortEffectEvent");
gameActionMessage.setParameters(ImmutableMap.<String, Object> of(
"viewPortEffectEvent", viewPortEffectEvent,
"exclusiveId", "ArenaBorder_Border" + i++));// exclusiveId: ViewPortModule will replace the previous effect that is still active under that id. This approach is preferred over just providing an event TTL of the turn duration times framerate because remote servers will have fluctuating network latencies spanning multiple frames
gameActionMessage.setArea(arena);
ServerFacade.instance().publishMessageToAll(gameSession, gameActionMessage, true);
}
}
This method is executed on server side. At first glance it would be more natural to execute anything that renders something on the client side. This is definitely true in most cases, but I picked this example to point out a certain corner case: As you already noticed when playing the game, the client has a very limited viewport and everything is else is hidden by fog of war. In fact, everything outside of the viewport is not sent to the client at all. Therefore scripting entities are only active on client side when they are inside of the viewport of the player.
In our case we draw an effect that goes beyond of these viewports. Therefore we first create a ViewPortEffectEvent like on the client side and as a second step we send it to the client with a GameActionMessage. These messages are handled by the core viewport module.
On the client side, ViewPortEffectEvent usually have a time to live of 1 frame and are created again on every frame as long as it should be displayed.
On the server side, code is only executed with every turn. Therefore we set TTL 0 to have it displayed until it is explicitely invalidated and we also set an "exclusiveId" parameter on the game action message. The client viewport module will automatically invalidate previous events with the same exclusiveId.
The GameActionMessage also has an optional area set. This causes the server, although using publishMessageToAll(), to send it only to clients their viewport intersects with that area.
The exact properties of a ViewPortEffectEvent depend on the effect, best is to search in the shipped mods for certain effects and check their usage.
private bounceShips(GameSession gameSession, Area2 arena) {
for (SpaceShip ship : gameSession.getServerWorldManager().findBy(SpaceShip.class)) {
if (! ship.isDead()) {
Area2 checkArea;
if (ship.getPrevPosition() != null) {
checkArea = WorldUtils.pointsToArea(
ship.getPosition(),
ship.getPosition().add(ship.getDimension()),
ship.getPrevPosition(),
ship.getPrevPosition().add(ship.getDimension()));
}
else {
checkArea = new Area2(ship.getPosition(), ship.getDimension());
}
for (Area2 side : WorldUtils.getSides(arena)) {
if (WorldUtils.intersects(checkArea, side)) {
CoordI2 arenaCenter = arena.getPosition().add(arena.getDimension().divide(2));
CoordI2 shipCenter = ship.getPosition().add(ship.getDimension().divide(2));
ship.setVelocityVector(arenaCenter.substract(shipCenter).toVNorm().multiply(5.0d));
break;
}
}
}
}
}
This method bounces back ships that crossed the boundary of the arena.
First it iterates over all SpaceShips, which can be queried from WorldManager. It also filters out ships with a dead crew.
After utilizing some utility functions from WorldUtils, which in general provides all kind of geometric helper functions, it checks whether a ship still intersects with the arena and if not it sets a new velocity vector that bounces it back into the arena toward the center.
The full example can be found in the game folder under ./mods/last-outpost/storage/src/ , class de.extio.spacecraft.mod.last_outpost.stages.C3DepotCtrl
private C3DepotServerState stageStatus;
@Override
public void create(UUID uuid, AbstractEntityDef entityDef, int entityDefIdx, UUID parentCompositeEntity) {
super.create(uuid, entityDef, entityDefIdx, parentCompositeEntity);
this.stageStatus = new C3DepotServerState(status: C3DepotState.START);
}
@Override
public void update(AbstractEntity other) {
super.update(other);
if (other instanceof C3DepotCtrl) {
if (other.stageStatus != null) {
this.stageStatus = new C3DepotServerState();
InvokerHelper.setProperties(this.stageStatus, other.stageStatus.properties);
}
}
}
@CompileStatic
static class C3DepotServerState {
C3DepotState status;
UUID station;
}
@CompileStatic
static enum C3DepotState {
START,
END
}
This example shows how to implement a stateful scripting entity. If the state changes on server it is transferred to the client as well. The state is also persistent when a checkpoint has been saved and later loaded again.
C3DepotServerState is a data object containing the state. The server logic is also in state machine style -> C3DepotState
create() sets the initial state on server side when the entity has been created (That happens already in the scene editor!). update() is usually called when the game client receives an entity update from the server side to merge the new data to the existing fields. So the client does not just replace instances but there is merge logic in place - this is important because entities usually also have transient fields that would be lost when receiving new data from the server and just replacing instances.
@Override
public void onServerTurnPass1(GameSession gameSession) {
super.onServerTurnPass1(gameSession);
if (gameSession.isEditorMode()) {
return;
}
switch (this.stageStatus.status) {
case C3DepotState.START:
The actual scene controller logic implements a state machine. Note that onServerTurnPass1() is also called in scene editor when the scripting entity has been placed, but it would of course not make any sense to execute game logic in the editor. This can be checked with gameSession.isEditorMode().
The following examples show how to implement certain types of modules in the game client. Client modules contain game logic and can interact with the UI.
The full example can be found in the game folder under ./mods/last-outpost/storage/src/ , class de.extio.spacecraft.mod.last_outpost.module.client.GameOverModule
@CompileStatic
public class GameOverModule extends AbstractClientModule {
Client modules extend AbstractClientModule
private EnhancedWindow<Void> window;
@Override
public void onLoad() {
final CoordI2 dimension = ImmutableCoordI2.create(800, 450);
this.window = new EnhancedWindow<Void>("GameOverModuleWindow", true, false, null, {
new Area2(EngineFacade.instance().getRendererControl().getEffectiveViewportDimension().divide(2).substract(dimension.divide(2)), dimension);
});
this.window.setDrawCloseButton(true);
this.window.setRenderingBoLayer(RenderingBoLayer.UI1_BGR);
}
@Override
public void onUnload() {
this.window.close();
}
@Override
public void onDeactivate() {
this.window.releaseDragging();
}
@Override
public void hide() {
this.window.releaseDragging();
}
@Override
public boolean onMouseDrag(final CoordI2 coord, final int button, final int modifiers) {
return this.window.drag(coord);
}
@Override
public boolean onMouseRelease(final CoordI2 coord, final int button, final int modifiers) {
boolean handled = false;
this.window.releaseDragging();
if (this.window.intersects(coord)) {
handled = true && !((ViewPortModuleSettings) EngineFacade.instance().getClientState().getState().get("ViewPortModuleSettings")).isViewportDragging();
}
return handled;
}
@Override
public boolean onMouseMove(final CoordI2 coord, final int modifiers) {
boolean handled = false;
if (this.window.intersects(coord)) {
handled = true;
}
return handled;
}
This snippet shows how the EnhancedWindow utility is properly integrated in a client module. It helps to position, draw and manage virtual windows in the UI. Windows are not integrated natively into the game engine but are rather handled by that helper class and therefore must be connected to various module event handlers as shown above.
@Override
public void runAfterEvents(List<RenderingBo> renderingBo) {
if (! this.isDisplayed()) {
return;
}
this.display(renderingBo);
}
private display(List renderingBo) {
this.window.render(renderingBo);
boolean isHost = EngineFacade.instance().getGame().getLocalPlayerId().equals(EngineFacade.instance().getGame().getGameSession().getHost());
RenderingBo bo = EngineFacade.instance().getRenderingBoPool().acquire(DrawFontRenderingBo.class)
.setSize(32)
.setText(EngineFacade.instance().getLocalizationManager().translate("lo-497"))
.setAlignment(DrawFontRenderingBoTextAlignment.CENTER)
.withDimensionAbsolute(this.window.getDimension().getX(), 36)
.setColor(RgbaColor.WHITE)
.setLayer(RenderingBoLayer.UI1_0)
.withPositionAbsoluteAnchorTopLeft(this.window)
.withPositionIncrementalAbsolute(0, 30);
renderingBo.add(bo);
bo = EngineFacade.instance().getRenderingBoPool().acquire(ControlRenderingBo.class)
.setId("GameOver_Load")
.setType(ButtonControl.class)
.setVisible(true)
.setCaption(EngineFacade.instance().getLocalizationManager().translate("lo-499"))
.setEnabled(isHost)
.withDimensionAbsolute(200, 64)
.setLayer(RenderingBoLayer.UI1_0)
.withPositionAbsoluteAnchorTopLeft(this.window)
.withPositionIncrementalAbsolute((int)(this.window.getWidth() / 2) - 205, this.window.getHeight() - 80);
renderingBo.add(bo);
This snippet shows how to draw UI elements.
The draw method is called from runAfterEvents(), this ensures that any result of an event that has been handled (e.g. a mouse click) is already included when rendering the frame to keep the latency (UI lag) low.
this.window.render(renderingBo) adds RenderingBo for the window itself, below that follow the actual contents of the window.
DrawFontRenderingBo is a good example how to draw text on a window and ControlRenderingBo shows how to draw a button.
Check nested interfaces of ControlRenderingBo to see which other types of controls are available.
private final static Map<Class<? extends Event>, Integer> RELEVANT_EVENT_TYPES = ImmutableMap.of(UiControlEvent.class, ClientModule.EVENT_PRIORITY_NORMAL);
@Override
public void onEvent(final Event event) {
if (event instanceof UiControlEvent) {
final UiControlEvent uiControlEvent = (UiControlEvent) event;
switch (uiControlEvent.getId()) {
case "GameOverModuleWindow_Close":
this.hideWindow();
break;
case "GameOver_Load":
this.hideWindow();
CheckpointModuleSettings checkpointModuleSettings = (CheckpointModuleSettings) EngineFacade.instance().getClientState().getState().get("CheckpointModuleSettings");
checkpointModuleSettings.reset(false);
checkpointModuleSettings.setStatePrefixes(ImmutableList.of("lo-"));
checkpointModuleSettings.setShowLoadDialogImmediately(true);
checkpointModuleSettings.setAddSessionGameTime(true);
checkpointModuleSettings.setShowMainMenuLoadEntry(true);
EngineFacade.instance().getMenuLauncher().launch("checkpointClientModuleEmbedded");
break;
case "GameOver_Quit":
EngineFacade.instance().getMenuLauncher().boot();
break;
}
}
}
This is how events are handled. UiControlEvent is the way how events from controls (e.g. a click on a button) can be handled in modules.
The code shown above handles clicks on buttons like "GameOver_Load", which corresponds to .setId("GameOver_Load") you set on the control.
Controls are stateful in the renderer as long as the control (by id) is rendered with the next frame.
The full example can be found in the game folder under ./mods/mp-official/storage/src/ , class de.extio.spacecraft.mod.mp_official.arena.ArenaModule
@CompileStatic
class ArenaModule extends AbstractClientModule implements LobbyModuleGameModeSettingsView {
Client modules implementing game modes usually also implement interface LobbyModuleGameModeSettingsView to render game mode options to the player.
@Override
public void renderLobbyGameModeView(List<RenderingBo> renderingBo, MutableCoordI2 offset, CoordI2 absolutePosition, CoordI2 dimension, boolean enable_) {
boolean enable = enable_ && EngineFacade.instance().getGame().isLocalPlayerHost() && ! this.sceneUploading;
RenderingBo bo;
offset.setX(10);
// Teams
bo = EngineFacade.instance().getRenderingBoPool().acquire(DrawFontRenderingBo.class)
.setText(EngineFacade.instance().getLocalizationManager().translate("mp-35"))
.setSize(24)
.setColor(RgbaColor.LIGHT_GRAY)
.withPositionAbsoluteAnchorTopLeft(offset)
.withPositionIncrementalAbsolute(0, 10);
renderingBo.add(bo);
offset.add(230, 0);
bo = EngineFacade.instance().getRenderingBoPool().acquire(ControlRenderingBo.class)
.setId("ArenaModule_Teams_FFA")
.setType(ToggleButtonControl.class)
.setCaption(EngineFacade.instance().getLocalizationManager().translate("mp-36"))
.setTooltip(EngineFacade.instance().getLocalizationManager().translate("mp-41"))
.setCustomData(ArenaConstants.TEAMS_FFA.equals(EngineFacade.instance().getGame().getGameSession().getGameModeOptions().get("teams")))
.setEnabled(enable)
.setVisible(true)
.withDimensionAbsolute(120, 35)
.withPositionAbsoluteAnchorTopLeft(offset);
renderingBo.add(bo);
offset is a mutable coordinate that can be used to determine the current position where to render controls.
enable_ indicates whether controls should be enabled.
private final static Map<Class<? extends Event>, Integer> RELEVANT_EVENT_TYPES = ImmutableMap.of(
(Class<Event>) UiControlEvent.class, ClientModule.EVENT_PRIORITY_NORMAL,
...);
@Override
public Map<Class<? extends Event>, Integer> getEventSubscriptions() {
return RELEVANT_EVENT_TYPES;
}
@Override
public void onEvent(Event event) {
if (event instanceof UiControlEvent) {
if ("ArenaModule_Quit".equals(event.getId())) {
EngineFacade.instance().getMenuLauncher().boot();
}
else if ("ArenaModule_Teams_FFA".equals(event.getId())) {
final GameActionMessage gameActionMessage = new GameActionMessage("ArenaModule_Teams");
gameActionMessage.setParameters(ImmutableMap.<String, Object>of("teams", ArenaConstants.TEAMS_FFA));
EngineFacade.instance().dispatchMessage(gameActionMessage);
}
Like already shown in the previous example, events from interactions with controls are handled by the module.
private final static List<Class<? extends AbstractMessage>> RELEVANT_MESSAGE_TYPES = [GameActionMessage.class, ArenaInfoMessage.class];
@Override
public void onMessage(AbstractMessage message) {
if (message instanceof GameActionMessage) {
final GameActionMessage gameActionMessage = (GameActionMessage) message;
if ("scene_transfer_complete".equals(gameActionMessage.getAction())) {
this.sceneUploading = false;
}
else if ("scene_transfer_progress".equals(gameActionMessage.getAction())) {
this.sceneProgress = ClientEntityDetailsSupport.decimalFormat.format(((Double) gameActionMessage.getParameters().get("p")).doubleValue() ** 100.0) + " %";
}
}
else if (message instanceof ArenaInfoMessage) {
this.arenaInfo.warmup = message.warmup;
this.arenaInfo.finished = message.closed;
if (message.endsAt != null) {
This module also handles messages, which are in this case coming from the game server.
GameActionMessage is the preferred way to exchange any kind of information between client and server (and vice versa) that is related to game logic.
ArenaInfoMessage is a game mode specific message sent by the related game server module to update the arena state on the client side.
@Override
public void runAfterEvents(List<RenderingBo> renderingBo) {
if (EngineFacade.instance().getGame().getLocalPlayer() == null || ! EngineFacade.instance().getGame().getLocalPlayer().isInGame()) {
return;
}
if (this.arenaInfo.warmup > 0) {
this.renderWarmup(renderingBo);
return;
}
This is where the client side game mode logic is implemented. Please note that the run* methods are called at any state of the game, also in lobby. Therefore there is also a check implemented whether the local player is already in game.
private void renderWarmup(List<RenderingBo> renderingBo) {
CoordI2 viewPortDim = EngineFacade.instance().getRendererControl().getEffectiveViewportDimension();
RenderingBo bo = EngineFacade.instance().getRenderingBoPool().acquire(DrawFontRenderingBo.class)
.setText(EngineFacade.instance().getLocalizationManager().translate("mp-49"))
.setSize(128)
.setAlignment(DrawFontRenderingBoTextAlignment.RIGHT)
.withDimensionAbsolute(viewPortDim.getX() - 20, 130)
.setColor(RgbaColor.WHITE)
.setLayer(RenderingBoLayer.TOP)
.withPositionAbsoluteAnchorTopLeft(0, 140);
renderingBo.add(bo);
bo = EngineFacade.instance().getRenderingBoPool().acquire(DrawFontRenderingBo.class)
.setText(this.arenaInfo.warmup.toString())
.setSize(96)
.setAlignment(DrawFontRenderingBoTextAlignment.RIGHT)
.withDimensionAbsolute(viewPortDim.getX() - 20, 130)
.setColor(RgbaColor.WHITE)
.setLayer(RenderingBoLayer.TOP)
.withPositionAbsoluteAnchorTopLeft(0, 280);
renderingBo.add(bo);
}
This is an example how the client modules gets a countdown rendered before the battle starts. Absolute rendering positions are always in reference resolution 1080p (1920x1080), so you don't need to take the actual screen / viewport size into consideration. This is then scaled transparently by the renderer.
The full example can be found in the game folder under ./mods/mp-official/storage/src/ , class de.extio.spacecraft.mod.mp_official.arena.ArenaServerModule
@CompileStatic
class ArenaServerModule extends AbstractServerModule {
Server modules extend AbstractServerModule
@Override
public ServerModuleType getServerModuleType() {
return ServerModuleType.GAME_MODE;
}
Server modules implementing game mode specific logic should return the correct type. These modules will then be activated and disabled together with the game mode.
It must also be defined in the game mode section of mod.xml, see mod.xml setup
@Override
public void onActivate() {
final GameSession gameSession = ServerFacade.instance().getCurrentGameSession();
gameSession.getGameModeOptions().put("teams", ArenaConstants.TEAMS_FFA);
gameSession.getGameModeOptions().put("victory", ArenaConstants.VICTORY_TIME_LIMIT);
gameSession.getGameModeOptions().put("limit", "10");
// ...
There are usually certain initializations necessary when the module is activated. See also getGameModeOptions()
private void setupShipSlots(GameSession gameSession) {
int slots = gameSession.getShipSlots().size();
int div;
switch (gameSession.getGameModeOptions().get("teams")) {
case ArenaConstants.TEAMS_2:
div = (int)(slots / 2);
break;
case ArenaConstants.TEAMS_4:
div = (int)(slots / 4);
break;
case ArenaConstants.TEAMS_FFA:
default:
div = 1;
break;
}
for (int i = 0; i < slots; i++) {
GameSessionUnprivilegedControlMessage gameSessionUnprivilegedControlMessage = new GameSessionUnprivilegedControlMessage();
gameSessionUnprivilegedControlMessage.setShipSlotTeam(Integer.valueOf((int)(i / div) + (i << 16)));
ServerFacade.instance().publishInternalMessage(gameSession, gameSessionUnprivilegedControlMessage, false);
}
}
This example shows how to manipulate ship slot properties with GameSessionUnprivilegedControlMessage.
Setting the team is special because it contains the ship slot index as well as the team number in one word - the first 16 bits contain the team number and the remaining ones the ship slot index.
private void loadShips(GameSession gameSession) {
String shipFullName = StorageDefaultLocations.PLAYER_SHIPS + "/arena/arena_" + (selectedShip % 4) + ".xml";
Optional<CompositeEntityDefinitionMessage> shipDefMessage = SHIP_CACHE.computeIfAbsent(shipFullName, {
String path = StringUtils.substringBeforeLast(shipFullName, "/");
String name = StringUtils.substringAfterLast(shipFullName, "/");
List<StorageItemDescriptor> descriptors = ServerFacade.instance().getStorageManager().query(null, name, null, null, path, false);
if (CollectionUtils.isNotEmpty(descriptors)) {
return Optional.ofNullable(ServerFacade.instance().getStorageManager().loadObject(descriptors.get(0), false, CompositeEntityDefinitionMessage.class));
}
return Optional.empty();
});
CompositeEntityDefinitionMessage shipDefMsgCopy = new CompositeEntityDefinitionMessage(shipDefMessage);
shipDefMsgCopy.setShipSlotIndex(i);
ServerFacade.instance().publishInternalMessage(gameSession, shipDefMsgCopy, false);
This snippet is a condensed version of how to load ships to a ship slot that players can join programmatically.
@Override
public void onGameSessionUpdatePlayers(GameSession gameSession) {
if (this.arenaState != null) {
this.updateTeams(gameSession);
this.publishArenaState(gameSession);
}
}
This method is called when a player joins or leaves the game session.
private void loadScene(GameSession gameSession) {
Scene scene = null;
String arena = (String) gameSession.getGameModeOptions().get("arena");
if (ArenaConstants.ARENA_CUSTOM.equals(arena)) {
scene = this.scene;
}
if (scene == null) {
String sceneFullName = StorageDefaultLocations.PLAYER_SCENES + "/arena/arena_" + arena + ".xml";
String scenePath = StringUtils.substringBeforeLast(sceneFullName, "/");
String sceneName = StringUtils.substring(sceneFullName, scenePath.length() + 1);
scene = SCENE_CACHE.computeIfAbsent(sceneName, {
List<StorageItemDescriptor> descriptors = ServerFacade.instance().getStorageManager().query(null, sceneName, null, null, scenePath, false);
if (CollectionUtils.isEmpty(descriptors)) {
throw new RuntimeException("Scene not found: " + sceneFullName);
}
Scene loaded = ServerFacade.instance().getStorageManager().loadObject(descriptors.get(0), false, Scene.class);
loaded.setLabel(sceneName);
return loaded;
});
}
SceneLoader sceneLoader = ServerFacade.instance().getBusinessObject(SceneLoader.class);
sceneLoader.load(scene, ImmutableCoordI2.zero(), ClearMode.ALL);
}
This is a good example how to load a scene.
First we need to create an entity definition for our entity.
@CompileStatic
public class StorageDisplayEntityDef extends StructureEntityDef {
@FieldDescription("Tileset position half full")
private CoordI2 tilesetHalf;
@FieldDescription("Tileset position full")
private CoordI2 tilesetFull;
Entity definitions define static properties of an entity (in the entity editor) and are independent of the entity implementation. For example all different kinds of laser weapons are just different definitions in the editor of the same implementation.
@CompileStatic
public class StorageDisplayEntity extends StructureEntity {
Our example extends StructureEntity, which is in most cases a good choice. Please check the class tree of entities to decide which base class suits best for your use case. Please note that although it's only weakly bound, the entity definition must also extend the counterpart StructureEntityDef. Mixing incompatible definitions and entity types has undefined effects.
private StorageDisplayEntityState storageDisplayEntityState;
@Override
public void create(final UUID uuid, AbstractEntityDef entityDef, int entityDefIdx, UUID parentCompositeEntity) {
super.create(uuid, entityDef, entityDefIdx, parentCompositeEntity);
this.storageDisplayEntityState = StorageDisplayEntityState.EMPTY;
}
@Override
public void update(AbstractEntity other) {
super.update(other);
if (other instanceof StorageDisplayEntity) {
this.storageDisplayEntityState = other.storageDisplayEntityState;
}
}
This snippet shows how a field is initialized (create()) and updated.
It is required to initialize fields in create() instead of using just a field declaration because it is also called for certain special operations on an entity like copies or resets.
update() is an incremental update, usually when receiving data from the server to the client. Entities are updated incremental and can also have a transient state, therefore the client cannot just replace an existing entity with a new instance from the server but has to merge it. In particular the merge logic is implemented by the entity itself in update().
It is also advisable to do an instanceof check, because update() is also called when converting an entity from one type to another. With these instanceof checks this mechanism can then keep fields that are compatible to both types (e.g. common parent classes).
private transient int clientDrawActiveFrames;
@Override
public void localInit(AbstractEntityDef entityDef) {
super.localInit(entityDef);
this.clientDrawActiveFrames = 0;
}
This is an example of transient fields. Transient fields are not transferred between server and client.
localinit() is called on client and server side when the entity is added initially to EntityManager
It is required to initialize transient fields in localInit() instead of using just a field declaration because it is also called for certain special operations on an entity like copies or resets.
Check the API reference for AbstractEntity and it's sub-classes to learn more about possible overrides, event handlers and run methods.
To use your entity in the game, usually you also need to define it in the entity editor. The entity editor loads like the game client all mods at startup, so it should display your new entity after it has been deployed with the mod to the game folder.
Posted by on No comments
I have successfully founded my sole proprietorship (yes, this takes 3 months in Germany and no, I don't need a dumpster for my business!) and am now registered in the Steamworks Developer Program.
The game is now in release candidate state and will probably release end of November!
Posted by on No comments
By clicking on one of these links, you are leaving this web site!
Responsibility for the content of external links (to web pages of third parties) lies solely with the operators of the linked pages. No violations were evident to us at the time of linking. Should any legal infringement become known to us, we will remove the respective link immediately.
| Year | Description | Link |
| 2023 | Gameplay Trailer | https://youtu.be/0cgLKpo-sDs |
| 2023 | How to create scenes (levels) | https://youtu.be/YypyebMDrlc |
| 2023 | How to create mods | https://youtu.be/P-ty9cu-oC8 |
| 2023 |
Playlist: Campaign Normal Run All Missions |
|
| 2023 | Campaign Speed Run (Recorded pre-release) |
https://youtu.be/50z1JIIZIuQ |
| 2023 | Playlist: Campaign Hard Mode Run (Recorded pre-release) |
| Year | Description | Link |
| 2018 - 2023 | All music is produced by myself, enjoy! |
| Year | Description | Link |
| 2022 |
Technical Presentation about the game. |
https://youtu.be/RlJRBo442dY |
| Year | Description | Link |
| 2017 | Path Finding Demonstration | https://youtu.be/X7nCCHHFOOY |
| 2017 | Viewports, First Development Version | https://youtu.be/exHX95IRVWw |
| 2017 | Asteroids Armageddon Test | https://youtu.be/WjzNuoJgxLs |
| 2017 | First Playable Network Test | https://youtu.be/Xn_Aj9jtNA8 |
| 2017 | First version of meshes and fields | https://youtu.be/KYHcN8VxER0 |
| 2018 | Consoles. Engines | https://youtu.be/Wum9F_zivDs |
| 2018 | Update September 2018 | https://youtu.be/U-rmfT6spMM |
| 2019 | Spaceship Editor | https://youtu.be/xLT18ftOujg |
| 2019 | AI, August 2019 | https://youtu.be/3ZODnNmEuGk |
| 2019 | Weapons, October 2019 | https://youtu.be/KX5h96CEVo4 |
| 2019 | Scene Editor | https://youtu.be/KOkVcOpjnEA |
| 2020 | Mission Prototype | https://youtu.be/n3UbQ3r9qYI |
| 2021 |
Last Outpost Campaign, October 2021 |
https://youtu.be/fsCHTaB7oMw |
Posted by on No comments
The game is now feature complete!
In the past months I did a lot of playthroughs of the compaign, taking care that the game feels like I intend. This of course includes balancing and bug fixes, but also testing the game on different PC platforms (from recent high-end AMD and Intel PCs to a 15 years old Windows 7 PC) and doing game optimizations to make sure that the game will run on all of these platforms well. Of course also tested it on different operating systems, including all Windows versions from 7 to 11 and various Linux Distributions of similar ages.
Additional game modes have also been implemented:
I also finished other items on my list like global highscores and finishing the Mod SDK that will be shipped with the game.
I still have to do more testing and I also need to take care of legal aspects and prepare everything that is needed for publishing.
It will still take some time until the game can finally be released, but it will be definitely this year!
Posted by on No comments
Hi,
the creation of game content reached an important milestone:
The campaign can now be played from the beginning to the end!
There is still a lot more to do, especially side quests need more content. Other than that, my focus will shift from creating content to a lot of play testing to fix any glitch I can find and also to polish game balancing.
I still can't tell when the game will be released, but it's getting closer!
Page 3 of 3, totaling 23 entries