Ars Militaris

Ars Militaris

Welcome to Ars Militaris.

Download

Windows

MacOS (not available yet)

Linux

This Week in Ars Militaris #1

This week marks a return to the development of Ars Militaris. This means that development has now restarted and is now undergoing.

This also marks the beginning of our new development lifecycle, which is week-based, and will contribute to bring about weekly updates, both to the game and to our community. One of these new updates is this very newsletter, which will serve to keep you informed about all the recent developments in Ars Militaris.

This newsletter will be published by email to subscribers and will be made available for the public at Ars Militaris' web site (http://arsmilitaris.com).

What is Ars Militaris?

Ars Militaris is an in-development Turn-Based Tactics game set in the Ancient Rome era. It is inspired by Tactics Ogre, which is by many people considered to be the pinnacle of the genre. With Ars Militaris, we intend to provide a Turn-Based Tactics experience like Tactics Ogre, while at the same time providing a modern game experience. We also have planned features that are beyond the scope of the original Tactics Ogre games, which will bring about several new aspects of gameplay to the game.

More will be revealed about Ars Militaris in the upcoming weeks.

Current state of the project

In late 2022/early 2023, work started on a new Ars Militaris prototype, with a new engine. After some failed attempts last summer to develop the back-end engine for Ars Militaris in the R language, the focus switched to using the Bevy Engine and the Rust programming language.

The switch to Bevy brought about significant progress in the project, as it is a proper game engine, and its Entity-Component-System (ECS) architecture is ergonomic and allows one to be productive.

So, right now we're developing version 0.1 of Ars Militaris with Bevy. Ars Militaris 0.1 will be the first release of Ars Militaris. It shall serve both as a PoC (Proof of Concept) as well as allowing us to test our recently established development lifecycle. It should provide a playable version of Ars Militaris, containing a single-player tutorial (codenamed "Ambush") and the capability to play multiplayer battles, with a lobby system. The opponents can either be AI or human opponents.

We're aiming for a release for Ars Militaris 0.1 at the end of the month of July.

Stay tuned for more Ars Militaris news.

This Week in Ars Militaris #2

In this week, significant progress has been made, even if doesn't translate into the visual aspect of the game.

Update to Bevy 0.11 and deploying to server

Instead, developments were made regarding the infrastructure of the project, including updating the current Ars Militaris prototype to use the recently-released version 0.11 of Bevy, and deploying our prototype server application to a real server, and connect to it using our game clients.

These developments required a lot of learning and also solving important bugs that arised due to the new interactions between client and server when communicating on a real network. One of the learnings was setting up a easy way to build and deploy the server application. Because this application is to run on a Linux server, and our development environment is a Windows machine, when we tried to cross-compile the server and ran into errors, instead we used WSL2 (Windows Subsystem for Linux 2) to compile the application natively for Linux, and then also used it to deploy it to the server using the `scp` command. With this setup, with just two commands (`cargo build --release` and `scp ...`), we can build a release and deploy it to the server. This setup is very useful as it allows us to be more productive in testing the application.

Our new email: [email protected]

We now have an email address to which you can communicate to, and from which we will send our newsletter (including This Week in Ars Militaris) to subscribers. You can now see it listed in the **Contact** section of this page.

New test release

With a new Friday comes a new Ars Militaris release. At least that is the goal of our development lifecycle. And this week we have a new release which, as we said before, may not be the most visual appealing, but represents an important step in the project, where a real Ars Militaris client can connect to the Ars Militaris server running on a real server.

This means that this release is "playable", in the sense that you can start the game and enter an Ars Militaris battle. The game even supports multiple players, with two of them actually playing the battle and the rest spectating.

But don't be fooled, there is still very limited interaction and content available. It is more of a test of the viability of the current architecture, and so far the results have been promising.

Also, currently the server only supports one battle at a time, and has to be restarted every time the battle finishes. So, even if you download the game from the button above, you may find that you can't connect to the server as it may not be available. But you can contact us and we can set up a playtest session. We would greatly enjoy that.

Conclusion and next steps

This was a very important week, as it dealt with foundational aspects of the project. With these in place, we can now progress in the direction of adding more gameplay features to the prototype. So by next week we should have more significant developments to show.

We should also note that we were successful in following our development lifecycle, as we managed to put in at least 4 hours of daily work, and have a release on Friday.

Stay tuned for more Ars Militaris news.

This Week in Ars Militaris #3

This week has perhaps been one of the most productive weeks in Ars Militaris history. We made significant progress in various aspects of the game.

Integrating `bevy-inspector-egui` and `bevy_console`

The progress that has been made has been made possible by the integration of the `bevy-inspector-egui` and `bevy_console` plugins.

Adding these plugins and connecting them to the existing architecture increased our productivity to new levels. With `bevy-inspector-egui`'s WorldInspector and ResourceInspector, the game data is easily viewable and manipulated right in the game. And with `bevy_console` we now have a fun way of communicating with the Ars Militaris architecture.

The addition of these two plugins also marks the start of the creating of the Ars Militaris Editor, which will be used to create the content for the game, such as the single-player scenarios and campaigns.

"Ambush" single-player scenario

We made slight progress in the creation of our first single-player scenario, codenamed "Ambush". Now, when a player presses the 'M' key at the Main Menu, they will be presented with an Ars Militaris scenario consisting of a map (20x20 grid), and two teams (Carthaginians vs Celts).

Keep in mind that this scenario is not playable yet. But, the player can now interact with it using the tools mentioned above. They can use the WorldInspector to issue new `UnitAction` commands, or also do this using the Ars Militaris console (which is built on top of `bevy_console`).

The currently available `UnitAction`s are the `DoNothing`, `Talk`, and `Move` `UnitAction`s.

Ars Militaris Demo

Work has started on creating the Ars Militaris Demo, which, as inspired by Tactics Ogre, starts playing upon the player being idle for a long time while in the Main Menu. This demo is a short demonstration of an Ars Militaris battle, and it is not interactable. Instead, it is more of a showcase.

To create this demo, some new features were required to be developed. This is good, because these features will also be useful for the other aspects of the game. For example, we are now developing our first animation, the animation for the `Move` `UnitAction`, which, for now, consists of the unit "sliding" to its new location.

Linux release

We now have a Linux build of the game available for download at the top of the web site.

It has not been tested on a proper Linux system, only on WSL2 (Windows Subsystem for Linux) running with graphics support (WSL2g).

We would welcome playtesters for the Linux version.

Stream and YouTube channel

We started the Ars Militaris YouTube channel for all the content related to Ars Militaris and its development.

Right now, this channel serves as the host for our livestream of Ars Militaris development. And soon we will be publishing much more content that we have planned.

Check it out at @ArsMilitarisDev

Contributing back to Bevy Engine

As much time was spent developing Ars Militaris this past few weeks, and the level of knowledge about Bevy Engine and its usage has increased, the opportunity has come to contribute back to Bevy. As it is an open-source project that welcomes contributions, it makes complete sense if one is using it, to support it. And we will soon make our first contributions to Bevy Engine. These will come mainly in the form of documentation contributions, but also a contribution to a PR of a new feature of Bevy.

This feature is the `log_to_file` functionality, and the PR is #5342. We found a solution to the issue of capturing "panics" in a Bevy application. We believe that this functionality is a very important one, and that it would be good if it would be included in Bevy.

We are now using this feature, which required us to use our own patched version of Bevy. Having accomplished this is a result of the aforementioned increase in the understanding of Bevy, and of Rust.

Conclusion and next steps

Because this week has been so productive, we are feeling really good about Ars Militaris right now. We have the fundamental stepping stones in place to build the project upon. This means we are confident that we can release Ars Militaris 0.1.0 at our planned time (in about two weeks).

We also have some surprises in store for you, that will be revealed at next week's issue.

So, stay tuned for more Ars Militaris news.

This Week in Ars Militaris #4

Good Friday everyone. We start this issue with two pieces of information: the first one is that this issue of This Week in Ars Militaris will be the biggest one until now. The second is that we are postponing the release of Ars Militaris 0.1 by one week. We will explain why.

Postponing 0.1 release by one week

In the first issue of This Week in Ars Militaris, we stated that we were aiming for an Ars Militaris 0.1 release at the end of July. We have now decided that our release schedule will follow our weekly development lifecycle, so it makes sense to publish it on a Friday. We also want the latest version of Ars Militaris to be ready in time for when the players finish their workday and decide to play some chill games. With this, we thought that, while the current development has progressed steadily, and we added a lot of features to the prototype, it would be better to postpone the 0.1 release to the 4th of July, so that we could have more time to polish it and, basically, make the current prototype look and behave more like a proper game.

This adjusment will prove very beneficial as it gives more time to Ars Militaris to be presentable, so that in the end the players can enjoy it more. But, this doesn't mean we haven't made progress. You'll find out more about it in the later sections of this issue.

Now, if you're curious to know more about the developers of Ars Militaris, pay attention to the following two pieces.

About Ars Militaris Dev

Ars Militaris Dev ("amdev" for short) is the company/organization developing Ars Militaris. It was founded by its Lead Developer (who you can get to know in the following section) in September 30th 2014 (in the spiritual realm, not as a legal entity). During this whole time its single goal has been to develop Ars Militaris, but we have not been active for some years. We have quite an history already. As it is quite long, we will be starting to publish some History of Ars Militaris articles, in several parts, in the next issues.

