Monday, January 5, 2015

The RTS Creator Advantage

In the last 3 years, there's been an explosion of game engine options available for independent developers. Unity has climbed to the top as every independent developers wet dream, Leadwerks 3 has unleashed a new realm of graphics fidelity with their OpenGL 4 renderer and CryEngine and Unreal Engine have been made public for a low monthly fee.

With all of these options it can be difficult for developers to choose what tools will best accomplish their visionary goals, after all, you wouldn't use a screwdriver to pound a nail in.

It may seem obvious if you've researched anything about the niche RTS Creator provides, but in developing RTS Creator we were able to make the assumption that anyone using RTS Creator is making a Real Time Strategy game. For us this means we don't have to provide features that aren't applicable to RTS games, making the interface less complex and significantly focused on a purpose that's in line with the user.

The challenge in making the assumption the user is creating a Real Time Strategy game is finding the perfect balance of simplicity versus flexibility. Oversimplifying could remove the possibility of RTS Creator being capable of creating the game you want, but having too much flexibility could make things over complicated, confusing, and create an abundance of unnecessary additional work. By acquiring feedback, we've been able to understand what's most important to game creators and focus on the flexibility that matters without sacrificing the simplicity RTS Creator currently offers.

The biggest advantage is the massive framework RTS Creator exposes through its interface. Using any of the above-listed engines, if you're making a RTS game you'll need to write code that defines your games logic. RTS Creator provides that logic without the need to write any code, saving a significant amount of time.

With many new features on the horizon RTS Creator could easily be the number one choice for independent developers looking to create a Real-Time Strategy game. 

Monday, December 8, 2014

Official Release

We are excited to announce that RTS Creator has officiallybeen released! We encourage you to try the demo and preview the example game before purchasing.

In the coming months we will be focusing on several primary areas.

1.            Video Tutorial Series
The video tutorial series will cover the following topics
•             First Game
•             2D Game
•             3D Space Game
•             Particles
•             Structures, HUDs and Tech Trees
•             Resources
•             Artificial Intelligence

2.            Assets
Currently RTS Creator ships with 52 Units and Structures and 1 HUD. We hope to greatly expand upon the Assets RTS Creator ships with.

3.            Features
The features we'd like to add are too long to list here but we'll be posting them soon on our forum.

4.            Performance Optimizations
RTS Creator in its current state begins to bottleneck with around 250+ units. Performance optimization will focus on physics, rendering and add threading.

5.            Scripting
With the wide array of real time strategy games in existence today it's impossible to create an environment that will meet the needs of everyone without scripting. Scripting will enable users to add unique game behavior using the LUA scripting language.

6.            Multiplayer
LAN and Internet multiplayer will support up to 8 players per game.


We look forward to the journey ahead of ourselves and can't wait to play your Real Time Strategy game!

Sunday, June 22, 2014

RTS Creator Inspired

A focus that's received a lot of attention in the world of productivity has been motivation. What motivates people and how people are motivated in turn results in all of the worlds output. By boiling down motivation we can separate all types of motivation into 2 separate and opposing psychological sources.

"Away from" motivation are ideas and situations a person is trying to avoid. For example, you don't have a job, you're running out of money and you're unsure how you're going to continue to put food on the table. The fear of not surviving motivates you to get a job and ensure your survival. You're trying to get away from the idea of not being able to survive.


"Toward" motivation consist of ideas and situations you're trying to attain. If you have a game or software, and distinct vision that inspires your motivation, every time you work to attain this vision you're working towards an idea.


What I've found fundamentally instructive about these distinctions is the quality of output based upon the inspiration for our motivation. Another word choice for these opposing forces could be "Fear" versus "Inspiration."


RTS Creator was founded on Inspiration from day 1. Every day before I put code into the machine, I take the time to recognize what I'm doing and why I'm doing it. What's the vision for this software, why is this vision great? How do I want people to feel when they're using this software?


The feelings and ideas I get from asking these questions fuels excitement, and motivation.


I want to enable people to bring their ideas to life, to get excited about the new possibilities that are now at their finger tips; to experience the awesomeness of making a world of war that consists of factions and armies of their own imagination.


