QPixel is a nice open source Q&A web application

 Recently I stumbled upon the QPixel software on GitHub. It's a Q&A-based community knowledge-sharing software, that is an open source web application written in Ruby on Rails and that allows users to register, ask questions, answer other questions, edit and comment on content written by others and vote on the content. Content is then shown ordered by score with the highest voted answers and questions on top.

Example view of questions in QPixel

 It's a time proven concept of efficiently creating a knowledge base that will eventually consist of high quality, relevant information. This information is very useful to visitors of these Q&A sites.

 One of the pioneers in this area was Stack Overflow. The combination of bringing askers and experts together and at the same time measure the quality of the content by voting proved to be very fruitful. Millions of visitors have profited from the knowledge stored on the servers of Stack Overflow over the years. The software that powered the platform had a tremendous impact on the success of Stack Overflow as it allowed the collaboration of users from the whole world in such a quality rated Q&A style.

One drawback was that the software powering Stack Overflow is proprietary. Here QPixel comes to the rescue. While being developed actively for 1-2 years now, I'm really impressed by the quality of it. On the outside it looks and feels like a proper Q&A platform with most of the features that a successful Q&A platform needs. Being written in Ruby on Rails it relies on an open source framework that is specialized on efficiently creating web applications. A handful of people only realized a software in the last two years that I would describe as usable. It should be a serious consideration to try QPixel as a free, open source alternative for Q&A at your location.

Indeed there is an instance of QPixel running at Codidact with a few example sites show-casing the features of the software. It seems to run relatively smooth.

I have no idea how convenient it is to setup QPixel but what I really like about it are some features like categories (sub-divisions of single site community) or different post types (Q&A, articles, wiki pages) that can be configured quite freely.

The only other serious open source Q&A software alternative (in my eyes) is Question2Answer and while QPixel feels like an open source replacement for the Stack Overflow platform software, Question2Answer feels more like an open source Quora replacement to me.

Civilization 6 falls quite short of the high expectations of a long term fan of the series

Being a long term fan of the Civilization franchise I yet had to play every part of the series. I played Civilization 1 for countless hours back in the 1990s, and then it went on and on. With much less time and quite late I now gave the latest installment in the series Civilization 6 a try. Testing it 5 years after the initial release and with all available addons/expansions should have advantages though. I expected to see beautiful graphics on a medium powered PC and a polished gameplay with lots of game features. And indeed it looks and sounds gorgeous (at least to me)...

Civilization 6 on difficulty level Immortal a few turns before a science victory without any war at all

I totally buy in the somewhat cartonish, but very polished look of the map. Exploring the map, improving the land, expanding cities with special areas, all that has been fun to me. And I really like the title music. And the terrain generator is really great with so much detail, especially in the naming department.

Nevertheless, I only played it for a couple of weeks, playing maybe three full games and some scenarios and I do not plan to play it any more than that. It's quite a disappointment after all. And here is why:

War is so much Civilization 1-5 (but not 6)

In none of the different attempts at playing the game, war was a big topic! It's just nothing somebody really does except maybe for some fainthearted attempts in early eras and the occasional occupation of a city state. In my last attempt on the second highest difficulty level (implausibly called Immortal) I could achieve a relatively simple science victory without firing a single shoot at anyone and I also think none of the six civilizations did so against each other. This might account to very civilized behavior (by modern standards) but feels so un-Civilization like, it's hard to digest. Actually I felt very bored over the course of the game. It's mostly some linear to exponential growth and the one with the largest growth factor wins in the end, which can quite reliably be predicted once all the areas in the world suitable for settlements are used up. And finally, it might just be me, but military units seem to be too expensive to really wage a war against strongly fortified cities and military areas.

AI opponents are not very smart and quite passive

They don't send much ships around, or settle on a second continent until very late. Or do anything much. They seem to have some agendas and if you fullfill them they're happy. War (if it happens at all) is still not their strong point. But they happily pay lots of gold per turn if you sell them a bit of diplomatic favor or other strategic ressources, even on very high difficulty levels.

Wonders of the World are a dime a dozen

There are really so many of them, in no game all players will build them all. And since they take up space (which I think is the right decision overall) it's often not a bargain to build them, their yield might be much lower than one could obtain from the tile otherwise. Some wonders are really useful and have an effect that scales favorably, but maybe only 10 of them, the remaining ~50 may give you a meagre 4 belief (really not a lot). Often enough a standard building will give a greater benefit.

Horribly, horribly imbalanced scenarios (and not much choice either)

