Last month of the year has started, time to report the progress of November.
I worked a lot on the general project configurations. I wrote a tool to automatically update the common files all projects share. Before I had to update every project manually when I wanted to update e.g. a dependency. Will save me much time and ensure configurations don't run apart.
On code side I only updated the project infrastructure to match the new configuration. But I added clockUtils to the GitHub repository for Vcpkg. This is a repository for Visual Studio projects to get current version of different open source libraries. Hope this will help to spread clockUtils.
m2etis got some nice improvements. I removed some occurences of threads where they weren't necessary and reused old threads. Haven't measured performance yet, but even if it's not faster at all, code is much better now. I also replace gflags by clock_argParser. Replacement was very easy and now it works on all officially supported platforms the same easy way.
A nice result of updating also m2etis' project configuration was that m2etis can be built for Android now, too. Haven't run an application really using it so far, but it compiles fine now. Another step forward to build i6engine for Android.
Cwizz' GUI was improved furthermore. Therefore I updated Qt to version 5.6. Now I can use automatic DPI scaling. This resolves most issues I had with Android. There still are some issues, but they're not as big as before. I hope I get everything solved within the next weeks so the open beta can start in early 2017.
Very good news for Elemental War: I finished all tasks I planned for the singleplayer alpha and sent it to some friends a week ago. Haven't got any feedback so far, but work goes on. I added some new improvements and graphics and started with the conceptual part for the multiplayer modes. The singleplayer was a first big step for me, the next will be the multiplayer alpha. I hope I'll get it done fast now.
As usual there were much more small pieces of work done, but I wanted to focus on the major parts. Next progress report might be a complete retrospection of 2016. Not sure about that. Maybe I'll also write two news for that.
As I updated the rpm and deb repository for clockUtils today it's time to officially announce the new release.
Version 1.1 of clockUtils is ready. It contains some bugfixes for most libraries. For example Socket::receivePacket(std::string&) was slow on Windows. Now it is much faster. Also static linking was broken.
But there are also some new features. I improved the toolchain to support building with clang on Linux and mingw on Windows. But building with mingw is really tricky as there are many distributions and they don't support the same features (e.g. threads). That's why I already dropped the support in 1.2 until I find a better solution for it.
The iniParser got some new possibilities to query the contained data. It is now possible to query what sections are available and what entries are in those sections. This is very helpful to get informations about configuration files one don't know the content or that are dynamically filled.
In our container library I added a simple LockFreeQueue. Actually it is 2-3x faster according to the unit tests compared with DoubleBufferQueue. I think this can be improved even more, but it's a good start in my opinion.
All changes can be found in the changelog.
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.
Today I tagged version 0.9.0 of the SocketPerformanceChecker on GitHub. I finished all planned features some days ago and as all continous integration tests I created pass on Windows and Linux, I think the time has come to release.
The main features are:
- m²etis plugin (it's not a socket implementation, but for us it's good for profiling)
- Qt plugins for UDP and TCP
- LineChart for presentation of results
- Possibility to export results
There were some more improvements, but those are the most important ones.
A next release will come, but isn't scheduled yet. If you have any feedback, we would love to get some.
Wow, another month passed, time is running so fast. This month was focussed on our games. There were also small things for the libraries done, but nothing really interesting. But an important improvement this month was the start of the continous integration testing. I wrote a small framework for this to test all our projects. There are already some jobs for some projects and I already found bugs, mostly in the toolchain.
But now I'll come to the projects.
I couldn't get much done for clockUtils this month, but the good news is, that a new release is almost finished. Just one ticket left. I want to add a lock-free queue to the container library. After this, the new release will come. If nothing intervenes it will be finished in September. Cwizz already uses a 1.1 revision as it needs the new ini parser functionalities.
Cwizz got a complete graphics overhaul. I not just improved the layout but also the complete style. It looks much better now. Besides this I also fixed some bugs we found during testing. On Sunday the next closed beta version will be released. After this one just one more will come before the German open beta version will come. This version is scheduled for November, so it's not a long time until then.
Another interesting part for Cwizz is the browser version of our question creation tool. It's still in an early stage, but I hope Michael will get it done soon.
So, many things going around here.
Also Elemental War good a real boost. I finished all gameplay elements I wanted to add for the singleplayer alpha I'll start in the next months. There are still a few things left, mostly optimizations and a little content. But in general the singleplayer mode now is mostly finished. After the singleplayer alpha has started the next big step will be to add the multiplayer modes. So I think a release in 2017 is still possible.
As the last news were mostly for the libraries, the focus has a little changed. That's because the libraries are really good so far. I add the features I need to finish the games. And the games will come soon.
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.
Today the time has come to release our first 1.0 version. For this release clockUtils got some new features like a new container library containing a DoubleBufferQueue allowing threadsafe queue access. We had the implementation of it in both i6engine and m2etis and put it into clockUtils as it is a thing more projects can need. Other changes affect our argument parser and our sockets. Both libraries got new features to improve usability such as marking command line arguments as required or allow multiple entries for an argument. Our sockets e.g. allow a dns lookup instead of using an IP.
The full list of changes can be seen in the changelog.
The source archive and Windows prebuilt packages for Visual Studio 2013 and 2015 can be found on our downloads page and our GitHub repository is also updated. The master branch contains the current release while dev-1.0 will stay alive for bugfixes. The new develop branch is dev-1.1.
Release 1.1 will add support for some new compilers. This means for now MinGW on Windows, a complete toolchain for clang on Linux and maybe also Windows. If you would like to see some other compilers let us know, we'll see what we can do.
Also tagged with a version (0.8.0) is the SocketPerformanceChecker to compare different socket implementations. It can be found in the corresponding GitHub repository. It provides the main functionality to compare the sockets. Future updates will add more socket implementations (e.g. Qt sockets and maybe also m2etis, which is not a socket library but networking in general) and eventually some automation to start the SocketPerformanceHelper on the selected machine.
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.
A new release of clockUtils is ready today. The biggest part are improvements and fixes to our TcpSocket implementation. A lot of fixes to several race conditions are done there. For a full list of changes see our changelog at http://clockwork-origins.de/en/clockUtils/changelogs
Together with the new release we also created a public repository on GitHub so you can stay updated besides the stable releases. You can find our repository here: https://github.com/ClockworkOrigins/clockUtils
We hope you enjoy the new version. The next to come will be 1.0!
We are proud to announce our first release of clockUtils, our C++ library collection for common tasks. This first release contains four libraries for command line parsing, compression, using ini files and sockets for both, Linux and Windows. The complete documentation can be found here: http://clockwork-origins.de/en/clockUtils/docu
We hope you enjoy these libraries and would be happy if we get some feedback