On XNA this is an out of the box option but if you’re using C++ you have a bit more work to do first.

First of all, you will need the DirecX 9.0+ sdk.

The includes.

#define WIN32_LEAN_AND_MEAN // We don't want the extra stuff like MFC and such
#include <windows>
#include <XInput.h>     // XInput API
#pragma comment(lib, "XInput.lib")   // Library. If your compiler doesn't support this type of lib include change to the corresponding one

Let’s define the buttons

typedef enum
{
	GamePad_Button_DPAD_UP          = 0,
	GamePad_Button_DPAD_DOWN        = 1,
	GamePad_Button_DPAD_LEFT        = 2,
	GamePad_Button_DPAD_RIGHT       = 3,
	GamePad_Button_START            = 4,
	GamePad_Button_BACK             = 5,
	GamePad_Button_LEFT_THUMB       = 6,
	GamePad_Button_RIGHT_THUMB      = 7,
	GamePad_Button_LEFT_SHOULDER    = 8,
	GamePad_Button_RIGHT_SHOULDER   = 9,
	GamePad_Button_A                = 10,
	GamePad_Button_B                = 11,
	GamePad_Button_X                = 12,
	GamePad_Button_Y                = 13,
	GamePadButton_Max =             14
}GamePadButton;

After some digging I don’t think Microsoft exposes access to the Guide button, let me know if you find anything. Anyway it’s not something we need on Windows.

Now the GamePadIndexes

// GamePad Indexes
typedef enum
{
	GamePadIndex_One =  0,
	GamePadIndex_Two =  1,
	GamePadIndex_Three =2,
	GamePadIndex_Four = 3,
}GamePadIndex;

The GamePadIndex is to define the player position. Like on the Xbox360, this way we can control up to 4 controllers.

We need something to store the GamePad state

// The GamePad State Stuct, were we store the buttons positions
struct GamePadState 
{
	bool		_buttons[GamePadButton_Max];
	Vector2 	_left_thumbstick;               // <= I'm using a Vector2 (floats) class but you can replaced it with a float X and Y or whatever your Vector2 class is
	Vector2	        _right_thumbstick;
	float		_left_trigger;
	float		_right_trigger;	
        // Just to clear all values to default
	void reset()
	{
		for (int i=0;i<(int)GamePadButton_Max;++i) _buttons[i] = false;
		_left_thumbstick.set(0.0f);
		_right_thumbstick.set(0.0f);
		_left_trigger = _right_trigger = 0.0f;
	}
};

Now a small class

 
class GamePadXbox 
{
public: 
	GamePadXbox(GamePadIndex player)			
	{
                  _playerIndex = player;
                  State.reset();
	}
 
	virtual ~GamePadXbox(void)
	{
		// We don't want the controller to be vibrating accidentally when we exit the app
		if(is_connected()) vibrate(0.0f,0.0f);
	}
 
	bool is_connected();
        void vibrate(float leftmotor = 0.0f, float rightmotor = 0.0f);
	void update();
 
 public:
   GamePadState	State;
 private:
   XINPUT_STATE _controllerState;
   GamePadIndex _playerIndex;
 
};

Now, onto the GamePadXbox::is_connected()

bool is_connected()
{
     // clean the state
     memset(&_controllerState,0, sizeof(XINPUT_STATE));
 
     // Get the state
     DWORD Result = XInputGetState(_controllerNum, &_controllerState);
 
     if(Result == ERROR_SUCCESS)	return true;
     else return false;
}

Documentation for the XInputGetState is here.

Onto the vibrate function. Now, the Vibration accepts values between 0 and 65535. But we don’t want to be typing that every time so the vibrate accepts from a range of 0.0f (0) to 1.0f (65535);

void vibrate(float leftmotor = 0.0f, float rightmotor = 0.0f)
{
	// Create a new Vibraton 
	XINPUT_VIBRATION Vibration;
 
	memset(&Vibration, 0, sizeof(XINPUT_VIBRATION));
 
	int leftVib = (int)(leftmotor*65535.0f);
	int rightVib = (int)(rightmotor*65535.0f);
 
	// Set the Vibration Values
	Vibration.wLeftMotorSpeed = leftVib;
	Vibration.wRightMotorSpeed = rightVib;
        // Vibrate the controller
	XInputSetState((int)_controllerNum, &Vibration);
}

