Introduction

Aug 25, 2015

What will you learn?

This tutorial covers the development of a game from a very beginning. This includes:

  • planning the architecture for a game
  • developing the game engine
  • defining game logic with scripts
  • creating 3d models
  • and distributing the application

And of course, the whole tutorial is built around Irrlicht and Newton Game Dynamics libraries.

As for 20 Mar 2019, the tutorial covers:

  • an introduction to NewtonGD
  • creating Irrlicht-powered application
  • controlling the application logic with Lua scripts
  • building application with CMake

Why writing everything from scratch? Why not use Unity / Unreal Engine / you-name-it?

There are some well-known and used game engines like Unreal Engine 4, Unity 3D and others. They all come with enormous amount of learning materials. So why this tutorial might be interesting for you? You might want to know how things work and thus get most flexibility out of your tools. Or even start working on building your own tools.

What should I know to proceed?

I expect you to have at least some experience with these three things:

  • C++
  • computer graphics
  • game development

The latter - to make sure, you will not call 3d models “textures” or miss the “script” word’ meaning.

Why these libraries?

Irrlicht is easy to use and contains all the features you will need to build a game - resource management, support for majority of asset formats out-of-the-box, user input (keyboard, mouse and joystick events handling), GUI (Graphical User Interface - buttons, text inputs, etc.).

Irrlicht is easy to use and contains all the features you will need to build a game - resource management, support for majority of asset formats out-of-the-box, user input (keyboard, mouse and joystick events handling), GUI (Graphical User Interface - buttons, text inputs, etc.).

Newton Game Dynamics is also very easy to use; it is constantly developed; and it is darn powerful!

If you are still interested - please proceed to the first chapter.

ReactJS introduction

Jul 11, 2015

Foreword

Last time I wrote an article on how one can encapsulate both HTML and CSS in one entity, called WebComponent. This time I want to tell a bit about how to encapsulate JavaScript and HTML.

When I see an article on Habrahabr titled React something, I think Omg, React again?... But React, just as Ember was always a mystery for me.

Until today.

Read more

About Bower, WebComponents and the all the good

Jun 22, 2015

BEM

These days, many web developers use different methodologies to make their web page source look structured and clean. But all those methodologies only work well until you use third-party libraries or involve a new person in your project.

Read more

Memory allocation in ASM

May 6, 2015

Currently I am working on a long arithmetic problem at the university. This problem is much more complicated than I described or than a task I shall be describing now, but here’s the thing: I needed some part of memory to be allocated from within my function. And I needed this to be done in assembly.

Read more

Assembly in C++ programs

Apr 23, 2015

Foreword

Writing code in assembly language in 2015 seems stupid and meaningless. Yet, this subject has a few huge pros:

  1. understanding how computers/compilers/programs work
  2. optimizations while writing a complex or performance-critical applications
  3. fun

Well, in real life, I’ve never met conditions of such performance requirements when I should be writing some parts of application in ASM. Except, maybe, a few ACM ICPC problems.

So, we got two merely huge pros to write in assembly. Thus, if you are not getting fun of writing applications, you may be not interested in this topic.

This article is academical mostly. People who study something like low-level programming at their universities may be interested.

Read more

ShootThem!

Apr 6, 2015

A few days ago I’ve found my old game, ShootThem! sources. 

Half of hour being trying to run it, and viola!

Placed all the sources with its dependencies on GitHub: https://github.com/shybovycha/shoot-them

One has no story (in-game, but has one written before the game presentation on a programming competition for students in Dnepropetrovsk). It has (almost) no colors. No code structure or architecture. No animations. 

It is really plain.

Yet, it was and it is a starting point for me =)

Here are some of game screenshots:

Running Qt + MySQL application

Mar 29, 2015

Yesterday I tried to run my university project made with Qt and MySQL. But all I got was strange error message, saying QMYSQL driver is not loaded whilst loaded driver list actually included that one.

Searching all over the internet up ‘til 2 AM and recompiling the whole Qt gave no result except time being wasted. Yeah, and 90% of search results were tutorials on how to recompile Qt MySQL plugin under Windows.

Yet in the morning I found solution and it was beautifully simple! I just performed one step from Deploying Qt applications, actually just copied the plugins/ directory to the dir where the application executable lives (build-debug/ or build-release/ for my project; I hate the default build-#{ProjectName}-Desktop_5_4_1-Debug/ paths); included the sqldrivers/ directory there (just copied) and created (a bit tuned although) the qt.conf file. That file just pointed the plugins path to the custom one:

[Paths]
Prefix=.
Plugins=./plugins

To sum everything up:

  1. create a plugins/ directory in your build directory
  2. copy Qt/5.4/Src/qtbase/plugins/platforms/ there
  3. copy Qt/5.4/gcc_64/plugins/sqldrivers/ there too
  4. create qt.conf file in build directory and fill it as mentioned above

And one more hint before the end: to debug why your Qt plugins fail use this application startup switch: QT_DEBUG_PLUGINS=1 ./app_name - this will display plugins debug information.

Tiny java code...

Mar 27, 2015



tinyjavacode:

This one was super easy so I did a quick comparison of a couple of ways you can do it; the goal is to count all the alphanumeric (a-zA-Z0-9) characters in the text of a Sherlock Holmes book. There’s probably other ways do do it because there’s lots of ways to do literally anything, but the fastest one here is stripping out all non-alphanumeric characters (\W).

Decorator pattern in Python

Mar 24, 2015

Just found some interesting way of implementing Decorator design pattern in Python.

As Jason Smith said in his book (Elemental Design Patterns), “design patterns may be implemened in different ways in different programming languages”.

That’s said, design patterns are not some set of classes which will be implemented in a very similar way in different languages - they are just a way of doing something.

Thus, Decorator pattern is a way of wrapping some method’s or class’ behaviour. In Python it may be done with Context Managers: ```python from contextlib import contextmanager @contextmanager def tag(name): print "<%s>" % name, yield print "" % name, with tag("h1"): print "moo", print with tag("div"): print "foo", ```

This code will end up wrapping print "foo" and print "moo" methods with printing some HTML tags around ‘em: ```html

moo

foo
```

That is interesting as it implements Decorator design pattern in a bit hard-coded way, but using language features, not OOP ones.

Compare it to the "standard" OOP implementation in Python: ```python # -*-coding:utf-8 -*- class SimpleText(object): def __init__(self, text): self.text = text def content(self): return self.text def __str__(self): return self.content() class TagDecorator(SimpleText): def __init__(self, text, tag): super(TagDecorator, self).__init__(text) self.tag = tag def content(self): return '<{0}>{1}'.format(self.tag, super(TagDecorator, self).content()) a = SimpleText('moo') print('SimpleText: %s' % a) b = TagDecorator('moo', 'h1') print('TagDecorator (h1): %s' % b) ```

This one looks a bit… ugly… right? And though Python does not really care of which type are a and b, we may not need all this class hierarchy.

This is the might of context managers!