For now, it suffices to say that we are based in Lisbon, Portugal, have consisted of two members for the past 4 years, and are currently thrilled and enjoying one of our most productive periods in the project's history.

About the Lead Developer

Assalamu Allaikum. My name is Raoul Abdullah (born Raúl Cardeira), a 30-years-old Portuguese born in France. Ever since my childhood I have had three main interests: 1) playing football (soccer) with my brother and friends and eventually in some football teams; 2) gangsta rap music, which my brother introduced me to when he bought his first Eminem and 50 Cent CDs; 3) computers, mostly playing games.

Perhaps the best way to start this story is with a story in itself. When I was a child we had a PlayStation 1. That was where I first played Tactics Ogre: Let Us Cling Together. I don't even know how I got the game, because I don't remember buying it. I immediately loved this game, and started playing it. Eventually I had reached about Lvl 17 with most of my units (the game has a Lvl limit of 50). But, something very bad happened. My brother, either accidently, or on purpose, either deleted or overwrote my save of the game in the memory card. I think that he can have done that on purpose, because he wasn't that much into this type of game, the only games he played were the ones related with football (like Pro Evolution Soccer and Football Manager), and he also played some wrestling games (he was a fan of Booker T), and he sometimes did things just to annoy me. I was so angry, it was one of the times that I remember being the most angry towards him. Ever since then, I haven't been able to play Tactics Ogre past Lvl 10 or so. I always play my favourite part of the game (which is the beginning), and then stop, for some strange reason. Sadly, my brother passed away 10 years ago from suicide. It has been very hard to deal with that. But, I now view this event of him having deleted the save as a memory of him, and as such I feel his presence, and enjoy it. I really miss you bro! Luckily, I still have two more brothers. Without them, I would feel much more lonely. But I think that soon I will be ready to finally overcome this and go through a complete playthrough of Tactics Ogre, as it is something that I want.

I was a normal, regular gamer, which enjoyed Strategy, Simulation and City-Building games, but then also got into some competitive games like Counter-Strike 1.6, where I was part of a clan for a while, and then League of Legends, where I am a Warwick/Trundle Jungler in Silver elo (my highest has been Gold), and Age of Empires II (multiplayer), where I fight for my position as a top #10000 player, with a sick one-trick strategy with the Portuguese civilization which involves lots of Battering Rams.

But when I first got the idea for Ars Militaris, and decided that I could develop it (even if it was a far too ambitious project), I started to learn programming and learning about game development. The first engine I got to know was Unity, but it took about three years until I finally succeeded in learning to program and create my first prototypes for the game.

Eventually I was finding some success with these prototypes, being able to create more and more features of the game. But I knew that my programming skills were not high, and I was starting to face difficulties such as high memory usage of the prototype due to some bad code. And at some point, when I tried to implement networking into the prototype for the multiplayer aspect, even though I had some initial success, for other, personal reasons, I got side-tracked from the project.

At this time, I was working as a Support Engineer at a software company. This company encouraged learning, and this is when I really started to get more deep into Computer Science. I read interesting articles on HackerNews daily and discovered a lot of concepts, tools, and other things related to computers. This is when I first got to know Rust, and I also discovered the Amethyst Game Engine.

I followed the Amethyst project for some years, but always felt that it was not very beginner-friendly, even if I didn't test if properly myself. So I didn't try to develop Ars Militaris with it, as I didn't even know Rust at that point.

And then I discovered Bevy, from its announcement on the Amethyst forum, and also from the "Elephant in the room" post. I don't know any of the details of what happened between Bevy and Amethyst, as I stopped following the projects for some time after that.

It was last year, when I got motivated to develop Ars Militaris again. By this time I had developed some systems for the game using the R language. I was having some success with that, but the time came to develop a front-end for the game. I initially tried with a simple, no-game-engine, HTML + JavaScript front-end. But while it worked, it was very limited and not good enough. So, I finally decided to try out Bevy. And I was amazed by how easy it was to get started with using the engine. That's due to the ergonomic aspect of Bevy, which is very well developed.

Eventually, around January this year, I moved out of the R backend, and created a new back-end with Bevy. And with these setup (Bevy client <-> Bevy server), for the first time I was able to have the Ars Militaris prototype with a working multiplayer aspect (using the `bevy_quinnet` plugin). This was a major achievement for the project, as it meant that we could move on, as that stepping stone was already in place.