There is a small number of scenarios included (with the base game and the two expansions) and the scenario ideas of some are quite interesting (spreading religion, peaceful expansion, fighting the plague) but the implementation is a big disappointment. Scenario lengths are too short (60 turns) and it's impossible to continue afterwards. For example the religious war scenario could be much longer. And the Plague scenario is a massive hyperbole: everyone died out (me last with about -1000 belief). That felt like an Excel sheet calculation that somehow wasn't tweaked very well.

Summary

Unfortunately, I decided to stop playing Civilization 6. It has too many major flaws to justify spending more time on it. It's surprising that a game that is that old, can appear to be so imbalanced  and unpolished. The multi-player mode (which I didn't test) might still be fun though because between humans many of the critical points listed above might not apply.

Still, it's worthwhile to ask the question: how could Civilization 6 be improved to make it much more playable than now. I think the main points would be:

• Make war more lucrative and make AIs more prone to conduct war.
• AI opponents should stop overpaying for diplomatic influence points or strategic resources.
• Reduce the number of World Wonders massively (like maybe a third of them) and increase their yields (but maybe also their production costs).
• Really polish and balance the scenarios and add more.

OSGL static website new and improved

 The web output of the OSGL (open source game list) that I maintain is now improved and public since a couple of days. You can see it at trilarion.github.io/opensourcegames as well as mirrored at osgl.twelvepm.de. It's made with Jinja2, a template engine in Python and Bulma, a CSS framework and displays the content of the OSGL database nicely (with some glitches still). It looks quite nice:

The dynamic table is gone for now and there are still some glitches. I hope to be able to improved both and tell the public about it a bit more soon. All in all there is information ~1500 open source games contained, linked to ~600 inspiration games and ~10,000 developer names. Let's see where the journey will lead the project. So far, there are quite a large number of issues still open including many things that could still be done with and to these games.

OSGL updates

 I added a couple (~50) entries to the OSGL, mostly open source Android games and updated links. I'm also working on getting a first version of the static HTML page finished.

And I'm thinking about how to deploy games that I have improved. There are a couple (~4) games that I started to improve on, but I never got around to substantially change the core mechanic of them. I cleanup up the projects and code though and now I would rather deploy them in a nice fashion before moving on.

 This was just a short update.

Java game improvement status

 I'm working on improving four long time ago abandoned games written in Java and while the progress has been rather slow in last couple of weeks compared to the beginning, I'm still making progress. I also have a better picture now regarding what can be done and what cannot. I definitely got into Java and Gradle again. Here is an unordered list of what I learned so far:

• Refactoring Java code with IntelliJ is quite simple and safe. Reflection and use of raw types (especially mixed use) can be difficult, but otherwise everything behaves very nicely and IntelliJ is a real strength in that regard.
  
• Gradle got easier over time. The plugins do more of the work with less customization needed. That is good because I mainly want to use Gradle as build system.
• Modularization of Java code is not as cumbersome as I thought. The benefits may not be large but updating old code to use modules isn't that difficult either.
• The transition from Swing as GUI framework to JavaFX isn't that bad either. It's important to clean up and simplify the GUI parts of old software as much as possible, but otherwise one can transition from one to the other quite nicely.
• Packaging and distribution of Java desktop apps is easy enough with jlint now, but the sizes of the packaged app (a 200 kb jar becomes a 100 MB bundle) are crazy. Not sure if shipping a Java runtime with each and every simple, small app is really the best way to go.
• The most time consuming factor is still understanding and refactoring the game logic. That is a task that can take weeks and is surprisingly different for every new game.
• There is demand for serialization (storing and loading) of complex structured data (game states for example) and it's not sure currently what the most convenient format is for that (JSON, XML, some custom format, Javas own serialization format...) and equally how best to serialize/de-serialize that.
  

An incredibly humbling experience

In December 2017 I started to collect information about open source game projects with the goal to build them and finally improve some of them. I thought about a one year project and maybe 200 games I would look at.

Now, over three years later, the open source games list (OSGL) contains information of ~1300 games and thousands of developers and I hardly started building and improving the games. But I can already say that I will be able to only work on a few of them, a tiny minority of all projects, which are out there. And it will take years, if not a decade. And lots of new projects will be started in the mean time.

Reflecting on this gave me the following (maybe familiar) feelings

• We are so small! 
• The world is so big!
• And so complex!
• Only by working together we can actually achieve something significant!
• We are like ants!
• Organization is everything!
• It's so humbling!
  
• It's not the individual, it's all team work!
  

Ant nest - Taken from Andrew Gustar on Flickr (licensed CC BY-ND)