This is the inspiration RTS Creator was founded upon and I hope to inspire that same inspiration in the users of RTS Creator. 

Sunday, June 8, 2014

Gauging User Expectations

After posting RTS Creator on Steam’s Greenlight we received a lot of feedback, comments, and questions. This has helped us to gauge prospective expectations and what we can do to best meet these expectations.

The original idea of RTS Creator was to be a tool for players and gamers to create their very own Real Time Strategy game with no prior programming experience. The biggest challenge is creating a tool that is easy to use and can create a variety of games. It’s challenging because we’re essentially developing a software that competes for a median on two opposing ends of the spectrum; simplicity versus flexibility.

We've received a lot of input on what users plan to do with RTS Creator and have decided to integrate lua scripting into the engine. This addition will be available post initial release and will complement the engines capabilities by giving users the ability to produce any result they could possibly think of.


Scripting will enable users to create and trade features with other users and vastly extend RTS Creator’s core functionality. 

Sunday, March 2, 2014

Modern Graphics. A layman Explanation.

One of the most exciting topics and endeavors of discovery for me his been 3d graphics. When I first started RTS Creator I knew absolutely nothing about 3d math or OpenGL. And a little secret is that most independent game developers don't. Now days you don't need have to have a PHD in rocket science and an awkward obsession with low level graphics to create games. Instead you use a higher level set of functions that handles the mathematics and calls to the graphics card for you.

But how do these mysterious frameworks work?

3D models consist of triangles, and as graphic power increases so do the number of triangles in modern models. What does it take to define a model of triangles? A list of coordinates for each triangle corner and which 3 coordinates come together to make each triangle. Pretty simple right?

What makes modern graphics "modern" is how these triangles are processed. 5 years ago graphics were rendered through a process called the "Fixed Function" pipeline. With the fixed function pipeline all graphics card commands were made in the application. The problem came years after the fixed function pipeline was invented, when models became extraordinarily complex and AAA game studios began to demand more flexibility and power.

This gave birth to the "Programmable" pipeline, which actually replaces parts of the native OpenGL rendering pipeline with... whatever the developer writes!  This amounts to less OpenGL calls to the GPU, resulting in less overhead, and lots more flexibility as developers are able to write their own rendering equations.

To give a brief example of what you can do now that you couldn't do before here are some pictures.

Ambient Occlusion


Shadows


Normal Mapping

And the list continues.

You can see how these things come together to produce more realistic and modern graphics.

RTS Creator was initially developed with the fixed function pipeline. With lots of research and studying I was able to swap out the fixed function pipeline and replace it with the programmable pipeline. I then had to find lots of equations to modernize the rendering and introduce new features such as Screen Space Ambient Occlusion and Shadows.

To give you a little taste of the final result, here's the equation and "program" RTS Creator uses to render its graphics.

#version 120

uniform vec3 EntityColor;
uniform bool FullBright;

varying vec3 vertex_normal;
varying vec3 Position;


//SHADOW VARIABLES
uniform bool EnableShadow;
uniform sampler2DShadow ShadowMap;
uniform int ShadowMapSize;
varying vec4 ShadowCoord;
float xPixelOffset = 0.001;
float yPixelOffset = 0.001;
//SHADOW VARIABLES

//DIFFUSE
uniform bool EnableDiffuseMap;
uniform sampler2D texture_diffuse;
//DIFFUSE

//NORMAL MAPPING
uniform bool EnableNormalMap;
uniform sampler2D texture_normal;
varying vec3 ViewDir[7];
varying vec3 LightDir[7];
//NORMAL MAPPING


//LIGHTING
struct LightInfo {
                vec3 Position;
                vec3 Intensity;
                vec3 La;
                vec3 Ld;
                vec3 Ls;
};

struct MaterialInfo {
                vec3 Ka;
                vec3 Kd;
                vec3 Ks;
                float Shininess;
};
uniform int LightCount;
uniform LightInfo Lights[7];
uniform vec3 LightPositions[7];
uniform MaterialInfo Material;
//LIGHTING


vec3 refl( vec3 s, vec3 n)
{
                return -s + 2 * (dot(s,n)) * n;
                //return 2 * (dot(s,n))* n - s;
}

vec3 ads( int LightIndex )
{
                vec3 n = normalize(vertex_normal);
                vec3 s = normalize(Lights[LightIndex].Position - vec3(Position));
                vec3 v = normalize(vec3(-Position));
                vec3 h = refl(-s,n);//normalize(v+s);

                return Lights[LightIndex].Intensity * ((Lights[LightIndex].La * Material.Ka) + (Lights[LightIndex].Ld * Material.Kd) * max(dot(s,n),0.0) + (Lights[LightIndex].Ls * Material.Ks) * pow(max(dot(h,n),0.0),Material.Shininess));
}

vec3 adsn( vec3 norm, vec3 diffR, int LightIndex )
{
                vec3 n = normalize(norm);
                vec3 s = normalize(Lights[LightIndex].Position - vec3(Position));
                vec3 v = normalize(vec3(-Position));
                vec3 h = refl(-LightDir[LightIndex],norm);
                return Lights[LightIndex].Intensity * ((Lights[LightIndex].La * Material.Ka) + (Lights[LightIndex].Ld * Material.Kd) * max(dot(LightDir[LightIndex],n),0.0) + (Lights[LightIndex].Ls * Material.Ks) * pow(max(dot(h,ViewDir[LightIndex]),0.0),Material.Shininess));
}

float lookup( vec2 offSet)
{
                return shadow2DProj(ShadowMap, ShadowCoord + vec4(offSet.x * xPixelOffset * ShadowCoord.w, offSet.y * yPixelOffset * ShadowCoord.w, 0.000025, 0.0) ).w;
}

void main(void) {
               
                vec4 tex = vec4(0.0);
                if (EnableDiffuseMap)
                {
                                tex = texture2D(texture_diffuse, gl_TexCoord[0].st).rgba;
                } else {
                                tex = vec4(EntityColor.rgb,1.0);
                }

                vec3 lcolor = vec3(0.0);
                if (FullBright)
                {
                                lcolor = tex.rgb;
                } else {
                                if (EnableNormalMap)
                                {
                                                for( int i = 0; i < LightCount; i++ )
                                                                lcolor += adsn(texture2D(texture_normal, gl_TexCoord[0].st).rgb,tex.rgb,i);
                                } else {
                                                for( int i = 0; i < LightCount; i++ )
                                                                lcolor += ads(i);
                                }
                }             

               
                float shadow;
                if (EnableShadow)
                {             
                                // Avoid counter shadow
                                if (ShadowCoord.w > 1.0)
                                {
                                                float x,y;
                                                for (y = -1.5 ; y <=1.5 ; y+=0.50)
                                                                for (x = -1.5 ; x <=1.5 ; x+=0.50)
                                                                                shadow += lookup(vec2(x,y));
               
                                                shadow /= 64.0 ;              
                                }
                } else {
                                shadow = 0.8;
                }
               
                if (tex.a < 0.15)
                {
                                discard;
                } else {
                                gl_FragColor = ((shadow+0.2) * vec4(lcolor*tex.rgb,1.0));
                }

}

Saturday, December 7, 2013

Beta Release

It's been awhile since we've last posted a status update. The RTS Creator website is up and from here forward we'll be posting our dev progress here -

www.rtscreator.net

The beta has been officially released and can be downloaded here -

http://www.rtscreator.net/index.php?/files/file/4-rts-creator-beta/

3 years and 24 days ago we began developing RTS Creator. After 3 revisions and lots of research and rewrites we've finally reached a state of stability and functionality that allows anyone to create a Real Time Strategy game with no coding.

Thank you for all your support and we look forward to seeing you on the RTS Creator forums.

Friday, July 19, 2013

Final Preperations

We're down to the final preparations before the initial release of RTS Creator!

Right now we're packaging up resources such as models and images, and finishing the web site!

RTS Creator will include a sample game "Genesys" that includes lots of models, objects, obstacles, and weapons so you can start remixing and modifying a full game.

We'll also be posting our roadmap with our future plans and feature releases.