So, for the last 6 months I have been, on and off, developing Ars Militaris fully with Bevy. By now, I have accumulated some experience, and am fairly confident in saying that I now consider myself an intermediate Bevy dev. I am happy with the current state of Ars Militaris, even more having in mind the fact that it was developed by an amateur, self-taught programmer.

So, that's it for an introduction. Regarding my interests other than Ars Militaris, you would think that my football career is over, after the many injuries (both physical and mental) that I've suffered. But I feel that my days in football are not over, and I have some surprises prepared. And regarding gangsta rap, I also have some suprises in store. I also still try to play some chill games of Age of Empires or League of Legends to cooldown from Ars Militaris development.

Contributions to the community

In this week we also bring you the work we have done that resulted in contributions to Bevy Engine or the wider community.

Bevy Timer example

When the time came to develop the first animation for our game, namely, the animation for the `Move` `UnitAction`, which consists of the unit "sliding" from one tile to the next, we had necessity of using Bevy's `Timer`s. It took some learning to understand that the `Timer`s have to be ticked, but once that was learned we started to make good use of them. But, while going through the `timer.rs` example in Bevy's repository, we came across an inconsistency or even mistake in the documentation for the `print_when_completed` system. It stated that this system would tick the `Timer` component on every entity in the scene. But this was not correct, as this system only ticks the `Timer` on entities with the `PrintOnCompletionTimer` component. So, we created a PR to Bevy with our suggestion of a modification to the documentation of this system. In our proposal the documentation clearly states that this system will only tick the `Timer` on entities with the `PrintOnCompletionTimer` component.

This was our first PR ever, and we're pretty proud of making our first contribution to open-source. With it we learned how to use GitHub for that, which included learning that you can edit the source code of a project right in GitHub. The PR is PR#9290 in case you're interested.

Bevy Cheatbook Windows Window icon page