On the destructor I’ve placed the vibrate at 0.0f otherwise the controller may be left vibrating after your game exits until the user unplugs it.

Finally, the update() function. Now this one is more out of convenience, since you could get the state straight out of XINPUT_STATE but I think this is a more consistent way of doing it. You can decide how you want on yours.

void update()
{
	State.reset();
        // The values of the Left and Right Triggers go from 0 to 255. We just convert them to 0.0f=>1.0f
	if(_controllerState.Gamepad.bRightTrigger && _controllerState.Gamepad.bRightTrigger < XINPUT_GAMEPAD_TRIGGER_THRESHOLD)
	{
		State._right_trigger = _controllerState.Gamepad.bRightTrigger/255.0f;
	}
 
	if(_controllerState.Gamepad.bLeftTrigger && _controllerState.Gamepad.bLeftTrigger < XINPUT_GAMEPAD_TRIGGER_THRESHOLD)
	{
		State._left_trigger = _controllerState.Gamepad.bLeftTrigger/255.0f;
	}
 
       // Get the Buttons
        if(_controllerState.Gamepad.wButtons & XINPUT_GAMEPAD_A) State._buttons[GamePad_Button_A] = true;
        if(_controllerState.Gamepad.wButtons & XINPUT_GAMEPAD_B) State._buttons[GamePad_Button_B] = true;
	if(_controllerState.Gamepad.wButtons & XINPUT_GAMEPAD_X) State._buttons[GamePad_Button_X] = true;
	if(_controllerState.Gamepad.wButtons & XINPUT_GAMEPAD_Y) State._buttons[GamePad_Button_Y] = true;
	if(_controllerState.Gamepad.wButtons & XINPUT_GAMEPAD_DPAD_DOWN) State._buttons[GamePad_Button_DPAD_DOWN] = true;
		// The Rest is missing, you can figure out the rest :)
 
....
             (ThumbSticks code below)   
}

For getting all buttons here are the official flags according to msdn

XINPUT_GAMEPAD_DPAD_UP          0x00000001
XINPUT_GAMEPAD_DPAD_DOWN        0x00000002
XINPUT_GAMEPAD_DPAD_LEFT        0x00000004
XINPUT_GAMEPAD_DPAD_RIGHT       0x00000008
XINPUT_GAMEPAD_START            0x00000010
XINPUT_GAMEPAD_BACK             0x00000020
XINPUT_GAMEPAD_LEFT_THUMB       0x00000040
XINPUT_GAMEPAD_RIGHT_THUMB      0x00000080
XINPUT_GAMEPAD_LEFT_SHOULDER    0x0100
XINPUT_GAMEPAD_RIGHT_SHOULDER   0x0200
XINPUT_GAMEPAD_A                0x1000
XINPUT_GAMEPAD_B                0x2000
XINPUT_GAMEPAD_X                0x4000
XINPUT_GAMEPAD_Y                0x8000

The ThumbSticks are a bit more tricky. They return 2 axis each but you have to make sure they are not in the deadzone. The deadzone pretty much are values !=0 but that are not relevant and can lead to errors.

 
  // Check to make sure we are not moving during the dead zone
  // Let's check the Left DeadZone
  if( (_controllerState.Gamepad.sThumbLX < XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE &&
	_controllerState.Gamepad.sThumbLX > -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE) &&
	(_controllerState.Gamepad.sThumbLY < XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE &&
	_controllerState.Gamepad.sThumbLY > -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE) )
  {    
	_controllerState.Gamepad.sThumbLX = 0;
	_controllerState.Gamepad.sThumbLY = 0;
  }
 
  // Check left thumbStick
 
  float leftThumbY = _controllerState.Gamepad.sThumbLY;
  if(leftThumbY)
  {
        State._left_thumbstick.Y = leftThumbY;
  }
  float leftThumbX = _controllerState.Gamepad.sThumbLX;
  if(leftThumbX)
  {
	State._left_thumbstick.X = leftThumbX;
  }    
 
  // For the rightThumbstick it's pretty much the same.

So how would we use this then?

int main()
{
     GamePadXbox* pad = new GamePadXbox(GamePadIndex_One);
 
     while(1)
     {
       if(pad->is_connected())
       {
          pad->update();
 
          if(pad->State._buttons[GamePad_Button_BACK]==true) break;
       }   
     }
     delete pad;
}

Anyway, most of this code is not elegant or “pretty” but it should work, the idea is for you to understand the concept, the rest is up to you.

Lately I’ve been working on the light system and fog of war for the game, it’s visible on the images.

Here’s the official post but I’ve placed the images here for convenience.

New game, called Dary’s Legend, a roguelike, dungeon crawling type.
This is what I’ve been working on lately, and … well not much more to say.

I’ll try and do posts with relevant stuff regarding the development of the game from now on.

Going back to coding now…

I’m trying to decide where my next game should store their save files so I decided to make a poll.

Personally I think that

C:/Users/$USER$/AppData/Local/

is a total idiotic thing.

Starting on Windows Vista there’s a pre-created “Saved Games” folder but most people seem to miss it since it’s not on the “My Documents” folder.

There’s also other possibilities which many games I own use like

My Documents\My Games\Game\

Others just create a folder directly on “My Documents” which some users find a bit obstructive.

I’ve been considering giving a read at Dropbox API (if any) too, It would be a nice touch to allow direct integration. But that’s just an idea that’s probably tricky to integrate.

So tell me what you think or suggest another one.

1 – You either are, or you aren’t.
People can go and , “I’m an aspiring indie game developer”. You are either doing games or not, period. If you are starting in development with your own money then you are one. People tend to think they are indie developers when money starts rolling in, well think again, cause money may never come.

2 – It’s a jungle out there
There’s not a safe path on becoming a successful indie developer. It’s not like following another’s path will get you there. That’s why giving advices is just that, it might work or not.

3 – There’s a minefield being left behind
We see it everywhere, indie bundles, pay what you want, fremium games, games at $1, the ones who made money with those models are leaving behind a bad legacy and an audience that doesn’t want to pay much.

4 – Finish you stuff
You should actually be working instead of reading this.

5 – You need to learn the rules
… to know when they must be broken

6 – You need to break the rules
… to know why they matter.

7 – Playing games does NOT make you a developer
Yet many think it’s all it takes, I’m good at playing thus I must be good at making them. You should however play critically, that is the key.

8 – Working alone
..can be like rowing a boat with just one paddle.

9 – Working with a team
…can be like two people on a bike, one steering and another one pedaling.

10 – Overnight success
Out of nothing this indie developer! Overnight success! Million-dollar!
And you think, “I can do that”. Yeah, except, those who are “overnight successes,” rarely appear out of nowhere. Minecraft? That dude’s been working in games for years. Super Meat Boy? I bet Edmund made over 30 games till now. They just stayed in obscurity for years. Work matters.

11 – Learn to fall
This one’s hard especially if you think your game is great and the first comment is “This is sh**”. Learn from mistakes and do it again, but better.

12 – Making games is hard work
…and you will shoot fire from your eyes to whoever says otherwise.

13 – People who tell you to keep trying
…are mostly lying, they think you’re lazy and can’t get a real job.

14 – Your parents will keep the hope
…that you get your act together and apply for IBM or Microsoft, cause that’s where the money is.

15 – You will think twice
…when someone asks you what you do for a living. It would be the first thing said if you were a Doctor.

Taking a rest between some more complex game mechanisms I decided to start doing a video player.

After a bit research I decided to choose theora, but a bit skeptic, I’ve used it before on a game company I worked at and I remember being a tiny nightmare, specially because of YUV->RGB(A) conversion and because of video/audio sync.

If I remember correctly we couldn’t play audio, we where using separated tracks and paying the audio via a normal music play and big resolution videos (>500??) where a killer.

Anyway, since I’m already using OpenAL for audio I decided to give it a try. Unfortunately I didn’t had that code we where using back then so I had to do some digging on the internet.

So after a few days I had it working but bumped into the same problem, a bit slow. Not as slow as before cause computers have evolved. But after some reading I discovered that you can actually cache some YUV->RBG values and speed went up by like 10 fold.

I can decode 1080p videos with audio on my Core2Duo @ 2 GHz. And I mention the core since I have the decoding from the file on a separated thread so on a single core it’s probably a bit slower.
But we probably will be placing videos around 512px width so there’s no problem there. I wonder if we could do the YUV->RGBA on the GPU side via a shader?

It’s also worth mentioning that I’m using OpenGL and “glTexSubImage2D” for updating the texture. I found out that it’s much faster than “glTexImage2D” because it respecifies the entire texture, changing its size, deleting the previous data, and so forth. “glTexSubImage2D” only modifies pixel data within the texture.

Tools

On the tools realm there was a need for a better Particle System Editor, the one we had has many things but adding stuff was turning into a nightmare, the old editor was build on XNA 3.1 which isn’t supported by VS2010.
Since the engine is already in C++ I started from scratch and built this handy tool in 3 days or so:

Not vary fancy but it gets the job done.

My next step was to fix most of the Sprite Sheet Editor bugs and issues my designer had been complaining about.

I already have an offline tool that grabs a bunch of tiny images and place them in an Atlas but most of the time the designer has the pieces together already on Photoshop so I incorporated a snippet of code that on double clicking an area tries to automatically detect the region around it. Anything that fails can be manually defined, the old fashioned way.

So in the next few days I’m working on the Animation Editor so the artist can quickly create and preview the animations from the sprite sheets without the need for me to place them in the game before hand.

I had most of these tools but they where awful. They did the trick for Vizati but now I’m trying to do things a bit better.

See you soon…

Anyway where’s a quick tip on how to fix it (You need a Windows 7 DVD of course)!

1 – Boot your computer to the Windows 7 DVD
2 – Select your language and click next.
3 – Click the button for “Use recovery tools”.
4 – Then select “Command Prompt”.

Do this:

 
Type: diskpart
and press Enter
 
Type: select disk 0
and press Enter
 
type: list volume
and press Enter

6 – Use your DVD drive letter so we can access the DVD

Type: exit
and press Enter
 
to close Diskpart
 
Type: G: (DVD drive)
and press Enter
 
Type: cd boot
and press Enter
 
Type: dir
and press Enter

7 – To restore the “bootsector code”:

 
TYPE: bootsect /nt60 SYS /mbr
and press Enter

You should be able to restart and boot you Windows now, if it fails, well, I’m out of ideas

But today I had this function I wanted to get rid of and simple change it with a public variable.

So I had something like this.

object->setLayer(/*BLABAL BLA CODE, */);

I want to replace it with something more simple

object->Z = /*BLABAL BLA CODE, */;

So using Visual Studio Find/Replace in regular expressions mode I used this as a search string

setLayer\({.+}\);

And this as a Replace with string

Z=\1;

Now, notice the first one, it’s actually simple, you have “setLayer”, followed by “\(” to tell the expression we really need to be that character, after than we have “.+”, which means match any single character except a line break and at least one occurrence. Followed by “\);”

Now if you notice we have curly brackets around the inside of what the function receives as parameter, that’s because we are tagging that string to use it later.

This way on the replace we simply need “Z=” followed by the first tagged string we have “\1″. if we have more curly brackets it would be “\2″, “\3″ etc.

Check the full list for more options: http://msdn.microsoft.com/en-us/library/2k3te2cs%28v=vs.80%29.aspx

Still over the last year I’ve gradually saw out little Different Pixel brand reaching more and more places which can be very helpful in the future and sure hell is nice to see work recognized.

From the top of my head I recall Kotaku article on the Xbox360 release, we finally managed to release the Xbox360 version, which was the first one we made. Being a semi-finalist on Dream.Build.Play 2011 and the coverage on Destructoid.

More and more I get to know developers from around the world and it’s been awesome, exchanging ideas, cultural stuff, helping solve trivial stuff that we sometimes miss, the indie dev community is really neat.

I worked most of this year on web development which is good and sucks at both time, on one hand it keeps me closer and updated on where technology/trend is headed and that’s always good, on the other hand I never really liked it that much and further more, all stuff now circles around Facebook, which I think is pathetic, get your own website, don’t host your company page on Facebook, it should be an alternative not the real thing.

I got accepted to the 2011 Codebits which was a blast, seriously, I’m definitely trying to go this the 2012 edition as well.

Rant: One note to the people closer to me, asking me every now and then how many copies we sold it’s annoying, I don’t ask you how much you earn on your job do I?

Favorite games:
Portal 2
Rage
Bastion
Terraria
Frozen Synapse
(a couple more probably which I don’t recall)

Favorite movies:
Real Steel
Super 8
Rise of the Planet of the Apes
Source Code
Mission Impossible 4
Fast and Furious 5

Favorite shows:
Breaking Bad
Castle
The Walking Dead
Chuck

So my hopes for the next year are to be able to release the current game in the oven, I’m really glad Rita accepted once again to make another one. Not only because of her art but because the way she see games, bringing a new perspective to things, also because, most artists/coders I know just want to do 3D games which I personally think can ruin things sometimes just by adding a third dimension. Just watch what happened to Sonic once it went 3d.

Happy new Year!!

This is a test on Basalt, and although I’ve been working on the engine since January 2010, only in 2011 did I placed in on a repository so a bunch of stuff is added right on the beginning.

This is the result.

Unfortunately since they are now part of Twitter I had a hard time finding the older build and decided to share it.

And that’s why you are here too probably, here it is: Tweetdeck 0.38.2, along with all other versions are available at oldversion.com. Don’t forget you need Adobe Air installed.

Edit 29-12-2011
Some user have experienced a

“This application cannot be installed because this installer has been mis-configured. Please contact the application author for assistance.”

They solved it by uninstalling all previous versions of tweetdeck. Make sure you don’t have another one already installed.

After a month, I think so far progress has been good. I’ve been able to work almost entirely on the game itself instead of the engine because most of the stuff is stable enough since Vizati.

It’s kind of rewarding now and instead of reading tons of docs of other engines each time something doesn’t work right I usually know where the problem may be and can fix it, as good as I can at least.
A few glitches here and there but so far so good.

I’ve managed to integrate GLSL to the engine after struggling a bit on the whole OpenGL extensions concept. Querying for extensions on the hardware/driver is a bit of obscure science, but it’s just a matter looking for them before using it.

Since GLSL isn’t part of OpenGL core before GL 2 if I end up placing any shaders, on older hardware (less than GL 2) I guess I’ll fallback to just fixed function. I’m still unsure about going “OpenGL 2 hardware required”, mainly because of integrated Intel cards. From what I could gather ATI supports it since the Radeon 9500 (2002), same time as DX9, so all ATI dx9 compatible should allow GL2 too. Nvidia since GeForce 6 Series (2004) I think, Intel is a bit of a mystery to me.

I’ve also added a DirectX9 layer to the Render but it’s not finished, It’s just successfully creating the device in a window, still ignores everything the engine asks to draw. It might be a good idea in the future finishing it, if the target ends up being Windows it’s probably a better choice to use DX or maybe having an option in the game.

Oh, Git has been a life saver, seriously. Every dev should use it.

My artist has also been hard at work and so far I’m loving what’s done.

Until the next update.

Like most developers out there I’ve been impressed by John Carmack’s work and breakthroughs in gaming and computer graphics for years. When I first heard Rage was targeting 60FPS I got intrigued.
Almost every game targets 30FPS and targeting twice as that leaves less time to render each frame, even more since they were promising vast wastelands, detailed characters, top notch animations and AI.

But enough of that. I got the PC version since I’m old fashioned and I think shooters are best played with Mouse/Kb. Besides that shooters are always a tad slower on consoles to compensate the lack of Mouse for aiming.

The game comes packed on 3 DVD summing a 23GB install.

The story takes place after a meteor crashing into the earth, several arks where placed underground with people in order for mankind to survive. You are one of those survivors.
There isn’t much more into, after you wake up you discovered most of the planet is a wasteland ruled by bandits, mutants and others.

From there you jump from mission to mission against the several factions.

