Friday, October 19, 2018

Araknoids is coming soon

It has been a long time since the last update :)

I was quite busy trying to build a project that could realize the potential of the Spider Engine. It was (and still is) a challenging exercise, but after a long search, tons of discussions, and more importantly the artistic contribution of an extremely talented friend, I can finally announce Araknoids!

I describe it as a multiplayer, "last-spider-standing" experience.
You play as a spider that gets bigger by stealing opponents' legs.
You die when you have no more legs!

I will not say more because this will be playable at MIGS and MEGA early November.
If you are in the Montreal area during these events, please come try it!


Tuesday, June 12, 2018

See you at BIG 2018!

I will be at BIG 2018 in Brazil starting June 25th with a delegation from Quebec. I will show demos of the Spider EngineSee you there!


Wednesday, May 9, 2018

Spider Engine in Beta


My new game engine, the Spider Engine, is in beta testing!

It's my humble attempt at making a creation environment that is as accessible as possible, without sacrificing power and flexibility.

Motivation


I enjoy creating worlds using software, but I hate the process when it involves keeping track of too much code, having to read tons of documentation, or using friction-full technology. Life is short, and creation is fun, but no one dreams of spending their life in front of a computer fighting against technology!

Spider Engine came to life because there is a lack of user-friendly real-time creation environments. Creation software are complex to make, and there are design trade-offs at every corner. Each decision affects the overall flexibility, performance, functionality, and user experience aspects, to name a few. The balance is really hard to strike, and there are tons of software trying to cover all bases, but in my opinion, none of them do it just right. I don't think Spider does it right either (engines can never be right, they can only compete in popularity), but I think it's a firm step in the right direction.

Technology


Spider is entirely web-based, no installers, no downloads. This was one of the hardest decisions to make, coming from more than a decade of C++ experience in the video games industry. I had to learn the ways of web programming pretty much from scratch, as the last time I did anything remotely web related was at college. But at the same time, I couldn't have done it any other way, because in my opinion, being accessible on the web is a must for modern software. Instantaneous access, cloud save, team collaboration, ease of sharing on social media, are all things we expect from software we use and the web is the ideal platform for that.

In addition, Spider was built with visual scripting in mind. However, it is not one of those "Create games with no code" environments. You will still have to write code to get certain things done right. You decide what level of abstraction you need, depending on your project and your performance target (yes, code blocks have a small overhead, so in performance critical parts it's better to use one code block with a lot of code instead of connecting several mid-sized code blocks). The closest environment that is based on this idea that I know of is Unreal Engine. But Spider has a big advantage in terms of iteration speed, because Javascript compiles light years faster than C++ (Thanks several decades of arms race between browser vendors!). This leads to a tight, real-time, iterative and efficient creation loop that I'm very fond of, and I think will help teams create quality products in less time.

Check out Spider Engine and let me know what you think!




Monday, March 13, 2017

Racing game prototype in progress, codename: Overdrive!

Overdrive is a prototype of an action-racing game. Some ships and special effects were made by the talented @gonthiermike. It has a hyper fast pace, butter smooth performance, and a combat mechanic.

Overdrive is one of the few projects not made with our proprietary tech, it was made with Unity.
If you played VLAD: Heavy Strike you might recognized some of the ships we refurbished :)




Wednesday, February 10, 2016

Source code release!

I'm releasing the source code of VLAD: Heavy Strike and Starports Space Defense to public. It represents about 5 years of work, and consists of the games, engine, tools, and pipeline developed during those years.


I loved every minute working on this tech. I'm satisfied with the level of maturity it has reached, allowing to release 3D games on mobile, even multiple releases (iOS, Android, and WP8) in the same month (November 2013!).

Let me know what you think of it I'd love some feedback on it!

Sunday, August 30, 2015

Debugging released versions

When releasing software to the world, it can be difficult to track down and fix problems that may happen on people's machines. In particular, problems that are not reproducible on the developer's machine. A good way to deal with this is to implement a mechanism for capturing and saving program state when an exception occurs. In addition, this mechanism should work in the "Release" version of the software, which is distributed to clients and should have no dependency on run-time developer libraries. Luckily, the VC runtime allows us to do this, on windows platforms.

Enable custom exception handler


The first thing to do is to plug a custom exception handler into the exception handling mechanism. This will be used to capture the necessary information needed for debugging. You want to do this at the very beginning of your program.

 #include <Dbghelp.h>  
 #pragma comment(lib, "DbgHelp")  
 LONG WINAPI CustomExceptionHandler(EXCEPTION_POINTERS* info)  
 {  
      shoot::Log.Print("GOTCHA!\n");  
      MakeMiniDump(info);  
      return EXCEPTION_CONTINUE_SEARCH;  
 }  
 int main(int argc, char** argv)  
 {  
      SetUnhandledExceptionFilter(CustomExceptionHandler);  
     // ...  
 }  

Record crash information


The next thing is to extract the crash information from the exception structure received by our handler. On windows platforms, this consists in producing a "MiniDump" file, which is recognized by visual studio and can be opened like any regular VS project. When opened, Visual Studio will conveniently extract the program state and present a call-stack for each thread of the process, local variables, and can even let you peek into the heap of the process, depending on the MiniDump type. If you're familiar with debugging a visual studio project, this will feel no different.

 void MakeMiniDump(EXCEPTION_POINTERS* e)  
 {  
      HANDLE hFile = CreateFile("minidump.dmp", GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);  
      if (hFile == INVALID_HANDLE_VALUE)  
           return;  
      MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;  
      exceptionInfo.ThreadId = GetCurrentThreadId();  
      exceptionInfo.ExceptionPointers = e;  
      exceptionInfo.ClientPointers = FALSE;  
      MiniDumpWriteDump(  
           GetCurrentProcess(),  
           GetCurrentProcessId(),  
           hFile,  
           MINIDUMP_TYPE(MiniDumpNormal),  // Explore other types for a full dump
           e ? &exceptionInfo : NULL,  
           NULL,  
           NULL);  
      if (hFile)  
      {  
           CloseHandle(hFile);  
           hFile = NULL;  
      }  
      return;  
 }  

That's it! Now you can distribute your software with less worries, and receive some juicy call-stacks whenever your program crashes on a user machine.

Sunday, March 8, 2015

Starports: Space Defense coming soon


After about 14 months in development, my game is in its final stretch. There is still work to do though but I can see the finish line. 

It uses the same engine as VLAD: Heavy Strike, with a lot of improvements. In particular, dynamic lighting, shadow mapping, and post effects. In fact, I completely removed all fixed-pipeline rendering code. I'll write a more in-depth article about the new engine when I have time (probably after the release).

Here is the teaser trailer: