What? Quaternions are quite well known and used all over the place. 4x4 matrices are a related but different transformation tool.

As already mentioned, quaternions are important, I use them myself when needed, but other than saving space or doing spherical interpolation, quaternions are seldomly used in game development.

Show me just one none-math/none-animation library, tool or engine which uses mainly quaternions. Most will support them, but the core math of almost all libs/engines etc. are based around 4x4 matrices.

First off, as already mentioned, you should use mip-mapping and use a offline mipmapping generation tool to get better quality (i.e. gamma correction).

Then you should consider to improve the overall image quality with fullscreen post-processing shaders, this way you can use simple sharping algos (extrapolate with a blurred version), AA, HDR/Bloom, unsharp masking etc.

There's nothing wrong with targeting quaternions, but the de-facto standard in game programming are 4x4 matrices.

Whenever you will get in contact with other API, phyics or rendering (i.e. shaders) API, you will most likely need to feed them with matricies. Although quaterions only cover rotation, whereas a homogeneous (which is the standard) 4x4 matrix can handle rotation,translation,scaling and projection in just a single matrix and eventually quaternions, though very important for some special cases, will lack community support. Most developers will be familiar with matrices.

The costs should be exchanged with your real cost function (a long ladder has costs >1, a teleport always 1 etc.).

In my pseudo code it would be better to use a priority queue ( lowest costs element at the beginning ).

And yes, the initial value should be MAX, best to take a look at the pseudo code in wiki. Here's my updated hacked version:

Code:

// init all nodes
for(...) {
  node.g = MAX;
}

// get start node and push it into queue
startNode = ...
startNode.g = 0;
startNode.parent = NULL;
open.push(startNode);

while(!open.isEmpty())
{
  // open is a priortiy queue
  current = open.dequeue();

for(j = 0; j < current.connections.length; j++){
adjacentNode = current.connections[j];

  // get costs to reach adjacent node, should be >0,
  // this ensures that you will not revisit a parent node
  costs = distance(current,adjacentNode);
  // BONUS: adjust costs according to properties, like 'fast travel' or 'teleport'

  // check if it is cheaper to reach adj node
  //(do your searchId-thingy to detect unvisited nodes)
  if( (current.g+costs)<adjacentNode.g )
  {
// update g
adjacentNode.g = current.g+costs;
adjacentNode.parent = current;
 
// add to open list
// ensure that this one is a PRIORITY queue
// if queue is a simple array, use insertion sort
open.push(adjacentNode);
  }
}
}

Trying to understand your code   , searchId etc. are used to avoid clearing the path costs, right ? I've left this out, then basicly you just need to do this:

Code:

for(j = 0; j < current.connections.length; j++){
adjacentNode = current.connections[j];

  // get costs to reach adjacent node, should be >0,
  // this ensures that you will not revisit a parent node
  costs = 1;

  // check if it is cheaper to reach adj node
  //(do your searchId-thingy to detect unvisited nodes)
  if( (current.g+costs)<adjacentNode.g )
  {
    // update g
    adjacentNode.g = current.g+costs;
    adjacentNode.parent = current;
  
    // add to open list
    // ensure that this one is a FIFO queue, no stack, we want a breadth first search
    open.push(adjacentNode);
  }
}

[dungeon keeper + roller coaster tycoon]

dungeon keeper + roller coaster tycoon

Integrate a roller coaster in a dungeon with which the hereos will drive to encounter some nasty traps and your minions.

I think the noise variants looks best, but to be honest, the whole GI effect looks somewhat wrong. Looking at you base image, the yellow blocks are solid earth(?), the grey ones are cavern and the rest is sky/background, right ?

For me disturbing is, that light travels along solid(yellow) blocks. Have you tried to limit it to only grey and adjancent yellow blocks ? Or is it be more of a fog-of-war, shadowing unknown areas ?

Some artists contacted me, I offer one $250 so he realized I am not really a company and just a private person. I guess a "next gen" model should cost at least $500 even $1000 to make?
I am not sure how much to offer...
I will also post here at the paid section.

An artist earns around ~75k in US game industry (source), that's 1.5k per week (freelance could demand more).

Next gen character model:
1. hi-poly (zbrush)
2. retopo/low-poly (max/maya)
3. texturing
4. rigging
5. animation

Time depends on your qualtiy requirements, but I'm sure that you need at least a few weeks for a professional model.

Just out of interest, why do you want to use quaternions ?

Unit quaternions and orthogonal rotation matricies are just different ways to describe the same rotation, so in general when it comes down to game developing, you often use quaternions only if you need to save space (rotation matrix = 3x3, quaternion = 4x1) or if you want to do easy, smooth rotations (slerp, this is the reason it is often used in animation or camera movement).

A matrix setup is often easier to understand (you can read the 4 important vectors, position+3 axis, directly from the 4x4 homogenous matrix) and to manipulate. When you need do smooth movement, write a simple slerp function which takes in matrices, uses internally quaternions and outputs a matrix again. This might help you to keep your sanity. 

Just don't use A* (path finding).

Dijkstra (all possible,shortest pathes) is much more suitable for your issue, though you need to invert the edges because you start at the potential path goal. As long as you don't modify your level on-the-fly, this will be a simple precalulation with just one additional node information (edge index for shortest path to level goal). A* is just an optimisation of the dijkstra algo which will not help you in this issue at all (you still want to visit all nodes).

Some comments on your gui.

1. Try to cluster important elements (life, mana, actions).
2. Move the the most important UI elements where you have a good view of the character and these elements at the same time.
3. Move seldomly used or unimportant things to the corners.
4. Try to minimize eye-movement while playing.
5. A dark background for your gui elements could help to distinguish them better from the game world.
6. You saturated use of color for the ui elements in the left,top corner are a little bit too much. Try to use eye-catching ui elements only if they are really important for some action. You game world should pop up and your ui only if something important is happening (animation will attract more attention than color). I.e. a blinking health bar when you are low on health.

PS: the overall look and art style is really awesome

I think that all the body proportions are fitting in his overall style, btw. the game looks really awesome.

I would work on the side view of the animation. Either the head, nor the body is bobbing, thislink might help you.

[Racing + Sims]

Racing + Sims

You must drive a camper while managing your family back in the camper in a sims-like style.

I like to see health as pace controller of the game flow, and not as punishment for failure.

You as player react in different ways to the state of your healthbar. When it reduces, you slow down, get more defensive, trying to recover, whereas when you have full health you do more risky things, play more aggressively.

This have not changed much in the recent two decades, early arcade games have 'lifes', then came a health bar, then heath regenration and modern games like CoD  don't even show up any health at all.

There are two important aspects of this view. First, changing pace will make your game much more interesting, it is like a drama, you need up and downs (i.e. L4D is doing this in a dynamic, very clever way). The second import part is, that you , as game designer, have an instrument to control the pace by defining the rule of recovering (i.e. clever placement of health potions).

When it comes to punishment, you need other aspects like enemy respawning or permadeath, this has other effects on the player not directly linked to the pace of the game.