Apart from some technical issues I first encountered, after updating the drivers I managed to play it smoothly on my laptop, my desktop rig is quite old now (6+ years) so it doesn’t quite handle it at 1080p.

I’m very impressed with the game’s smooth animations and enemy AI. The story itself is crap but the whole fun in this game is just playing it, the battles always feel fresh, holding the shotgun feels like an id gun indeed. You keep encountering new enemies with new tricks, near the end you are still trying to get the hang of that new enemy tactics.

If you have the chance try it.

First, I have tones of unread, thus answered emails on my inbox. I haven’t managed to go through that lately. I usually scroll to see if there’s a really urgent one, I will eventually read them all.

I decided to quit my current job, my last day is October 31st. I couldn’t glimpse a very promising carrier there and I practically staggered learning-wise for the past months due to the type of work we develop so yeah, that’s it.

That also means that I’m taking some time to finish the current game in hands, yeahh.

I can’t talk about it but I’m quite excited with this. I expect to have some news about the game soon but mostly likely I won’t update the blog till then. I’ll probably keep ranting on twitter though =)

So starting November 1st I’ll be on my code cave @ Different Pixel.

Wish me luck…

Mainly with the rendering section, trying to squeeze as much as possible, thus maintaining an acceptable framerate. It’s not like I’m doing a heavily graphic game but I like to know that It can be used even on slower pcs and that I’m not using more cycles than necessary.

This past week and after reading a bunch of stuff and keynotes from John Carmack about Rage (60FPS ftw) I decided to measure my own stuff.

So let’s break this down, your framerate or FPS is the number of images you draw per second, not just that, you have to animate stuff, play sound, collisions, etc.

Most 3D games nowadays target 30 FPS, it’s the minimum acceptable before you start noticing slowdowns or not so smooth animations, for 2D games it’s a pretty realistic objective to target 60FPS.

Let say you want to target 30 FPS,

  1 second = 1000 milliseconds
  1000/30 = ~33.3 milliseconds

That means that for 30 FPS you have to calculate, animate, do collision and draw the scene in under 33.3 milliseconds. And do it again 30 more times.
Sounds hard doesn’t it?

At 60 FPS it’s even worse

  1000/60 = ~16.6 milliseconds

16.6 milliseconds to do a full loop on your engine. Actually with modern technology it’s not an impressive accomplishment depending on what you are doing but it’s a good practice to
look at these numbers, consider them while you code.

Now I’ve been making some tests on my own engine and I placed 2000 sprites each with a sprite animation and an A* pathfinding (2000 paths can be cached at a time) rendering at 100 FPS.
It runs well and each loops takes 9ms.

   1000/100 = 10ms

Each loop could take up to 10ms, so I’m wasting 1ms for each loop, bringing the sum up to 100ms per second.
When I say waste it doesn’t mean you could be doing something else but you could make you game a bit more CPU friendly make making it sleep that extra millisecond each cycle.
This will actually make you game use less of a processor and you can even check it on the Windows Task Manager.

At just 60 FPS, let’s say I’m drawing everything at 9ms too, but I could take up to 16.6

   16 - 9 = 7ms
   7 * 60 (FPS) = 420ms

You can make your application sleep for almost half of a second and the game would run exactly the same
Isn’t that something?

I’ve made a change on my pump to accommodate this and tested on Vizati, now most of the time it uses 12% of the CPU with bursts of 32%.
Of course by measuring this you can also do cooler stuff like, let’s say you walk by a heavy area, or need to do some calculations, by lowering the intended FPS and drawing less times in that second you can get the other calculations done faster and return to a normal FPS much faster.

Well I hope this wasn’t too boring =)

EDIT:
After talking to some other devs there are mixed feelings about the benefits of putting your application to sleep those extra milliseconds. One thing that’s worth mentioning is that when you put your application to sleep you only guarantee that it will be idle for a minimum of let’s say 5ms, you may only regain control after 7ms, that’s really up to the OS.
So my suggestion is, leave it as an option in the game, CPU throttling or something. Each user may test and see if it benefits, and in a couple of years it may in fact make some difference with to futuristic 30 core cpu where you don’t need to be using 100% of it. Starcraft 1 got a patch to do just that some time ago.