Babylon project (provisional name)

Babylon project is a provisional name for a open world, multi mission, single player game.

It’s ambiented in the mesopotamian cultures, but it’s a fantasy, not historical, game.

The game is inspired by the stories of the Anunnaki in the ancient Sumer.

I started to learn UDK two years ago and at this point the code part is almost finished. Still there are a lot of work with the graphic part.

The map area has 100 square kilometers (but some are water). It’s a UDK Landscape with several localizations using streaming levels.

Foliage is placed around the player dynamically:

landscape_04 (1).jpg

Illumination are full dynamic, with complete day/night cycle, night lighting with shadows, etc.

The game uses the principle of “if are hidden, destroy it” as a way to always keep a minimum of actors on the map and can run at an acceptable framerate. An example of this is the foliage, but it also applies to characters and objects on the map.

Characters are modular, can be customized in appearance, clothes, etc.


APEX cloth are used for some cloths and hairs.

Alien ship:


Here is one of the latests videos:

More videos in the Youtube channel:

the (provisional) game blog:

and Facebook:

The game main language will be english with subtitles for others languages, but in the videos some voices are in spanish (I’m from Spain). Are “dummy” voices, not for the final game.

I have had sporadic collaborations but basically I’m working alone in the project. If you are interested in collaborating (royalties) please contact me. Particularly 3D artists are needed.

(the old thread from the previous UDK forums: )

The latest video, to show a new armor for the male character and some new animations:

very cool bravo !!!

Happy to see you here…This project was the only reason I was going back to the UDK forums for…

Thanks, old forum will close soon, fortunately we can continue here.



I have changed the aiming method. The new uses “canvas.project” to find the aimnode values. Perhaps it sounds a little strange, but it’s simple and works perfect.

Here is a video:

The old aiming system was very imprecise. The camera have different offsets and the character aiming postures are no perfect. So the alignment had errors.

This new method are using “canvas.project” to find exact values to pass to aim node.

Instead comparing character and camera rotations, I do a projection of the weapon canyon over the screen, and compare it with the center. After that is easy to find the values for the aimnode.

No matter if the aiming postures aren’t perfect, the system always finds the weapon correct orientation with respect to crosshair in the center of the screen (in the video there are a little “lag” because it’s using interpolation for smooth movements).

Also the player auto-rotates when the horizontal aim is near the limit.

In the video you can see a red “laser guide”, a debug line that is the current weapon orientation. Always finishes in the crosshair, what is the desired.

This is using UDK, but it can work with UE4 and any engine, only need some function to convert 3D coordinates to 2D (canvas.project in UDK).

The weapon are only for tests purposes, downloaded from In the final game will be bows and crossbows and others.

This is how it works:

  • in the HUD, function DrawHud, I get the “muzzle” socket from the weapon and I do a trace using the muzzle location and rotation. If no collision, a value of 1000 are used as impact distance. The center of the screen is stored in a variable located in the player class.

  • Then, with the 3D impact coordinates, I use “canvas.project”. This gives the 2D coordinates of the impact point.

  • Now in the player class:

Aim.x = MyAimNode.Aim.x; Aim.y = MyAimNode.Aim.y; //get the current AimNode values

//“CanvasAim” is the 2D coordinates for the impact location, calculated in the Hud.
//“CanvasCenter” is the center of screen, when the crosshair are printed. Shots always goes to here. You can calculate it once at the begining instead in each tick.

if (CanvasAim.x >= CanvasCenter.x) { Aim.x -= abs(CanvasCenter.x - CanvasAim.x) / (CanvasCenter.x*2); }
else if (CanvasAim.x < CanvasCenter.x) { Aim.x += abs(CanvasCenter.x - CanvasAim.x) / (CanvasCenter.x*2); }
if (CanvasAim.y < CanvasCenter.y) { Aim.y -= abs(CanvasCenter.y - CanvasAim.y) / (CanvasCenter.y*2); }
else if (CanvasAim.y >= CanvasCenter.y) { Aim.y += abs(CanvasCenter.y - CanvasAim.y) / (CanvasCenter.y*2); }

and you have in CanvasAim.x and CanvasAim.y the values to pass to the aimnode. I use another variable, “DesiredAim” to do interpolations and set the values in the aimnode.

And you MUST use a system to disable the aiming when the player is looking to the camera. I use “abs(NormalizeRotAxis(Rotation.yaw - YourCameraRotation.yaw))”. If > 16000, then the player is looking to the camera.
I use NormalizeRotAxis instead Dot because camera has some diferent offsets.

thanks for this information.

Congrats CobaltUDK on that compliment…Tim Sweeney himself…
The game looks great so I agree…

Yes, it’s a honor for me, thanks to Sweeney and to all of you. Your comments are very appreciated.

I made a dismemberment system using “HideBoneByName”. Here’s the video, with graphic content:
Perhaps it’s a little bloody, and I don’t know if this is the path I want to follow. What do you think?

Background graphic is very clean and excellent.

You are a great person.

Thank you, I had some collaborations, for example Daniel Akbari did a clean retopology of my old female model and I did the rest. Alex Boyco and Alex Pryde did house models and I have used some free animations and models parts from Mixamo.

Now AmyP is working in a house model and still waiting for people that wants to accept a risk working for royalties in this project.

The game has great graphics and gameplay, you will make some jaleous Unreal 4 users :smiley:

Heh, sure I envy UE4 users… but I need to finish this project before.

Here is a model inspired on the Queen Puabi:


Some, ejem… body phisics:

looks very nice. perhaps a little too jiggly but at least it feels quite dynamic compared to the usual staticness of character skin

so the hair is apex cloth, and the jiggly body parts are just extra bones with always-on physics, right?

Oh~ Good inner wear~ ^^

White is the truth of inner wear. -_-

Chosker, correct.
Kee, painted inner wear good for modders.

Here is a cheap camera automatic exposure with practically no performance cost.

It’s based on the Sun angle and the player occlusion.

The whole screen is brighter depending of these two values, using postproccess Scene_HighLights.

With this is possible to reduce the global ambient light without having too dark image in the penumbra.

In the video, exposition are exaggerated, to make the effect more noticeable.

Commence the jigglin’!

This is a test I did with a map for Unreal Tournament called “VCTF-Retribution”, downloaded from here long time ago:

I have included it in my main 10x10 km map as an stream level (the map are loaded when you are near).

I wanted to have an idea as how the game can look once finished, using a well finished map like this.

This is only a test, the game is ambiented in the ancient Mesopotamia, and this level doesn’t fit. It’s only a test.

In this video you can see:

  • Camera auto focus and auto exposure (both are configurable and deactivable).

  • Dynamic illumination (no GI), with day/night cycle and torches casting shadows.

  • 64 bots following a path using splines.

And some bugs:

  • Bots don’t detect ledges too well, sometimes they fall as if they were lemmings.

  • Some clothes don’t fit well because the base models were modified after made the cloth. I prefer to have a definitive base model before fixing the cloth.

  • Framerate is bad, with frequently falls under 60 fps because the map has a lot of individual meshes (about 7000), and the 64 bots aren’t optimized (too many modules, no LOD for clothes, apex clothing, etc).