I will continue to plow that field, but with a renewed sense of what it means to work together and what can be achieved really (need to prioritize even more). One thing becomes clear however: Organizing ourselves is the key to make use of us most efficiently. Open source game developers should strive to even better connect themselves.

The frustration that inevitably follows the initial euphoria

So I had this 10-15 year old open source game projects written in Java (AntiChess, SpiceTrade, Domino On Acid, 4DMaze) and I could quickly get them to run again and build with Gradle and I could do easily some static code analysis and throw out redundant stuff, fix deprecated code usage and reduce the overall amount of code, all without changing anything how these games looked or worked.

But now I have spent something like 20-30 hours (not really counted, could even be more) and frustration sets in. Mostly because

• There is no visible progress. I simplify the code base and write documentation and tests, but the resulting game itself does not change even a single bit. I realize how far I'm from making substantial edits.
• Real understanding of the code takes so much time. I have only gained superficial understanding of 4DMaze and Domino On Acid, no understanding of SpiceTrade and half-understanding of AntiChess so far. It really takes time to read the code, to understand possible side effects and to plan and conduct meaningful changes.
• I realize how much work it would be to make substantial changes (not only minor fixes). I do not plan substantial changes for 4DMaze and Domino On Acid, so these two might see an official new release sooner. AntiChess is more work than anticipated, the 4 player mode is only doing random moves and the 2 and 4 player modes do not harmonize very well currently. SpiceTrade I would like to do something, but it has this inbuilt scripting engine that is outdated.
• With this speed (which is probably a much more realistic estimate of how much time it takes to "improve" old games) I will never finish the hundreds of games I would like to engage with. I might need to give up on that dream and do some serious prioritization.
• It's easy to break things and the test coverage is far below 100%. More often than I would have liked, I need to go back and revert changes in order to not break the apps badly. Generification is a potential source, adding final is another one (when reflexion is used somewhere else in the game).
  

 That's all not really a reason to give up and there is still hope that I will get faster over time and can use synergies. I'll surely become a better Java programmer in this phase.

Added 10,000 developers to the OSGL

 I finished gathering data automatically from the Sourceforge and Github projects in the open source games list and that greatly expanded the number of developers listed.

 With more than 11,000 developers now I could even crosslink some names (if the names are similar and they work on the same game or have similar nicknames) but mostly it's guesswork to follow accounts over different code hosting platforms like Sourceforge, Bitbucket, Github and Gitlab. The Git commit emails might give me more insight, but since an accurate account of the developers of open source games was never really the main aim, I think I will leave it at that for the moment.

The main goal here was to fill the planned static web page with as much content as possible with reasonable effort before finishing it.

Multithreading in game improvements

 I looked at many more of the Java games that I potentially want to improve and I could strike out some of them because they are too complicated or the sources have not yet been converted to Git. A thorough search also resulted in some of them already having some form of continuation. I'm left with maybe 10-15 projects. The question is how many of them I want to work on in parallel.

I want to work on more than one of them simultaneously to not get bored, less risk of getting stuck and to use synergies effectively. I don't want to work on all of them simultaneously to actually finish some of them. Obviously there is an optimal number.

For the time being, I will try ~6 as that number: AntiChess, Spice Trade, 4D Maze, Domino on Acid, Boulder Dash, Java Name Generator and Polis.

P.S.: Work got me again after the Christmas and I understood that so many projects are too many. So I reduced the workload to 4 (AntiChess, Spice Trade, 4D Maze and Domino on Acid).

Progress of Spice Trade, 4D Maze and Domino on Acid

I started with a couple of old, abandoned Java games more (Spice Trade, 4D Maze and Domino on Acid) and I got quickly past the initial stage. I could easily convert them to build with Gradle. Only Spice Trade did not immediately start but after specifying updated dependencies it did and I could easily run static code analyses on these projects and improve a couple of things without really changing how the programms work.

Start screen of Spice Trade

Interesting is that they all have about the same size (8-12k lines of Java code). That might be kind of a sweet spot in terms of what can be achieved and what is manageable and codeable within a reasonable time by a very small team or single person.

I identified issues that are common and I hope that I can exploit lots of synergies there and improve many games (apps) at the same time. The list includes:

• Localization with properties and resource bundles
• Swing (they all are based on Swing) helper utilities and UI modularization
• Persistent options/settings storage.
  
• Display HTML based help/documentation pages.
• Storage/serialization of game state data.
• Deployment of the apps for various OS systems.
• Logging support
• Meaningful tests
• Adapting display size to modern screen resolutions (full screen mode)