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)
  

Progress of AntiChess

AntiChess is the first on the list of Java open source games I wanted to improve. It has been abandoned for a long time (since 2003) and it looks like a small enough game to get into the improvement of Java based games.

I took the CVS from 2003 and had previously converted it to Git already. It used Ant as build system but I could quickly upgrade it to use Gradle and with a JDK version 11 (from AdoptOpenJDK) I could easily run the game and after some adoption also the tests. That remarkable, fully working backwards compatibility of Java is always very nice to see.

The game and tests were 8.8k lines of code (LOC) initially and with using code analysis features from IntelliJ and some optimizations I could reduce that to 7.6k LOC without changing the game even a single bit (I hope at least). 10% reduction is a typical value at this stage. While I was at it, I also re-arranged the package structure, converted constants to enums, encapsuled public variables with getters and setters, improved names of variables and fixed common spelling errors (with project wide search and replace in IntelliJ this is quite easy).

Now the difficult part begins. I really have to understand the code to further optimize and improve it. One big thing is that the computer opponent seems to evaluate moves but does not perform a move in time. Additionally, the differentiating between a 2-player and a 4-player game could be done much better. There is only one inheritance (for pieces) and there definitely could be more Interfaces (for the evaluator, for the engine, for the player, ...). Moves should be immutable, I think, but they aren't and I want to find out what is currently holding them back from being immutable. It's currently not clear if AntiChess could also play normal chess. I want to find out.

The graphics is relying on Java Swing, which is a quite old framework and doesn't look so shiny. However, I will not change that, only nicely separate the user interface from the rest of the game. This is definitely something that will remain for somebody else.

And I published the updated version of the game under the GPL-3.0 license (was MIT). That is a more restrictive license, but I definitely like it more for end user applications.

Review of Evil Cult

Evil Cult is an open source, turn-based strategy game mainly programmed by Max Kowarski (infidel-). It can be played in the browser, for example at www.in-fi-del.net/static/cult/index.html. The programming language is Haxe and the sources are available on Github, the game is licensed under the GPL-3.0 license. The game is in a mature state and playable, but also still actively developed. One special feature is that this game (or a more enhanced version) is also commercially available on Steam for PC.

Playing Evil Cult in the browser

 I like it a lot and think it is a quite enjoyable strategy gem. The screen output is text-based, with the network of cultists taking up the main part of the screen. Resource and other important information is on the left and menus for managing sects and getting information about cults are on top. The interface is very clean and easy to understand and use, the layout is agreeable. A nice little detail are the hilarious sect names as well as cultist names.

The game mechanics is all about growing the network of follows of your own cult (there are computer controlled opponent cults) with special emphasis on resource generating individuals, defending them by having at least 3 links to each of the resource generators, staying undetected (low awareness of the cult), defending against investigators and finally with the help of advanced cultists and the resource "virgins" performing the Final Ritual before anyone else does. This means that the game poses quite a strategic challenge while also offering an interesting fresh setting.

A single game lasts about 30 minutes (~30 turns) and may depend somewhat on luck, i.e. the availability of resource generators close to the starting position as well as the absence or presence of an investigator in the early turns, however, if one keeps a low public profile (awareness ~5%), expands quickly to gather a lot of "virgin" resources (which can be converted to the other resources at a favorable rate) and focuses to get rid of investigators early on as well as sacrifices sects on level 2 for resources, it can be won on all difficulty levels.

The only thing I miss would be a multiplayer mode. I imagine that playing against other human opponents could increase the appeal of the game even more.

I can strongly recommend it and hope it will be improved even more in the future.

List of C++ games I want to improve

 Here is the list of C++ games I want to improve

Mature

•  54321 (Custom (a very simple copyleft see http://old.nklein.com/etc/copyright.php), 2001)
  
• Maelstrom (GPL-2.0, 2002)
  
• Pizza Business (GPL-2.0, 2003)
  
• Wargamer (GPL-2.0, 2003)
  
• I Have No Tomatoes (zlib, 2004)
  
• Nighthawk (GPL-2.0, 2004)
  
• Openglad (GPL-2.0, 2004)
  
• Crack Attack! (GPL-2.0, 2005)
  
• Einstein Puzzle (GPL-2.0, 2005)
  
• GL-117 (GPL-2.0, 2005)
  
• Sarah-Maries Eierjagd (GPL-2.0, 2005)
  
• Shotgun Debugger (GPL-2.0, 2005)
  
• Super Transball 2 (GPL-2.0, 2005)
  
• Tumiki Fighters (2-clause BSD, 2005)
  
• Xconq (GPL-2.0, 2005)
  
• Bloboats (GPL-2.0, 2006)
  
• 2H4U (GPL-2.0, 2007)
  
• Adanaxis (GPL-2.0 (non-free file in the commercial version), 2007)
  
• Armies (GPL-3.0, 2007)
  
• kiki the nano bot (Public domain, 2007)
  
• Ri-li (GPL-3.0, 2007)
  
• Attal: Lords of doom (GPL-2.0, 2008)
  
• BRIQUOLO (GPL-3.0, 2008)
  
• Gravitation (Public domain, 2008)
  
• Mtp Target (GPL-2.0, 2008)
  
• Battle Tanks (GPL-2.0, 2009)
  
• Dark Oberon (GPL-2.0, 2009)
  
• Glest (GPL-2.0, 2009)
  
• LevelHead (GPL-3.0, 2009)
  
• Primrose (Public domain, 2009)
  
• Secret Maryo Chronicles (GPL-3.0, 2009)
  
• Bombermaaan (GPL-3.0, 2010)
  
• Crimson Fields (GPL-2.0, 2010)
  
• Cultivation (Public domain, 2010)
  
• Linwarrior 3D (Apache-2.0, 2010)
  
• Passage (Public domain, 2011)
  
• Song of Albion (Apache-2.0, 2011)
  
• Super Methane Brothers (GPL-2.0, 2011)
  
• Afternoon Stalker (GPL-2.0, 2012)
  
• Conquests (GPL-2.0, 2012) 
  
• Liberal Crime Squad (GPL-2.0, 2012)
  
• Mega Mario (LGPL-2.1, 2012)
  
• PixelLight (MIT, 2012)
  
• Privateer - Gemini Gold (GPL-2.0, 2012)
  
• Toppler (GPL-2.0, 2012)
  
• TROPHY (GPL-2.0, 2012)
  
• UFO2000 (GPL-2.0, 2012)
  
• Battle City (GPL-3.0, 2013)
  
• Bos Wars (GPL-2.0, 2013)
  
• BurgerSpace (GPL-2.0, 2013)
  
• Cosmosmash (GPL-2.0, 2013)
  
• Garith (LGPL-2.1, 2013)
  
• Hex-a-hop (GPL-2.0, 2013)
  
• Key Runner (GPL-3.0, 2013)
  
• Murder In The Public Domain (GPL-3.0, 2013)
  
• Zero Ballistics (MIT, 2013)
  
• BlockOut II (GPL-2.0, 2014)
  
• Curse of War (GPL-3.0, 2014)
  
• Cuyo (GPL-2.0, 2014)
  
• FLTK Recycling Game! (LGPL-2.1, 2014)
  
• Grobots (GPL-2.0, 2014)
  
• Hovertank3D (GPL-2.0, 2014)
  
• Keen Dreams (GPL-2.0, 2014)
  
• Maxit (3-clause BSD , 2014)
  
• Scorched3D (GPL-2.0, 2014)
  
• VDrift (GPL-3.0, 2014)
  
• X-Moto (GPL-2.0, 2014)
  
• Xenowar (GPL-3.0, 2014)
  
• ativayeban (GPL-2.0, 2015)
  
• Egoboo (GPL-3.0, 2015)
  
• Freekick 3 (GPL-3.0, 2015)
  
• H-Craft Championship (zlib, 2015)
  
• Micropolis (GPL-3.0, 2015)
  
• NetMauMau (LGPL-3.0, 2015)
  
• OpenGL Test Drive Remake (GPL-3.0, 2015)
  
• OpenLiero (Custom, 2015)
  
• Open Zelda (zlib, 2015)
  
• Return of Dr. Destructo (MIT, 2015)
  
• Vulture's Eye (NetHack General Public License, 2015)
  
• Atomic Tanks (GPL-2.0, 2016)
  
• Birth of the Empires (Custom (private use allowed), 2016)
  
• Blob Wars Episode 2 : Blob And Conquer (GPL-2.0, 2016)
  
• FLTrator (GPL-3.0, 2016)
  
• Ghostly (GPL-3.0, 2016)
  
• HoverRace (Custom, 2016)
  
• OGS Mahjong (GPL-3.0, 2016)
  
• OldSkool Gravity Game (GPL-3.0, 2016)
  
• Open Yahtzee (GPL-2.0, 2016)
  
• SDL-Ball (GPL-3.0, 2016)
  
• TORCS, The Open Racing Car Simulator (GPL-2.0, 2016)
  
• xu4 (GPL-2.0, 2016)

Unfinished

• Operation Citadel (GPL-2.0, 2000)
  
• Greenius' Civil War (GPL-2.0, 2001)
  
• Apricots (GPL-2.0, 2003)
  
• Cannon Smash (GPL-2.0, 2003)
  
• Cat Mother Dead Justice (3-clause BSD, 2003)
  
• Machinations (GPL-2.0, 2003)
  
• Sopwith 3 (GPL-2.0, 2003)
  
• XArchon (GPL-2.0, 2003)
  
• Colonization too (GPL-2.0, 2004)
  
• Krystal Drop (GPL-2.0, 2004)
  
• Noiz2sa (2-clause BSD, 2004)
  
• Pathogen Warrior (GPL-2.0, 2004)
  
• TuxKart (GPL-2.0, 2004)
  
• Bombic (GPL-2.0, 2005)
  
• Microracers (GPL-2.0, 2005)
  
• T^3 (GPL-2.0, 2005)
  
• Boson (GPL-2.0, 2006)
  
• GPL Arcade Volleyball (GPL-2.0, 2006)
  
• GUSANOS (GPL-2.0, 2006)
  
• OpenMortal (GPL-2.0, 2006)
  
• StarBlastrix (GPL-2.0, 2006)
  
• Brutal Chess (GPL-2.0, 2007)
  
• DreamZZT (GPL-2.0, 2007)
  
• ika (GPL-2.0, 2007)
  
• Kobo Deluxe (GPL-2.0 (LGPL?), 2007)
  
• SilverTree (GPL-3.0, 2007)
  
• SLASH'EM (Custom (NetHack license), 2007)
  
• StressFreeZone (GPL-3.0, 2007)
  
• Tactics Squad (GPL-2.0, 2007)
  
• Zatacka (GPL-2.0, 2007)
  
• Avanor (GPL-2.0, 2008)
  
• FreeRails (GPL-2.0, 2008)
   
• Freestars (GPL-2.0, 2008)
  
• Help Hannah's Horse (GPL-2.0, 2008)
  
• Mars, Land of No Mercy (GPL-2.0, 2008)
  
• Qonk (GPL-2.0, 2008)
  
• RedShift (GPL-2.0, 2008)
  
• S.C.O.U.R.G.E. (GPL-2.0, 2008)
  
• Sengoku: Warring States of Japan (MIT, 2008)
  
• Balder2D (GPL-2.0, 2009)
  
• Ball and Paddle (GPL-3.0, 2009)
  
• Brikx (GPL-2.0, 2009)
  
• Cadaver (GPL-2.0, 2009)
  
• Crown and Cutlass (Custom (almost identical to BSD), 2009)
  
• Ecksdee (GPL-2.0, 2009)
  
• Fall of Imiryn (GPL-3.0, 2009)
  
• Goblin Hack (GPL-2.0, 2009)
  
• Jamp (GPL-3.0, 2009)
  
• Bombic2 (GPL-2.0, 2010)
  
• Combat Simulator Project (GPL-2.0, 2010)
  
• Heroes of Wesnoth (GPL-3.0, 2010)
  
• Labyrinth of Worlds (LGPL-3.0, 2010)
  
• OpenAlchemist (GPL-2.0, 2010)
  
• OpenHoMM (GPL-3.0, 2010)
  
• Stargus (GPL-2.0, 2010)
  
• Zaz (GPL-3.0, 2010)
  
• Danger from the Deep (GPL-2.0, 2011)
  
• Dawn (GPL-3.0, 2011)
  
• Digbuild (GPL-2.0, 2011)
  
• The Rush (GPL-2.0, 2011)
  
• Batrachians (GPL-2.0, 2012)
  
• Cataclysm (CC-BY-SA-3.0, 2012)
  
• Fictional Air Combat (GPL-3.0, 2012)
  
• Goblin Camp (GPL-3.0, 2012)
  
• Kuklomenos (GPL-3.0, 2012)
  
• Nikwi (GPL-2.0, 2012)
  
• Peragro Tempus (GPL-2.0, 2012)
  
• splexhd (GPL-2.0, 2012)
  
• Tux Football (GPL-2.0, 2012)
  
• Critterding (GPL-2.0, 2013)
  
• Cytadela (GPL-3.0, 2013)
  
• Forsaken (GPL-2.0, 2013)
  
• Gnomescroll (GPL-3.0, 2013)
  
• Grail (GPL-3.0, 2013)
  
• HolySpirit (GPL-3.0, 2013)
  
• Limbs Off (GPL-3.0, 2013)
  
• MechCommander 2 Omnitech (MS-PL, 2013)
  
• Phantasy Star Rebirth (GPL-3.0, 2013)
  
• Teeworlds (zlib, 2013)
  
• Theme Park Builder 3D CAD (GPL-3.0, 2013)
  
• Trinity Reign (GPL-3.0, 2013)
  
• Ultimate Stunts (GPL-2.0, 2013)
  
• xBaK (GPL-3.0, 2013)
  
• Xye (zlib, 2013)
  
• Battles of Antargis (GPL-2.0, 2014)
  
• Flukz (GPL-2.0, 2014)
  
• Gusty's Serpents (GPL-3.0, 2014)
  
• Kingdoms (GPL-3.0, 2014)
  
• Knights (GPL-3.0, 2014)
  
• Open Tibia (GPL-2.0, 2014)
  
• Summoning Wars (GPL-3.0, 2014)
  
• TurokEX (GPL-2.0, 2014)
  
• Vamos (GPL-3.0, 2014)
  
• Blitwizard (zlib, 2015)
  
• Construo (GPL-3.0, 2015)
  
• Free Heroes 2 (GPL-2.0, 2015)
  
• Hardwar (GPL-3.0, 2015)
  
• M.E.W.L. (GPL-2.0, 2015)
  
• OpenCity (GPL-2.0, 2015)
  
• OpenRaider (GPL-2.0, 2015)
  
• Q-Gears (GPL-2.0, 2015)
  
• starshatter-open (3-clause BSD, 2015)
  
• The Epic of Heroes (GPL-3.0, 2015)
  
• Thunder&Lightning (GPL-2.0, 2015)
  
• Witch Blast (GPL-3.0, 2015)
  
• DNT (GPL-3.0, 2016)
  
• FreeRCT (GPL-2.0, 2016)
  
• Hocoslamfy (GPL-2.0, 2016)
  
• l-echo (GPL-3.0, 2016)
  
• M.A.R.S. (GPL-3.0, 2016)
  
• Numpty Physics (GPL-3.0, 2016)
  
• Strife: Veteran Edition (GPL-3.0, 2016)
  
• TecnoballZ (GPL-3.0, 2016)
  
• uMario (GPL-2.0, 2016)
  
• uninvited (Artistic License-2.0, 2016)
  

List of C games I want to improve

Here the list of C games I want to improve

Mature

• Hack (3-clause BSD, 1985)
• xdigger (GPL-2.0, 1999)
  
• 3Dc (GPL-2.0, 2000)
  
• ACM (GPL-2.0, 2000)
  
• Circus Linux! (GPL-2.0, 2000)
  
• XInvaders 3D (GPL-2.0, 2000)
  
• XBill (GPL-2.0, 2001)
  
• Batalla Naval (GPL-2.0, 2002)
  
• Deathchase 3D (GPL-2.0, 2002)
  
• Vectoroids (GPL-2.0, 2002)
  
• Alex the Allegator 4 (GPL-2.0, 2003)
  
• Ice Breaker (GPL-2.0, 2003)
  
• Aklabeth (GPL-2.0, 2004)
  
• Digger Remastered (GPL-2.0, 2004)
  
• Falcon's Eye (NetHack General Public License, 2004)
  
• Jump'n'Bump (GPL-2.0, 2004)
  
• Abe's Amazing Adventure (GPL-2.0, 2005)
  
• GalaxyNG (GPL-2.0, 2005)
  
• Lincity (GPL-2.0, 2005)
  
• Luola (GPL-2.0, 2005)
  
• Overgod (GPL-2.0, 2005)
  
• XBlast (GPL-2.0, 2005)
  
• ZAngband (Custom (Modifications allowed?), 2005)
  
• Linley's Dungeon Crawl (Custom (Crawl General Public License), 2006)
  
• Moon-buggy (GPL-2.0, 2006)
  
• No Gravity (GPL-2.0, 2006)
  
• Rogue Clone IV (3-clause BSD, 2006)
  
• Excellent Bifurcation (GPL-2.0, 2007)
  
• Penguin Command (GPL-2.0, 2007)
  
• Meritous (GPL-3.0, 2008)
  
• Sinatra (GPL-3.0, 2008)
  
• Slot-Racers (GPL-3.0, 2008)
  
• Defendguin (GPL-2.0, 2009)
  
• Netrek (Custom (permissive), 2009)
  
• SDL Asylum (GPL-3.0, 2009)
  
• Tornado (GPL-2.0, 2009)
  
• Tremfusion (GPL-2.0, 2009)
  
• Caph (GPL-3.0, 2010)
  
• FooBillard (GPL-2.0, 2010)
  
• LBreakout2 (GPL-2.0, 2010)
  
• Slime Volley (GPL-3.0, 2010)
  
• XPilot (GPL-2.0, 2010)
  
• XPilot NG (GPL-2.0, 2010)
  
• GNU Go (GPL-3.0, 2011)
  
• The Ur-Quan Masters (GPL-2.0, 2011)
  
• Tux of Math Command (GPL-3.0, 2011)
  
• 4D-TRIS (GPL-2.0, 2012)
  
• Biniax (zlib, 2012)
  
• FooBillard++ (GPL-2.0, 2012)
  
• GNU FreeDink (GPL-3.0, 2012)
  
• OpenArena (GPL-2.0, 2012)
  
• Rise of the Triad for Linux (GPL-2.0, 2012)
  
• SDL Bomber (GPL-2.0, 2012)
  
• Dope Wars (GPL-2.0, 2013)
  
• HHexen (GPL-2.0, 2013)
  
• LTris (GPL-2.0, 2013)
  
• c64-nuclearreaction (GPL-3.0, 2014)
  
• CatacombSDL (GPL-2.0, 2014)
  
• DarkPlaces (GPL-2.0, 2014)
  
• Dune Dynasty (GPL-2.0, 2014)
  
• SDL Sopwith (GPL-2.0, 2014)
  
• SuperFoulEgg (MIT, 2014)
  
• VMS Empire (GPL-2.0, 2014)
  
• Atomiks (GPL-3.0, 2015)
  
• Liquid War (GPL-3.0, 2015)
  
• RPG-X (GPL-2.0, 2015)
  
• The Endless Dungeons (CC-BY-NC-SA-2.0, 2015)
  
• Tile World (GPL-2.0, 2015)
  
• TwinEngine (GPL-2.0, 2015)
  
• XScavenger (GPL-2.0, 2015)
  
• Atrinik (GPL-2.0, 2016)
  
• GCompris (GPL-3.0, 2016)
  
• Nox Imperii (GPL-3.0, 2016)
  
• PrBoom+ (GPL-2.0, 2016)
  
• Sudokuki (GPL-3.0, 2016)
• Tremulous (GPL-2.0, 2016)

Unfinished

• Tux Racer (GPL-2.0, 2001)
• Anagramarama (GPL-2.0, 2002)
  
• Gem Drop X (GPL-2.0, 2002)
  
• Vertigo (GPL-2.0, 2002)
  
• Freeciv Alpha Centauri project (GPL-2.0, 2003)
  
• The Clans (GPL-2.0, 2003)
  
• 3D Pong (GPL-2.0, 2004)
  
• Gee Whiz (GPL-2.0, 2004)
  
• Open Quartz (GPL-2.0, 2004)
  
• rRootage (2-clause BSD, 2004)
  
• T-Bots (GPL-2.0, 2004)
  
• Vorton (GPL-3.0, 2004)
  
• Heart of the Alien (GPL-2.0, 2005)
  
• JFDuke3D (GPL-2.0, 2005)
  
• JonoF's Shadow Warrior Port (JFSW) (GPL-2.0, 2005)
  
• Elysium Engine (GPL-2.0, 2006)
  
• Thrust (GPL-2.0, 2006)
  
• Transfusion (GPL-2.0, 2007)
  
• Amphetamine (GPL-2.0, 2008)
  
• Duke3d_w32 (GPL-2.0, 2008)
  
• Duel Commander (GPL-3.0, 2009)
  
• Duke3D (GPL-2.0, 2009)
  
• Freenukum (GPL-3.0, 2009)
  
• Mmpong (GPL-3.0, 2009)
  
• PSY PONG 3D (GPL-3.0, 2009)
  
• BomberClone (GPL-2.0, 2010)
  
• Syndicate Wars Port (GPL-3.0, 2010)
  
• Warp Rogue (GPL-3.0, 2010)
  
• xDuke (GPL-2.0, 2010)
  
• XSera (MIT, 2010)
  
• CAVEZ of PHEAR (GPL-3.0, 2011)
  
• FreePrince (GPL-2.0, 2011)
  
• KQ Lives (GPL-2.0, 2011)
  
• Infon Battle Arena (GPL-2.0, 2012)
  
• XorCurses (GPL-3.0, 2012)
  
• Airstrike (GPL-2.0, 2014)
  
• Hnefatafl (ISC, 2014)
  
• Lips of Suna (GPL-3.0, 2014)
  
• n2048 (2-clause BSD, 2014)
  
• OpenTitus (GPL-3.0, 2014)
  
• Turious (GPL-3.0, 2014)
  
• CorEngine (zlib, 2015)
  
• erampage (GPL-2.0, 2015)
  
• FreeBlocks (GPL-3.0, 2015)
  
• Kartering (GPL-2.0, 2015)
  
• Minesweeper (in C) (3-clause BSD, 2015)
  
• Powermanga (GPL-3.0, 2015)
  
• Tenes Empanadas Graciela (GPL-2.0, 2015)
  
• twin-e (GPL-2.0, 2015)
  
• Chocolate Duke3D (GPL-2.0, 2016)
  
• Escape Towards The Unknown (GPL-2.0, 2016)
  
• Wizznic! (GPL-3.0, 2016)
  

List of Python games I want to improve

And here now the list of Python games I want to improve

Mature

• PySol (GPL-2.0, 2004)
• SolarWolf (LGPL-2.1, 2004)
• Search for the Red Herring (GPL-2.0, 2006)
• Bouncy the Hungry Rabbit (GPL-2.0, 2007)
• Slune (GPL-2.0, 2007)
• Trip on the Funny Boat (GPL-2.0, 2007)
• Frets on Fire (GPL-2.0, 2008)
• Mrfuze (LGPL-2.1, 2008)
• Ardentryst (GPL-3.0, 2009)
• LevelHead (GPL-3.0, 2009)
• MicroWar 2.0 (3-clause BSD, 2009)
• Libre: The Open Source Card Game (AGPL-3.0, 2010)
• Monsters and Mushrooms (GPL-2.0, 2010)
• Python Kye (GPL-2.0, 2010)
• Brain Workshop (GPL-2.0, 2011)
• Wizards Magic (GPL-2.0, 2012)
• OpenRPG (GPL-2.0, 2013)
• Q (GPL-3.0, 2013)
• The Bub's Brothers (MIT, 2013)
• Deity (GPL-2.0, 2014)
• Fujo (CC-BY-SA-4.0, 2014)
• Star-Wars-III (GPL-2.0, 2014)
• Freekick 3 (GPL-3.0, 2015)
• Gnome Hearts (GPL-2.0, 2015)
• Micropolis (GPL-3.0, 2015)
• PyBreak360 (GPL-3.0, 2015)
• Atrinik (GPL-2.0, 2016)
• Chess3D (GPL-3.0, 2016)
• Dungeon Monkey Eternal (GPL-2.0, 2016)
• GCompris (GPL-3.0, 2016)
• ransack (MIT, 2016) 

Unfinished

• Umbra (similar to BSD, 2002)
• Civil (GPL-2.0, 2003)
• Pathological (GPL-2.0, 2003)
• pyRacerz (GPL-2.0, 2005)
• Castle-Combat (GPL-2.0, 2006)
• OpenRTS (GPL-2.0, 2006)
• buggyGame (GPL-2.0, 2007)
• Eos, Dawn of Light: A Space Opera (MIT, 2007)
• ika (GPL-2.0, 2007)
• Magic Gardeners Tournament (GPL-2.0, 2007)
• Slingshot (GPL-2.0, 2007)
• A Planet's Revenge (GPL-3.0, 2008)
• Krank (Public domain, 2008)
• One is enough (GPL-2.0, 2008)
• Stringrolled (Public domain, 2008)
• Which Way Is Up? (GPL-2.0, 2008)
• Beat Harvester (GPL-2.0, 2009)
• Fallen Spire (GPL-3.0, 2009)
• Fall of Imiryn (GPL-3.0, 2009)
• Froggix (GPL-3.0, 2009)
• World of Heroes (3-clause BSD, 2009)
• AI Wars (MIT, 2010)
• nXtank (GPL-3.0, 2010)
• Canta (GPL-3.0, 2011)
• GalaxyMage Redux (GPL-2.0, 2011)
• Kobold's Quest 2 (LGPL-3.0, 2011)
• OpenBlox (GPL-3.0, 2011)
• OpenMOO2 (GPL-2.0, 2011)
• PyKaraoke (LGPL-2.1, 2011)
• UlDunAd (GPL-3.0, 2011)
• Artillery Duel Reloaded (GPL-3.0, 2012)
• Card Stories (AGPL-3.0, 2012)
• Celestron (GPL-3.0, 2012)
• PARPG (GPL-3.0, 2012)
• Thousand Parsec (GPL-2.0, 2012)
• Gnomescroll (GPL-3.0, 2013)
• Heroes of Wing Commander (GPL-3.0, 2014)
• Sintel The Game (MIT, 2014)
• Vamos (GPL-3.0, 2014)
• pyORPG (MIT, 2015)
• Hexoshi (GPL-3.0, 2016)
• Hypatia (MIT, 2016)
  
  

List of JavaScript/TypeScript games to be improved

 Here are the client-side Java/TypeScript games that I want to improve

Mature games

• Pendumito (GPL-2.0, 2003)
• WebHangman (GPL-2.0, 2003)
• PrimeShooter (GPL-2.0, 2010)
• RacerJS (MIT, 2010)
• Runfield (GPL-3.0, 2011)
• Skrupel - Tribute Compilation (GPL-2.0, 2011)
• Xultris (MPL-1.1, 2011)
• Candy Box 2 (GPL-3.0, 2013)
• Fluid Table Tennis (MIT, 2013)
• HTML5 Pacman (WTFPL, 2013)
• Gorillas (Java Research License (no commercial use), 2014)
• Lose Your Marbles (MIT, 2014)
• OpenRoads (MIT, 2014)
• Ball And Wall (MIT, 2015)
• 3d.city (GPL-3.0 (with additional terms), 2016)
• Chess3D (GPL-3.0, 2016)
• Consomaton (MIT, 2016)
• HexGL (MIT, 2016)
• Prescription Wars (GPL-3.0, 2016)
• skifree.js (MIT, 2016)

Unfinished

• Betrayer's Moon Tactics (GPL-2.0, 2006)
• Ajax3d (GPL-2.0, 2007)
• Arashi-JS (GPL-2.0, 2010)
• Skifree-HTML5-clone (GPL-3.0, 2011)
• BlackNova Traders (GPL-2.0, 2012)
• Card Stories (AGPL-3.0, 2012)
• CommandoJS (MIT, 2012)
• Hexwar (MIT, 2012)
• Taggem (AGPL-3.0, 2014)
• WWW (GPL-3.0, 2014)
• Aussenposten (MIT, 2015)
• BlakedAwesomenaughts (MIT, 2015)
• movbizz (MIT, 2015)
• Roguish (3-clause BSD, 2015)
• Castle of the Winds (MIT, 2016)
• lttp-phaser (MIT, 2016)

List of Pascal open source games to be improved

I decided to also delve into Pascal, as this was one of the first languages I ever programmed in and I have quite fond memories about it (from like 25 years ago). Here is the list of games I intend to improve:

 Mature

• WAtomic (GPL-2.0, 2005)
• Dragon History - Dračí Historie (GPL-2.0, 2010)
• Dungeon Monkey Unlimited (LGPL-2.1, 2010)
• FunLabyrinthe (GPL-2.0, 2012)
• LambdaRogue: The Book of Stars (GPL-2.0, 2012)
• Battle City (GPL-3.0, 2013)
• C-evo (Public domain (original project), 2013)
• Iron Seed (GPL-3.0, 2013)
• Scrabble3D (GPL-3.0, 2015)

Unfinished projects

• RPDungeon - computer aided role playing (GPL-2.0, 2006)
• Siege of Avalon : Open Source (Custom (NC), 2011)
• X-Force: Fight For Destiny (GPL-2.0, 2011)
• FAR Colony (GPL-3.0, 2014)

List of Java open source games first to be improved

In the last post I laid out the general approach of how I want to improve open source games. I wanted to start with inactive Java games. I had a look at the database and decided to first go for mature projects and then for unfinished projects. Within each group I will advance chronologically, i.e. start with those that have been inactive for the longest time (at least since 2016). The list is then:

 (format: name (license, year of last activity))

mature

• AntiChess (MIT, 2003) in progress
  
• Ladder (GPL-2.0, 2005) author updated in 2020
  
• Spice Trade (LGPL-2.0, 2005) in progress
  
• 4D Maze Game (Public domain, 2008) in progress
  
• Moagg2 (GPL-2.0, 2008) CVS + SVN history not yet converted to Git
  
• Domino On Acid (GPL-2.0, 2009) in progress
  
• ORIENT (GPL-2.0, 2009) not a pure Java project, very complex
  
• SpaceTrader for Java (GPL-2.0, 2010) there is a fork, maybe no need
• HoDoKu (GPL-3.0, 2013) many clones on Github, need to find out which one to fork
  
• Room for Change (Apache-2.0, 2013) Android (maybe later)
  
• eAdventure (GPL-3.0, 2014)
• Boulder Dash (MIT, 2015)
• Micropolis (GPL-3.0, 2015)
• Hypercube (GPL-2.0, 2016)
• JaNaG - Java Name Generator (GPL-3.0, 2016)
• Javelin (GPL-2.0, 2016)
• jewelthief (GPL-3.0, 2016)
• Mice Men: Remix (LGPL-3.0, 2016)
• Polis (GPL-3.0, 2016)
• Sudokuki (GPL-3.0, 2016)

 unfinished

• Freya Game Engine (LGPL-2.1, 2002)
• Planetary Hoppers (GPL-2.0, 2003)
• Jake2 (GPL-2.0, 2006)
• JQuest (GPL-2.0, 2006)
• FreeRails (GPL-2.0, 2008) in progress
  
• MUSoSu (GPL-3.0, 2008)
• Space Opera (GPL-2.0, 2008)
• jClassicRPG (LGPL-3.0, 2010)
• Mercenary Commander (3-clause BSD, 2010)
• Slay (GPL-3.0, 2010)
• XSwing Plus (GPL-3.0, 2010)
• Battlefield Java (GPL-3.0, 2011)
• Creep Smash (GPL-3.0, 2011)
• Blitzkrieg (GPL-3.0, 2012)
• Decker (GPL-2.0, 2013)
• DemiGod (GPL-3.0, 2013)
• Mpango (GPL-2.0, 2013)
• Rescue! Max (GPL-3.0, 2013)
• EternalWinterWars (MIT, 2014)
• Hale (GPL-2.0, 2014)
• Turn of War (GPL-3.0, 2014)
• Battleround (Apache-2.0, 2015)
• Divercity (GPL-3.0, 2015)
• FreeBlocks (GPL-3.0, 2015)
• KnightOfWor (GPL-3.0, 2015)
• Ares Dogfighter (GPL-3.0, 2016)
• Dingo-Engine (3-clause BSD, 2016)
• Team Tactics (MIT, 2016)
• Yet Another Engine (MIT, 2016)

That will be the games I will concentrate on in the next months.

How to improve open source games systematically

I'm closing in on finishing the new static website that shows the content of the open source games list quite nicely. It's built with a template generator library (jinja2) and a CSS framework (bulma), free icons and lots of links between the games, the inspirations, the developers, frameworks and information about how to improve the content. I hope I will get lots of updates of content from people seeing the site.

There are still things to improve, but I feel like I need the current version (90% ready) out.

And I like to think about what follows. I always wanted to start improving open source games (especially old abandoned ones) in a way where I apply lots of common improvements to many projects like better build or deployment system, code cleanups and other stuff without concentrating too much on the specific content and gameplay of a game. It's a kind of low hanging fruits first, cross-section, best practice, upcycling approach. Here is the plan for it:

I will concentrate first on inactive but more or less mature/finished games and will try to modernize and polish them. That will hopefully increase availability and attractiveness of them will I don't need to negotiate with other developers. I will of course touch everyone only shortly, basically leaving them ready for other developers to take over again. I will concentrate on the major languages in the following order: Java, JavaScript, Python, C, C++. Java, JavaScript and Python run on virtual machines and basically have high chances that code from the past is still runnable today without major modifications. Especially with Java I have made good experience in the past, sometimes old Java projects run out of the box. C and C++ is/was used in a majority of games. Learning and working with other languages might be nice but time is limited. Maybe some of the projects can be converted to another language (Java to Kotlin, JavaScript to TypeScript, C to C++, C++ to Rust) in the course of this work.

I imagine the following steps will be done in roughly that order:

• Check the code license. Only work if the code license is unmistakably clear open source.
  
• Getting the game to (compile and) run somehow. Fix major crashes that might occur because of the time passed since the game was abandoned. This is the most difficult step.
  
• Improve the building system (Ant, Maven to Gradle, make to CMake)
• Do a first code cleanup, remove unused code, remove unused dependencies
• Check the artwork license. Remove all artwork without a clear free license. Replace with alternatives if possible.
  
• Update the programming language version / compiler version (Python 2 to 3, Java 8 to 11)
  
• Thoroughly test the game and make a list of possible improvements. Prioritize them by effort and benefit.
• Implement the high benefit, low effort improvements.
• Minimize the number of dependencies as much as possible without major replacements.
• Update dependencies (SDL to SDL2 for example).
• Increase platform support if possible.
  
• Do a final code cleanup.
• Improve documentation and leave a list of possible further improvements.
• Put on Github or Gitlab if not yet there.
• Make a release and distribute it
• Post about it on social media

And I hope that all this takes basically not more than two weeks per game. That might be a bit optimistic.  The idea is though to exploit synergies between the projects, because the expert knowledge needed to do these improvements is not so project specific.

I will start with abandoned, mature games, then follow with abandoned, unfinished but promising games and then offer my services also to still actively developed games. For games of marginal interest, I will do only a minimal treatment, but for games that I really like, I hope I can improve them a lot actually. I'm especially looking forward to turn based strategy, fantasy role-playing, sports and racing simulations, but who knows, a simple arcade platformer can be fun too.

Wow, quite a lot of text here.

Polishing the static website takes time

 I think the largest problems with building the new static website are solved and most of the structure is in place. I can render links, icons, text, lists and combinations thereof; I have a working template system and a split of the entries in games and frameworks/tools. Games can be filtered by letter, by genre, by programming language and by supported OS platform. Additionally there is a developer index and an inspirations (other games) index, all with backlinks. The layout is kind of looking well. I use icons in an icon-font to kind of improve the visualization. So far, so good.

Now the details are still to be filled in. Adding a bit more information here and there. Choosing more icons (for the genres), improving the layout (adjusting the size of the programming languages shown according to how many entries there are for each language), creating the statistics page, filling the contributions page with content, creating a cover picture as a collage from many pictures of OS games, ... and that will still take a couple of weeks.

My new dead line, beginning of November. On the plus side: I'm really proud of how nice it looks.