Install Irrlicht

First of all, you will definetely need the Irrlicht engine, so go get it.

Then you will need to compile it. Compilation process depends on the operating system you use, but it's really similar on every one.

Linux

Install these dependencies with your system' package manager: libenet-dev libxxf86vm-dev zlib-dev cmake.

Unzip Irrlicht, go to the directory you unpacked with the terminal and run the following:

cd source/Irrlicht
make

Belive it or not, but that's all!

Windows

Unzip Irrlicht, go to the directory you unpacked and open the VisualStudio project (depending on VisualStudio version, you might want to open a bit different file) in source/Irrlicht:

Irrlicht10.0.sln
Irrlicht11.0.sln
Irrlicht8.0.sln
Irrlicht9.0.sln

Build it with VisualStudio - and you are done!

MacOS X

The steps are a bit complicated. And they require you to install XCode and Command-Line Tools - those could be found either in AppStore or on the Apple website.

• First of all, you need to install a bunch of dependencies (I use brew for this purpose):

  brew install tinyxml enet lua cmake

• Get a list of all compilers available for your OSX version:

  xcodebuild -showBuildSettings | grep DEFAULT_COMPILER

  I got something like this:

  $ xcodebuild -showBuildSettings | grep DEFAULT_COMPILER
    DEFAULT_COMPILER = com.apple.compilers.llvm.clang.1_0

• Now the build process:

  cd source/Irrlicht/MacOSX
  xcodebuild -project MacOSX.xcodeproj GCC_VERSION=com.apple.compilers.llvm.clang.1_0

• And the final step - copy the library to the lib/MacOSX directory:

  cp build/Release/libIrrlicht.a ../../../lib/MacOSX

Phew! That's a damn bunch of commands, don't you think?

Basic terms

Let's talk a bit about our application before we create it. In order to make the development process sequential and least painful, we need to design the application well. The design of an application or the application architecture is the hardest thing to change on later stages of development. Thus it must be well-thought at the very beginning to prevent suffering in the future.

Well, there are number of application architecture' levels:

    <p>
        The next level is how the modules communicate to each other, how they work together.
    </p>

    <p>
        The lower level is the structure of each module - what classes, entities, data structures and similar things will
        the module consist of.
    </p>

    <p>
        One of the lowest, yet still very important architecture levels is how files are organized.
    </p>
</div>

From the highest architecture layer point of view, I can advice a very simple architecture:

• a stable, rarely changed core
• a set of assets (models, textures, sounds - any content, made by artists and used to be presented to the player)
• a bunch of scripts, defining all the logic of a game (how character looks like, how the menus are shown and how they react to player’s actions)

The main benefits of such an approach are:

1. scripts and assets may be changed at any time
2. scripts and assets define what we show to the user and how the application behaves, so we can changes them without the need to re-compile the core
3. we can modify the core (for example - optimize some features) without changing the application behaviour

We can make the core so flexible that we may re-use it in the future projects.

The tools

We will use Irrlicht engine because of its simplicity. And it satisfies all our needs - it does not need much content preparation; it provides GUI; extending it with IrrKlang will give us very simple interface to sound and music playback.

Newton Game Dynamics engine we will use to simulate physics. It is easy to use and is really powerful - you would be impressed!

The last, not the least, we will use Lua scripting language to write scripts. Lua is a lightweight programming language and perfectly suits that goal.

One of the most beautiful parts of this tutorial, will be the part on making of assets. We will use Blender 3D to create a couple of 3D models.

I also found CMake kind of user-friendly. It is not that handy as any of dependency managers for all those languages, supporting them (npm for JavaScript, go get for Go, RubyGems for Ruby, leiningen for Clojure and many others). Yet it makes your project a little more portable, helps to handle your dependencies, totally eliminates the need of all those How to configure VisualStudio for OGRE tutorials. Just try it!

Conclusion

Remember all the three rules for our architecture. And keeping them in mind, let's get to some coding already!

Next chapter

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 {{ site.time | date: '%d %b %Y' }}, 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.

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.

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.

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.

Foreword

Writing code in assembly language in 2015 seems stupid and meaningless. Yet, it has a few huge benefits:

1. understanding how computers / compilers / programs work
2. hardcore optimizations for performance-critical applications
3. just for 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 handful of ACM ICPC problems.

Those are two merely big benefits to write in assembly. Thus, if you are not getting fun out of coding, you may not be interested in this blog.

This blog is mostly for academical purposes. People who study something like low-level programming at the university may be interested.

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

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

I have hosted sources with all the dependencies on GitHub.

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 still it is a starting point for me 😁

Here are some of game screenshots:

//*********************************************//
//                                             //
//        EASY DAILY PROGRAMMING TASK #19      //
//        ALPHANUMERIC CHARACTER COUNTING      //
//                                             //
//*********************************************//

public void count1(String text) {
    long start = System.currentTimeMillis();
    int count = 0;

    for (char c : text.toCharArray()) {
        if ((c + "").matches("[a-zA-Z0-9]")) {
            count++;
        }
    }

    long end = System.currentTimeMillis();
    System.out.println("Count 1: " + count + " Time taken: " + (end - start));
}

public void count2(String text) {
    long start = System.currentTimeMillis();
    int count1 = text.length();
    text = text.replaceAll("\\w", "");
    long end = System.currentTimeMillis();
    System.out.println("Count 2: " + (count1 - text.length()) + " Time taken: " + (end - start));
}

public void count3(String text) {
    long start = System.currentTimeMillis();
    text = text.replaceAll("\\W", "");
    long end = System.currentTimeMillis();
    System.out.println("Count 3: " + text.length() + " Time taken: " + (end - start));
}

Countiung all alphanumeric characters in Sherlock.txt:
Count 1: 432188 Time taken: 269
Count 2: 432188 Time taken: 53
Count 3: 432188 Time taken: 22

tinyjavacode: