October is finished and it was a great month.
clockUtils 1.1 is already finished, but I need to build and upload the linux packages before the official release will come. But GitHub is already updated and the download section contains the source package and the Windows prebuilt packages for Visual Studio 2013 and 2015, both in 32 and 64 bit as usual.
The most important changes are better ini parser capabilities to query some informations about the contained data, better socket performance and a new LockFreeQueue implementation in our container library. The full changelog can be found on the changelog page.
Already released this month was the SocketPerformanceChecker 0.9. I also have some local changes for it that aren't on GitHub yet. That's only stuff to make the whole toolchain support Visual Studio 2015. I'll update the repository soon, still working on some improvements there.
For i6engine I fixed some GUI related bugs I found during the work on Elemental War. It works now much better.
I also started the work on a new tool for i6engine called TakeControl. It willl allow to handle the synchronisation of spoken texts very easily. There is actually just a GUI prototype without any functionality, but it will go on.
The main menu GUI is mostly complete now and I fixed some more bugs. There are just a few bugfixes and tests missing for the internal singleplayer alpha.
September over, almost reached some big milestones. Lets see, what we have done this month.
I haven't done that much for i6engine, but it was important. Most games might use some kind of animated textures. Think of a 2D games using sprites. In my case I need for an unannounced game and for Elemental War, which will provide some animated cursors. So this month was focussed on the support for easy to use animation using i6engine's GUI API.
Cwizz' open beta is almost finished. Only some small tickets here and there are open and the GUI has to be reworked for a better scaling on different devices, especially with different DPI. This will take a while, but we will release Cwizz soon for Android, Windows and Linux. This first release will contain only German questions, but we will add English ones as soon as possible.
If you have cool question ideas, you can create own questions in the browser version of our QuestionManager created by Michael, that will go live tomorrow I hope. Have to test it and maybe fix bugs that might still be in there. I'll write a seperate news for this.
Elemental War made also some good progress. The singleplayer alpha is almost finished. Next week I'll get the textures for the new main menu, cursors and more. On code side just a few fixes and testing are missing. The singleplayer alpha will go to some friends to get feedback about gameplay. The three singleplayer modes Elemental War contains are completely integrated and only will be extended by some more content like more items, textures, objects and small features, but no big game changes anymore (except my testers will find something that has to be changed).
After this internal release the work on the multiplayer will begin. I already thought a lot about it and it will become really cool.
Besides those three projects I did a lot for our test infrastructure. I set up a continous integration framework a while ago and added many jobs and could already find some bugs in different projects. Not all are tested yet, but at least the most recent ones like i6engine, Cwizz, Elemental War and clockUtils provide many tests to be as save as possible.
That's all for now. I hope one of the next news will be the release news for Cwizz.
Hey again. Another month has passed and more goals have been reached although I was a little unproductive this month especially because of the heat. But nevertheless here the newest progress report.
clockUtils 1.1 makes really good progress. This month I got MinGW on Windows running. The trick was to use the mingw64 distribution as it supports std::thread. I had to perform some minor changes, but now it also compiles using MinGW. Besides this there aren't breaking news. I completed some other small tickets like the possibility to remove entries from ini files and added some asserts to check valid states in debug mode (e.g. during the unit tests).
As it still belongs to clockUtils, SocketPerformanceChecker is mentioned at this place again. Maybe I'll seperate it to an own project also on the homepage some time. SPC got a new statistic representing the throughput. I thought this might be more useful than the current durations as one can directly see now how many messages with a given size can be sent per second. Also the SPC now displays all results in form of a LineChart. Looks great so far in my opinion. Code for it already on GitHub.
i6engine came off badly this month. I didn't even write the news for i6engine 1.0.1 release although it is on GitHub for some weeks now and also on the homepage. There were several bugs I found during my work on Elemental War, so I decided to bring this update. Besides this I fixed another bug in the Splash screen on Windows as it wasn't always on top. Now it is. The other changes were things like integration tests now stopping itself automatically and removing lua code and added it as dependency instead.
m2etis now builds all its dependencies itself during call of cmake. But the major improvement was done for the performance. While it is still not as fast as I want it to be I could improve the performance by around 25%. That's good so far. The main problem now is the slow serialization. I think I'll either look for a faster solution than boost or write one myself for clockUtils.
Yeah, here I got many things done. I fixed all bugs I'm actually aware of and finished a lot of other tickets. These included some content like new monster abilities, but also new features and optimizations. Especially the new item system was started. It's nearly the last feature missing for the singleplayer alpha I want to start this year. Actually there are five feature tickets left and some other optimizations, content and test tickets I want to finish before the alpha. So I'm in time.
Another good message: An old colleague of mine who already worked with me on most of my old Gothic 2 modifications helps me with textures now. He creates the level textures for some of settings and also for new tower models. And for tower models I now also have a contact. So also the graphical side make progress now.
These were the breaking news. There would be more about Cwizz, but therefore I'll have to create the homepage first. But to spoil a little: I set up a concrete roadmap for the open beta of the German language version of Cwizz and it will comes this year!
Wow, the first half of the year is already over. In this time I got so many things done and the latest progresses you can see in this news.
You might have seen it already, I released clockUtils 1.0.0 this month. It's a big step as it is our first major release. I added some new features for that release like the possibility to perform a DNS lookup for our sockets or improved argument parsing. The complete changelog can be found here.
Since the release I started work on version 1.1. The core feature will be extended compiler support. I already added an official toolchain for clang on Linux. This already worked, but gtest for our unit tests wasn't built with clang but gcc instead, so that's changed now. Actually I try to get it built on Windows also with MinGW, but that's rather tricky as there isn't ONE distribution, but many different ones, and I haven't a version that works and supports std::thread. But I have a now trace, so maybe I get it done soon. The other feature for the next release will be some improvements for our ini parser. I added support to query all sections of a configuration file and for every section all available entries. I thought it might be useful, but hadn't a use case for this before I implemented it, as all entries we use in our projects are known in the project and we didn't need dynamic accessing. But just a few days after I implemented it I saw that it will ease the implementation of a feature for Cwizz.
Together with clockUtils 1.0.0 I tagged version 0.8.0 of my SocketPerformanceChecker on GitHub. I mention it here as I developed it as benchmark and compare tool for our sockets. The results are really good.
Meanwhile I also added support for Qt sockets and also for m2etis. m2etis isn't a socket implementation so it basically will always loose against them. But it is a very good possibility to profile m2etis and compare it to raw sockets. Actually it is really slow, but I haven't added performance optimizations now.
i6engine got also release 1.0.0 this month. Also this release was the first official one so far. I don't want to go in detail about the release here, all necessary informations can be found here.
Since the release I just did some small things like upgrading the dependencies (clockUtils, m2etis, CEGUI, boost, OpenAL Soft). As it was requested on Twitter, I also added a small gallery with some screenshots from the tools we provide. You can find it here.
Because I found some new bugs during my work on Elemental War I'm going to release an update to version 1.0.1 after this sprint, this means Sunday in a week, July 10th.
m2etis 0.5.0 hasn't made many progress so far, but the good thing is, that I started work on it again. I already profiled it using my new SocketPerformanceChecker and found some bottlenecks. I fixed some of them and have many other ideas how to improve the performance. So lets see, what I can get out of it.
And of course also Elemental War made some good progress. I did a lot of refactoring to improve the code quality. That took a while, but it's much easier now to implement new features, fix bugs and more. I also improved other elements like the presentation of stats of towers and opponents and added many new features.
After many years of work I'm proud to be able to announce the official release of i6engine.
i6engine is a game engine started at Friedrich-Alexander-University Erlangen-Nuremberg as a student project. After I visited the practical and worked on it, I took it over together with Michael. This first release is a really basic version, but it already provides a lot of nice features. I have three different kinds of games running on it to test different requirements. For Elemental War I already launched the game page. It's a 3D tower defense game with both single- and multiplayer, so it will use our network library and many GameObjects. It would be nice if some of you would also give it a try.
I'll provide more tutorials and maybe a full project devlog in the near future.
The next version 1.1 will contain some updates for our dependencies like CEGUI and OpenAL Soft. Then I need some more features for my game projects like projective decals and shadows for terrains. As I don't know anything about graphics programming this might take a while unless I don't find someone to take care of the graphics subsystem. The main feature will be a Mover editor in our level editor to create complex Movers directly within it and preview them.
The full source code is available in our download section and also on GitHub. Our download section also contains prebuilt packages for the libraries and if you just want to test our samples, then you can do that too.
This month I got a lot of different things done.
While the code for clockUtils 1.0 was already finished, a logo, an icon and a small performance tool were missing. I'll get the logo and icon tomorrow as I can't create them myself, but I started writing the performance tool. The basic framework is already finished and six different socket implementations are available to be tested. Although there are still some crashes and it wasn't tested yet on Linux the results are really nice: clockUtils tcp async beats boost::asio tcp socket and both modes of clockUtils' udp socket beat boost::asio udp socket. I still have to test a bit and fix the remaining bugs, but I think the tendency is clear.
The complete code for the performance tool can be seen in the official GitHub repository at https://github.com/ClockworkOrigins/SocketPerformanceChecker.
The release of clockUtils 1.0 is scheduled for Sunday.
i6engine also got a lot of attention. I fixed all remaining bugs and added the last features for the upcoming release of i6engine 1.0.
The ParticleEditor now allows to define a box to visualize the size of a particle. This will help to get a good scale for new particles so there is no need to rescale them ingame.
While there are already a lot of plugin interfaces for our level editor, I now added the possibility to write plugins to insert own types of objects. As an example plugin I wrote one to insert NPCs for the RPG module.
During the work on the new GUI of Elemental War I found out that it wasn't able to set the default font to be used by the GUI. This option is now available.
And the last big feature was a way to be able to scale the size of a MovableText depending on the distance between camera and text. Therefore a callback can be provided which is called and shall determine the new size.
Actually there are just four tickets left. Three of them are for the logo, the icon and two textures that have to be replaced before release while the last one ist for the tutorials page on the homepage.
The release of i6engine 1.0 is scheduled for Sunday next week.
Elemental War now is public. I unlocked the homepage and uploaded a first screenshot with the new GUI being implemented. Beside this I added a lot of new stuff and fixed many bugs. The progress is really good. The only problem is that I still need some graphics guy, but I hope I'll find someone in the near future.
That's all for now, but you'll read me soon again as there are two upcoming releases within the next two weeks.
Another month has passed and the list of progresses is short. That's because I had to finish my master thesis. I hope I can do more for the projects now.
clockUtils again got some improvements for its argument parser library. Now it is possible to create new variables marking them both as required and multiple. Using a required variable will cause a ClockError during parsing when the variable isn't set. Multiple variables can appear multiple times. For examples gcc requires the possibility to parse multiple include paths. Such a feature now is possible using this new functionality.
All changes are available in the official repository at GitHub on branch dev-1.0.
The release of clockUtils 1.0 is planned for June as there are just three tickets left. Hope we get it done soon.
Also i6engine made some progress this month. Besides several fixes of bugs occurring during a test session of my tower defense game Elemental War (homepage coming soon) I improved the tools. Instead of parsing the command line itself they now use our clockUtils argParser library. This improves our code quality and makes it very easy.
As also i6engine 1.0 is going to be released in June on GitHub and on our homepage some last improvements have to be done. As I hadn't that much time this month I just checked the tutorials. They now match the current API of the engine and also describe internal methods correct.
Another month, another report. We've been busy this month, had a first business meeting.
Our homepage got some more features you'll be able to see soon. I added a basic setup for future game pages. They'll just contain the news page, a features page to describe the game and a gallery page to show you some screenshots. That gallery feature is the seconds feature our homepage got. A first game page will go live soon, just needs some new screenshots. After this, more will follow soon, especially for Cwizz. I think also i6engine will get a gallery page at least with its first release around June to show some features or editors.
clockUtils got more updates this month. We refactored our DoubleBufferQueue implementation. Its API now isn't equal to std::queue anymore, but instead more like other clockUtils APIs. Changing this causes better error detection as the STL sometimes had undefined behavior, e.g. calling front() on an empty queue. In this case you'll get ClockError::NO_ELEMENT now using our DoubleBufferQueue.
Also the container library got its missing documentation entry. It's basically structured as the other docu pages as the library actually contains just one class.
Our sockets, both for tcp and udp, now provide a dns lookup. You can get the IP for a hostname using the new method resolveHostname(const std::string & hostname). But you're also able to connect directly to a hostname using connectToHostname. Of course this also works for the UdpSocket sending packets directly to a hostname.
And finally the argument parser now can be used in unix like way. This means you can register variables to be parsed with both a long name and a short name. Assuming you have a variable "file" you can use this a the long name and e.g. f as shortname. Now, entering the arguments to parser, both --file or -f are detected and assigned to the variable "file".
All these changes are already live in our GitHub repository on branch dev-1.0.
Our engine got two major updates besides some small ones and bugfixes.
The first one is support for basic terraforming. This is split into two parts. The first one is the possibility to generate terrains during runtime and create one out of std::vector
The other major update was in our editor. It now provides two more plugin possibilities. One is used during loading of a level, the other one is for saving objects. The use cases are really simple to explain using our RPG module:
The load level plugin can easily be used to load not only the level file but also the NPCs and items added to the world via the startup script. Such a plugin is already provided by the engine. The save object plugin is called for every GameObject in the world and can handle objects in another way than just storing it the level file. It is used to handle NPCs and items in the editor. Saving a level with NPCs or items now generates a startup script to add them to the level during startup using our RPG module or the plugin provided for loading RPG levels.
I hope this new report was interesting. I think the next news will come before April's progress report and add the first game page.
February is already over and we have many new progresses we want to share with you.
In clockUtils, decompressing an uncompressed string ended in random behaviour in 0.5. This was fixed now to return a ClockError instead and otherwise ClockError::SUCCESS. This results in a change API for the compress and decompress method, but it’s worth it.
Also clockUtils now contains a new library, which is actually header only. The new library is called container and contains a DoubleBufferQueue allowing threadsafe queue access. We use it both in i6engine and m2etis, so the class is well tested in real applications.
All changes are pushed to dev-1.0 branch in our GitHub repository. There isn’t that much work left for 1.0, so we hope to be able to release it within the next months.
Our engine got a lot of fixes and new features this month. Several rare crashes we found during working on one of our games are history now. We also refactored the usage of conditionVariables as we learned more about their behaviour while fixing clockUtils for release 0.5.
For our object system we created some new Components to allow more features. It’s now possible to register and store animation events in an AnimationControllerComponent. This is necessary for automatic transitions betweens animations, triggering a sound or particle at a defined position within the animation and so on. The whole system is already in use in one of our games and works really well. More Components affect our Lights. You now are able animate them. This means you can interpolate attributes like the colour or range over a time. May be you want some flickering fire, than that’s no problem anymore.
The sound system was improved to be able to group sounds now. In nearly every game you can change the volume for different categories of sounds like effects, background music and dialogs. This grouping is already possible now. The volume changing for a complete group is another ticket and will be done in future.
Also our tools got several updates this month. Besides several fixes for our new ParticleEditor we also localized all GUI tools including i6engine-editor, NPCCreator, DialogCreator and ParticleEditor. Supported languages are only German and English, more might follow as soon as we released and someone contributes a translation.
Currently we’re working on a way to create terrains during runtime with the possibility to feed the TerrainAppearanceComponent with an array and also change this array during runtime (terraforming, yay).
m2etis got new options for its test scripts to be able now to profile all channel configurations. This works both for Windows using the Visual Studio performance tools and Linux using google performance tools. The first results profiling the current implementation show most time waiting at some conditionVariables. The only “significant” m2etis time is within the RealTimeClock because of slow boost::date_time. As we tested earlier in i6engine, std::chrono is much faster than boost here, especially on Windows (about factor 40). Switching from boost to std::chrono in the engine dropped CPU usage of RealTimeClock from 10% to 0.5%. So m2etis will profit here too.
That’s all for the announced projects. We mentioned one of our games sometimes and hope to be able to show you some informations about it soon. That’s why we’re going to set up our game page template and a gallery in March or April. As soon as this is done we’ll create the homepage for the first game with some screenshots. Also i6engine might get a gallery section then to show some of its possibilities.
Starting this month we want to let you take a look at our progress in our monthly progress report. We release the progress report on the first day of every month. So here is what we achieved in January and plan for February.
This month we improved the usability of the website for us to allow easier changes. Additionally, we added the newsticker on the start page of clockwork-origins.de. There you can see the latest five news we posted.
clockUtils made good progress. We fixed some rare deadlocks and race conditions in our socket implementations. It took us several hours to get rid of all of them, but finally we did it. As this was the last problem occurring we were able to release the update to version 0.5. Starting with this version, clockUtils is also available at GitHub. So if you like you can fork the repository and do your own changes. Of course we would appreciate if you share your changes with us.
The next step is version 1.0 and it will come soon. The first small steps towards it are already done.
We didn’t officially release any version of the engine so far because we have to clarify some licensing stuff, but we’ll tell you what’s going on and what you can expect with the first release.
This month we worked really much on the tools we offer.
Our level editor was completely rewritten using Qt for the GUI and has many new features such as plugin support for, e.g., starting a game to test the current level directly from within the editor or declare the layout and the way of parsing for components' attributes.
We also added two new editors to create NPCs and Dialogs. The NPCCreator can create and edit new and existing NPCs with realtime preview of the model. The DialogCreator still needs some more features, but you are able to create and edit dialogs. The next big step will be to abstract the dialog scripts so you don’t need to know anything about scripting for most dialogs. This means any storywriter in your team can write dialogs directly for your game really easily.
The last tool for this month was the ParticleEditor. We used the ParticleUniverseEditor so far, but it didn’t work that well and porting it to Linux wasn’t easy and many things had to be refactored. So we decided to rewrite the editor with Qt. We dropped some of the old features like recording videos. We might add them, when we need them or they are requested by anyone else. However the basic mechanics like creating, editing and saving particles with realtime preview, script editor and a component overview with edit possibility works really fine now both on Windows and Linux.
m2etis is one of the first projects we worked on during our studies. It’s a really powerful template based publish subscribe network middleware and generates all channels during compilation time. Thus the overhead during runtime is very small. This month we released version 0.4 which is a stable version now. We will focus on performance next because there is still a lot of speed wasted caused by parts of m2etis that are still single-threaded and not profiled at all.
That’s all so far. We hope you enjoy this new monthly information. Watch our public repositories for more updates or join our mailing lists to be up-to-date and well informed.