If you've visited our web site or downloaded the game, you might have noticed that we now have a new icon. This new icon was produced from the main Ars Militaris logo, and it is to be used for the executable icon, as well as the Window and Taskbar icon. In order to configure Bevy to display the new icon, we also followed Bevy Cheatbook's page (https://bevy-cheatbook.github.io/platforms/windows.html) on producing a good looking release for the Windows platform. For us, it was very important to see how far Bevy could go in producing this good looking release, with a nice icon. And we were very happy to find that Bevy can produce a very good looking release of a game. Perhaps even the most beautiful aspect of Bevy is how the release can contain only the executable and the `assets` folder. And doesn't even need an install. So, we're thrilled by this simplicity.

When following the Bevy Cheatbook's page, we noticed that it wasn't updated to be in accordance with Bevy 0.10, namely, with the Windows-as-Entites feature that was introduced in this release. But we were able to adapt the example to the recent version of Bevy. With this, we decided that we could contribute back to this book with our suggestion of an update. But when the time came to do that, we first took a look at the existing PR in the book's GitHub repository, and found out that there was already a PR (PR #212) with this update, and with a better solution that ours. So, this was another learning, that one should always consult the existing Issues and PRs to see if that specific aspect is already being worked on.

Bevy `log_file`

When we started testing the release builds of Ars Militaris, we were soon faced with a difficulty, namely, the fact that if one is running a release build on Windows, if the application crashes, the debug console that is opened when the game launches is close immediately, leaving the user with no option to inspect the logs of the application.

Also, another time when we met the same issue was in deploying our Ars Militaris server application. If one has the program running in the background, we couldn't find a way to view the logs of it. So, we needed the ability to capture the log here again.

Facing this, we decided to explore the options for logging the Bevy output to a file. And exploring Bevy's Issues and Pull Requests, we found out Issue #5233, which describes exactly this aspect of Bevy, and proposes a solution, and then we also found PR#5342, which contains an updated `LogPlugin` for use in Bevy that can save the logs to a file. We also found yet another solution, by the devs of the Digital Extinction game. With this options, we decided to try to use the one proposed in PR#5342.

We were able to integrate this PR into our project, but for that we had to do some nifty `git` usage, in order to understand which was the specific commit of Bevy that that PR was on, and how to then ensure that we could update it correctly. With `git` we were able to check if the files modified by this PR had themselves been modified by any Bevy commit after that date.

There was only one problem remaining, though. If the Bevy application encountered a `panic`, it would still crash and the `panic` wouldn't get captured by the log to file functionality. At this point, some help from ChatGPT turned up to be very valuable: a simple solution for capturing panics, called a "panic hook". With the following line, at the beginning of the `main()` function:

std::panic::set_hook(Box::new(custom_panic_hook));

we set a `custom_panic_hook`, that then can be just:

// Logging
fn custom_panic_hook(info: &std::panic::PanicInfo) {
    // Perform any necessary logging or error handling here
    error!("Panic occurred: {:?}", info);
}

In this way, `panics` are correctly logged to the log file. This is a good solution for now, but we are of the opinion that this functionality should be included in Bevy's `LogPlugin` by default. There's one caveat to this implementation, though. We don't know how the "panic hook" could be included in the `LogPlugin`, as it should be placed at the beginning of the `main()` function. So, we currently don't know how this can be done.

Inspecting the State Resource with ResourceInspector

After some time using `bevy-inspector-egui`'s `ResourceInspector`, we had the idea that if it can inspect any Resource in a Bevy app, it could be used to inspect and manipulate the current state of the States our game. Because these States live in the `State` Resource, we could just use the following line:

.add_plugin(ResourceInspectorPlugin::>::default())

And we would have a `ResourceInspector` for that State. Doing this required patching the `state.rs` file in the `bevy_ecs` crate, so that the `State` type would be made reflectable. After doing this, the `ResourceInspector` showed up correctly in our game. And it allowed manipulating the current state. There's one caveat to this though. If one manipulates the state using this inspector, the `apply_state_transitions` system of Bevy will not run, so the state transitions, namely, the `OnEnter()`, `OnTransition()`, and `OnExit()` schedules will not run.

At this point, we realized one more thing. If the changing of States is done through the `NextState` Resource, we could also have a `ResourceInspector` for it. And this one would allow us to manipulate the current state and have the state transitions occur. So we did the same as we had done before with the `State` type, but now with the `NextState` type. Unfortunately, we weren't able to have it displaying correctly in the `ResourceInspector`, as it displays the message `Option::Some has unconstructable fields. Consider adding #[reflect(Default)] to - amclient::GameState`. Even though we have added it. We think the problem is that `NextState` contains an `Option` and we don't properly know how to deal with that in `ResourceInspector`.

But, as a workaround, we think it is not difficult to implement a custom Resource, that will contain the same data as the `State` Resource, and have a `ResourceInspector` for it with a button to trigger the running of the `apply_state_transitions` system. But we still haven't got around to try to implement this.

A word for Nu Game Engine

As part of our contributions, we decided to start financially supporting an open-source project. So, we became Sponsors of the Nu Game Engine. We would like to share word about this engine, as we believe it is a really cool project.

As the developer of Nu states, "The Nu Game Engine is the world's first practical functional 2D and 3D cross-platform game engine. Built in F#, it offers a declarative Elm-style programming API, as well as an algebraic ECS programming API for additional scalability. Nu offers a path to a future where game developers are liberated from imperative, OO game programming style. After nearly 10,000 commits, the implementation has matured enough to prove both the efficacy and viability of functional programming techniques in games in terms of performance, programmability, and reliability. Nu currently utilizes SDL2, OpenGL, Aether 2D Physics, and Bullet 3D Physics."

We have been following Nu for some years, and have recently tried it out, including testing some of its example projects. We were impressed by the quality of these projects, especially the OmniBlade game demo. We become interested in Nu due to our interest in Functional Programming, and actually think that we found out about Nu with a Google ("functional game engine") search.

Our decision to become Sponsors is motivated by our ideals in the sustainability of projects in which we believe in. And the fact is that Nu could use some help in this regard. We initially had thought of supporting Bevy, but we saw the fact that Bevy is already receiving substantial support from its current Sponsors. So, we decided that Nu was more in need, and that our Sponsorship would better be directed to them.

So, if you are interested in Functional Programming, or are curious about this engine, you can just check it out (https://github.com/bryanedds/Nu).

New Ars Militaris features

New assets for "Ambush" scenario

For our first single-player scenario, which will serve also as a Tutorial, we were in need of some assets, namely, for two units: a Celt Archer, and a Celt Musician. So, we took the steps to produce. Currently, our method of developing the assets for Ars Militaris is top-secret. But it resulted in producing these two needed assets.

We are yet to use these new units in Ars Militaris, but you can already see them, by downloading the game and visiting the `assets` folder.

First animation (Move)

In this week, we developed the first animation for Ars Militaris: the animation for the `Move` `UnitAction` of the units. It consists on the unit "sliding" from one tile to the next tile.

To develop this animation we made use of Bevy's `Timer`s, and also had to face some difficulties with the z-ordering of the units when the movement is occurring.

You can check out this animation by starting the current "Ambush" prototype, opening the Ars Militaris console by pressing the '\' (Backslash) key, and using the `move` console command. For example, try out the following commands in sequence:

move 1 2 1
move 1 3 1
move 1 4 1
move 1 5 1
move 1 6 1
move 1 6 2
move 1 6 3
move 1 6 4
move 1 6 5

We will explain the `move` command. The first parameter (in the sequence above, its value is 1 every time), is the `UnitId`, which represents the unit to move. In this case, we are moving Unit 1 every time. The second parameter is the X coordinate of the destination tile. And the last parameter is the Y coordinate of the destination tile (keep in mind the tile array is 0-based).

With the above sequence, you should see the first unit sliding across the tiles. Note: Please don't try to have an unit move diagonally. If you do, you will probably see some z-ordering bugs, as units are not supposed to move diagonally in Ars Militaris.

Second State: `TurnState`

In one of our days, while we were streaming, a viewer showed up and we talked a bit about Bevy States and how they are so useful. They said they were using two States in their game, one for the main state of the game and another for handling the turn logic of the game.

Inspired by this, we implemented a similar solution for Ars Militaris, to handle the turn logic in single-player battles. So, we now have a `TurnState` responsible for handling this aspect. This way of using Bevy states is very useful as they are orthogonal to each other. So, modifying a state won't change the other (unless you specify it).

With this implementation, a player can now, when in the "Ambush" scenario, press the 'T' key to end the current unit turn. The game will automatically move on to the next unit, and start its turn.

If the unit whose turn it is is controlled by the AI, the game will start an AI turn. And with this we move on to the next section.

First AI

This week also marks the time where the first AI for Ars Militaris was started to be developed. Right now, this AI is really a prototype AI, basically, an only knows how to do one action, which is to make a movement in the -X (negative X) direction (which corresponds to West in the game), and then end its turn.

So, if you try out the "Ambush" scenario, and end all your units' turns by pressing 'T' eight times, you will see the AI playing their units' turns. Once the AI has played all its units turns, it will be time for the human player to play his turns again.

There are many ways to build an AI for a game, and we don't have any experience in that. We think that this simple AI is called a rule-based AI. We will soon be looking into how we can expand this AI. But we are already very proud of this achievement.

Ars Militaris Event #1

Last Friday, we hosted the first Ars Militaris Event of this new era of Ars Militaris. We hosted it at our friend's car shop, TougeWorks.

The Event consisted in the following: we brought our pristine physical prototype (a board game version of Ars Militaris), and hosted a playtest session with our friends. This is because the current prototype of the board game version of Ars Militaris is already playable.

The playtest session went smoothly, even if it took some time to properly explain the rules and have them understand them before starting to play. But once the rules were understood and the battle set up, it didn't take long for the players to play their turns, and the battle finished in about 30-45 minutes of playtime.

It had been a long time since this physical prototype version was played. And the feedback was very positive, and some friends which hadn't yet had the opportunity to play the game, did enjoy it. So, we are planning more Ars Militaris Events. Ideally, we would host one Ars Militaris Event per weekend. But we don't promise it will be possible.

Unfortunately, no pictures were recorded of this event. We could have some nice photos of the "pristine" Ars Militaris prototype, which is very good looking. This is something that we will change. In the following events, we will record some battle logs.

The next Ars Militaris event is planned for tomorrow afternoon, and it will happen at the Conflux store. Again, we will be hosting some playtest sessions with our friends. We'll make sure bring some nice pictures this time.

Conclusion and next steps

The past few weeks have been incredible for Ars Militaris. We have achieved progress in various aspects of Ars Militaris. Perhaps we could make faster progress if we advanced in one single direction at a time, instead of dividing our attention between different aspects of Ars Militaris, but it is important for us that we are building Ars Militaris in accordance to what we have envisioned.

We are hoping for another productive week, which will result in the release of Ars Militaris 0.1. We have a lot of new features listed that we want to develop. But it is important to control the feature creep.

As a reminder, this is what we are planning for Ars Militaris 0.1:

• Main Menu
• Single-player "Ambush" scenario
• Multiplayer battles in one scenario (only available by directly talking to the devs)

We are dropping the lobby feature for now, as we feel it will require some more work, and we will instead delay it for the Ars Militaris 0.2 release.

So, we hope you have enjoyed this longer issue. Stay tuned for more Ars Militaris news.

This Week in Ars Militaris #5

Good Friday everyone. This week’s issue will be mostly focused on Ars Militaris and the actual game aspects. We have already covered other areas of its development, and now the time has come for it to properly be taken into attention.

But, first, we start this issue with a declaration.

Ars Militaris Declaration of Independence

We couldn’t stop noticing that we made a mistake in last week’s issue. We stated that Ars Militaris 0.1 would be released on the 4th of July, but July was already gone and we wanted to have said 4th of August. But, as the 4th of July marks the Independence Day in the U.S., we will now take this opportunity to add another step of our own history.

So we’re announcing the Ars Militaris Declaration of Independence.

We thus hereby declare that Ars Militaris Dev will forever be an independent games studio. This is in continuation of our past history as independent game developers. We went through a long journey already, and had some experiences with the games industry, including with other studios, developers, or even publishers.

With these experiences in mind, and having considered what’s best for Ars Militaris, we have decided that we will remain an independent studio, and will strive to follow the path of other independent games like, for example, EverQuest.

We do realize that this will mean that we will have to handle several more aspects of the game ourselves, but we believe that this decision will utimately be the best for Ars Militaris.

Ars Militaris 0.1 Release

Now that we’re over with the Declaration of Independence, let us talk about another great moment, which is the release of Ars Militaris 0.1. As we had stated before, this version is intented to primarily serve as a Proof-of-Concept for our game. And we’re thrilled to announce that we are satisfied with the current state of it, as we believe that it shows the basic mechanics of the game to prospective players.

So, Ars Militaris 0.1 is currently available for release (at the Downloads section of this website), for Windows and Linux platforms. We will soon have the MacOS version ready as well.

So, what is contained in this release:

1. Main Menu
2. Single-player Ambush scenario (battle against AI)
3. Multiplayer scenario prototype (only available upon request to the devs)

This release is the result of the solid work that has occurred in the past 5 weeks, that has built on top of the work that had been done in the previous 6 months with the start of the development of the Ars Militaris architecture.

Instructions for playing the game

Download the game from the website, extract it and read the README.md file.

Start the game by double-clicking the amclient.exe executable.

You will be presented with the Main Menu. You have four options:

1. Demo (the Ars Militaris demo, which is a showcase of Ars Militaris consisting of a simulated battle, but which is not available yet)
2. Ambush (single-player battle against AI)
3. Multiplayer (multi-player battle prototype only available upon request to the devs)
4. Quit (to quit the game)

We would wish that you start by checking out our demo, but unfortunately we couldn’t get it ready for this release. Instead, you can start by choosing the Ambush option. You will be presented with the Ambush scenario, where you will control a squad of 8 Carthaginian soldiers (7 Libyan Spearman and 1 Libyan Captain) against 8 Celt Naked Fanatics (6 Spearman and 2 Swordsman).

When the scenario loads, the game will enter the WaitTurn state, which is a central mechanic of Ars Militaris. In this state, every unit’s WaitTurn attribute is decreased by 1, and if a unit’s WaitTurn becomes 0, that unit gets the chance to have its turn. This is the way turns are decided in Ars Militaris.

The WaitTurn state will take some time to execute, but once finished it will be the first unit’s turn, which in this scenario corresponds to your first unit. You will be presented with a Cursor, that you can control with the ‘WASD’ keys. This cursor is very important as it is the main form of interaction with Ars Militaris at the moment.

We should also note that you can move the camera by moving the mouse to the edge of the window, this will allow you to navigate the battle environment.

So, now you’re in a unit’s turn. What can you do? You can do three things: you can issue a Move UnitAction, to move your unit, or you can issue a BasicAttack UnitAction, to make a basic attack against another unit, or you can issue a EndTurn UnitAction. The keys for these commands are the ‘M’ key for the Move UnitAction, the ‘F’ for the BasicAttack UnitAction, and the ‘T’ key for the EndTurn UnitAction. The two first commands follow the same implementation: first you press the desired key, and the possibles tiles that you can move to or attack will show up. Then, move the cursor to the desired target, and press the command key again. The command will be executed if possible. At any time, you can press ‘Escape’ to cancel the showing of the move or attack tiles. To end the current unit’s turn, you simply press the ‘T’ key (while not in the state where you choose the target attack or move tile).

Ars Militaris Basic Combat System

In order to attack an unit, you have to be at range. You can check a unit’s range by pressing ‘F’ and seeing the tiles which it can attack. We will assume that you want to attack an enemy unit. So, make your movement towards an enemy unit.

Now, if you’re at range to attack, and decide to make an attack against another unit, the following will happen: your unit (the “attacking” unit) will make a basic attack against its target. It will do a certain amount of damage, which is visible in the game logs (in the black console window that shows up beside the game when you start it). If the target unit dies, the combat is over. If not, the target unit will automatically make a counter-attack against the initial attacking unit. Once it has done its counter-attack, the combat is over. This counter-attack mechanic is a fundamental feature of Ars Militaris.

What we just explained is valid for the Melee type of combat. For the Ranged combat type, there is only one difference, namely, that units that have a Ranged AttackType won’t make counter-attacks.

Whilst right now the game has an almost completely absent UI regarding the combat and damage statistics, the most visual indicator of combat is the fact that units will change their direction to face their target/attacker. With this, you can verify that the basic attacks are working correctly. Also, the fact that when an unit dies, it will get removed from the battle.

Another rule: once a unit has made both a BasicAttack and Move UnitActions, its turn will automatically be over and the game will move on to the next unit. But this rule isn’t implemented in the code yet, so you are free to make as many moves and basic attacks as you wish with one unit.

So, right now the Ambush scenario consists of this battle. The winning condition is the good-old “Kill’Em All”, in which you have to kill all enemy units to win the battle. If all your units die, you lose. Either on winning or losing, you will be taken back to the Main Menu.

Multiplayer scenario prototype

We were hoping to have our multiplayer scenario ready for this release. For that, we were hoping that we could use the existing architecture we developed for the single-player battles, for the multiplayer ones. But this will require some adaptation of the systems that compose the battle, and we haven’t been able to do it yet.

The current multiplayer scenario prototype only features a grid of 10x10 tiles, and a cursor that can be used to navigate this grid. What is most important is that this prototype already has the ability for an unit to end its turn by pressing the ‘T’ key, and the game will move on to the next unit, just as in the single-player version.

But that’s basically the one single-feature of the multiplayer prototype. More mechanics will come soon.

So, that’s pretty much it for the Ars Militairs 0.1 release. We are happy that it at least provides the ability to play a single-player battle against a simple AI. That is already enough as a PoC. We hope you give it a try, and if you do, that you enjoy it as much as we do.

Other Ars Militaris News

Ars Militaris Discord server

We now have a Discord server, which you are free to join if you want to have a closer point of contact with Ars Militaris. We link it here Discord and also have linked to it in our new “Socials” section at the bottom of the website.

Inclusion in This Week in Rust

It is with great pride that we inform that issue #4 of This Week in Ars Militaris was accepted to be included in This Week in Rust. This Week in Rust is a weekly newsletter containing updates from all-around the Rust community, and it is an honor to be included in such a well-reputed publication.

Scaling Ars Militaris Development

While it has been very positive that we have managed to put in daily work towards Ars Militaris, and that it has resulted in the solid development that has occurred, we realize that Ars Militaris development is currently hindered by the fact that we have only a single dev working on the game.

Thus, we have took some steps towards changing this, with the goal of increasing our output in terms of the development and management of the game and all its aspects.

So, we have started to look for more Co-Founders to join Ars Militaris Dev, which will contribute with their expertise and skills towards the development and management of Ars Militaris.

We have already found two more Co-Founders, which is great, and are actively looking for more still, as we realize Ars Militaris is an ambitious project and it would be good if it has the necessary resources to grow.

And this leads to our next announcement…

Open-sourcing Ars Militaris

It is with great joy and excitement that we announce that Ars Militaris has now been open-sourced. This means you are free to explore the project’s code, on its GitHub repository.

We will explain a bit what this means for Ars Militaris, and how the open-source model fits our business model.

Ars Militaris will be a free-to-play game. This means you will be able to play the game without spending a single cent, if that’s what you want. This also means we will freely distribute the client for the game, so that you can access your Ars Militaris account, which is going to be the central point of interaction of the players with the game.

We open-source our game in an effort to make it more “free” software (“free” as in “free speech” and not in “free beer”, but we will also include some free beers in the offer). So, you will be able to inspect the game code for any analysis you want to make, be it for learning purposes, security audit, or other reasons.

There’s one caveat to our open-sourcing the game, though. The right to use the code will be granted on a use-case basis. This means that if you want to use the code for any endeavour which is not listed on the project’s LICENSE.md, you will have to ask us for permission, and we may refuse it. We plan to be very generous, though, and we are only reserving this refusal option for cases where we feel Ars Militaris could be hurt.

So, please go check out the project at our GitHub: amclient and amserver. We are still configuring the repository, but soon we will be starting to accept contributions.

Conclusion and next steps

This has been a action packed week. Unfortunately, our work management and productivity were not the highest in this week, which meant that we couldn’t achieve some of the goals we had set for Ars Militaris 0.1, such as the Demo or an improved AI, or a gameplay video.

But, we still could deliver a working PoC for Ars Militaris, and that is enough to make us feel good.

Now, with the open-sourcing of Ars Militaris and our search for more Co-Founders, we hope that we can increase the available resources for Ars Militaris, to ensure that its development continues progressing steadily.

With this, we can announce that we will now start working on Ars Militaris 0.2, which we plan to release in about a month. We will be announcing its features in the following weeks.

Overall, we continue thrilled and enthusiastic about the future of Ars Militaris..

We hope you enjoyed this issue. Stay tuned for more Ars Militaris news!

Socials

Discord

Contact

[email protected]