I was in charge of developing the network infrastructure for the game, which consisted of a central Master Server responsible for initial authentication of the client and upon success it was in charge of connecting the client to a Game Server, which was then responsible for all in-game updates. Load balancing was implemented in order to manage multiple connections and create additional instances of Game Servers when maximum capacity was reached.

A MySQL database was created to communicate important information and data about the client. Master Server and Game Servers were able to communicate directly with it and retrieve or modify data by using the MySQL .NET connector as an interface between the C# native server and MySQL.

I was also in charge of a complete rework of the UI and flow of menus and tutorials. All of the GUI work has been done using EZGUI, a plugin for Unity3D. Furthermore, I coordinated and executed a variety of optimizations and code refactoring to improve upon the existing codebase.

An interesting thing is that, although not being a student is a good feeling, this also means that I’m now unemployed. The following months will be spent looking for a position as a programmer at a Game Company, and also start on some of my personal projects that I’ve been putting aside for far too long now. One of them is learning Objective C and get more experience with iOS and XCode.

On the other side, I’m spending some time with my family and friends back home in Italy. Having some free time after these hectic two years really feels refreshing It also means I’ll have a fair amount of gaming to do

Language: C++, C# (particle editor)

Installer: an installer for the game can be found here.

Description: Dungeon Divers was the first team project I worked on while in school. The team was composed of 4 programmers and the time required to complete the project was 2 months.

Dungeon Divers is an action game where the player will adventure through a series of dungeons to defeat enemies. The player can choose from 4 different classes, which will have different special abilities and also a different styles of play. For example, the warrior will have a lot of health and will be able to do an area of effect attack, while the cleric will be able to heal.

The game has also support for Xbox 360 controller, and up to 4 players local multiplayer.

Language: C++

Team Name: Double Punch Kick Games

Description: This is the Final Project game that our team is currently developing at Full Sail University. We are a team of 5 programmers and 2 artists, and we’ve been working on this game for 5 months. Sheeple is an arcade style game where the player walks around a mall and has one main objective to accomplish: slap the teeth out of cliques!

That’s right! You will meet a lot of different cliques in the mall wondering close to their favorite stores, for example you will find some Emos near Warm Issue (Hot Topic), and they will continue to grow in size, eventually reaching critical mass, and convert you to be one of them.

The player will not be able to avoid eventually being converted, so the main goal of the game is to control the growth of the cliques and collect their teeth, obtained by slapping them, and try to get a High Score. Sounds simple, right? Except for the fact that the mall is full with Grey People, which represents all the mass of people that don’t have an identity, and will just convert to one of the cliques already present in the mall.

The player will have to use them wisely, though, since moving against the crowd will make you move slower, while moving with them will make you go faster. This adds a puzzle-strategy component to the game, since now the players will have to decide whether or not going for an easy slap, but lose time because you are slowed, or follow the crowd, and potentially reach a clique faster.

And that’s not all! By collecting teeth, the player will be able to unlock different upgrades for his slap, such as one and two hit combos, and different kind of charge slaps, such as a Whirlwind slap, which will slap a number of clique members around you, or a Cleave slap, which will swipe a few cliques in a 180 degrees area in front of you. The best slap is the Mark of The Wolf though, and the only way you can fully enjoy it, is by playing the game! You can download the final version here.

We arrived in the afternoon, so the rest day was spent to get food, which I found quite delicious as we stopped at a really good Thai restaurant, and also to rest after the long flight from Orlando. The hotel here is pretty nice, props to Jezzy for organizing everything. It’s also really close to the conference, which is always good especially when you have no other means of transportation but yourself : )

Tomorrow we are going to be registering for the conference and receive our passes. The rest of the day will be probably just us going around the city. We were talking about going to China Town, so we might end up having lunch down there, which I’d really like to as I’m fond of Asian food. Tomorrow a few other classmates will be joining us as well, so we’ll probably meet with them after they get here and hang out in the evening. I still have to check if tomorrow evening there’s a party going on or not, can’t find anything about it, I’ll have to look for clues at the conference when I register.

As for the rest, I’m really happy to be here, and I hope to not only meet a lot of new people and make some great connections, but also learn something new and fascinating by attending the different sessions and keynotes. More to come in the next days!

This is the header file:

#ifndef SKELETON_H_
#define SKELETON_H_
 
/***********************************************
 * Filename:  		Bone.h
 * Date:      		2/09/2011
 * Mod. Date: 		2/09/2011
 * Mod. Initials:	AM
 * Author:    		Alessandro Metta
 * Purpose:   		This class will be responsible
 *					of holding the skeleton hierarchy
 *					for the animation and update it
 ************************************************/
 
#include <vector>
#include ".././Math/MathLib.h"
#include <string>
#include "AnimUtils.h"
 
class CAnimation;
class CInterpolator;
 
class CSkeleton
{
private:
 
	CAnimation* m_pAnimation;
	CInterpolator* m_pInterpolator;
	std::vector<TBoneFrame> m_vImportedHierarchy;
	int m_nNumOfRoots;	
 
public:
 
	CSkeleton();
	~CSkeleton();
 
	CSkeleton(const CSkeleton& copy);
	CSkeleton& operator= (const CSkeleton& copy);
 
 
	/*****************************************************************
	 * Load():  Loads the skeleton hierarchy from a binary file
	 *
	 * Ins:			    szFileName
	 *
	 * Outs:		    void
	 *
	 * Returns:			void
	 *
	 * Mod. Date:		2/09/2011
	 * Mod. Initials:	AM
	 *****************************************************************/
	void Load(std::string szFileName);
 
	/***************
	* Mutators
	***************/
	void SetAnimation(CAnimation* pAnimation) { this->m_pAnimation = pAnimation; }
 
	/***************
	*  Accessors
	***************/
	std::vector<TBoneFrame>& GetHierarchy(void) { return this->m_vImportedHierarchy; }
	CInterpolator* GetInterpolator(void) { return this->m_pInterpolator; }
	CAnimation* GetAnimation(void) { return this->m_pAnimation; }
 
	/*****************************************************************
	 * Update():	Updates the bone hierarchy with the information from the 
	 *				animation's keyframes
	 *
	 * Ins:			    fElapsedTime
	 *
	 * Outs:		    void
	 *
	 * Returns:			void
	 *
	 * Mod. Date:		2/09/2011
	 * Mod. Initials:	AM
	 *****************************************************************/
	void Update(float fElapsedTime);
 
};
 
#endif	//SKELETON_H_

And here is the .cpp:

/***********************************************
 * Filename:  		Bone.cpp
 * Date:      		2/09/2011
 * Mod. Date: 		2/09/2011
 * Mod. Initials:	AM
 * Author:    		Alessandro Metta
 * Purpose:   		This class will be responsible
 *					of holding the skeleton hierarchy
 *					for the animation and update it
 ************************************************/
 
 
#include "Bone.h"
#include "../ShaderManager/CShaderManager.h"
#include <fstream>
#include "Animation.h"
#include "Interpolator.h"
 
CSkeleton::CSkeleton()
{
	this->m_pInterpolator = new CInterpolator();
}
 
CSkeleton::~CSkeleton()
{
	m_vImportedHierarchy.clear();
	delete this->m_pInterpolator;
}
 
CSkeleton::CSkeleton(const CSkeleton& copy)
{
	*this = copy;
}
 
CSkeleton& CSkeleton::operator= (const CSkeleton& copy)
{
	if(this != &copy)
	{
		m_vImportedHierarchy = copy.m_vImportedHierarchy;
	}
	return *this;
}
 
void CSkeleton::Load(std::string szFileName)
{
	std::fstream in;
	in.open(szFileName.c_str(), std::ios_base::in | std::ios_base::binary);
	if(in.is_open())
	{
		int nNumOfJoints = -1;
		int nNameLength = -1;
 
		//Creating a temporary varialbe to store the bone information
		TBoneFrame tTemp;
 
		//Reading in the number of Joints
		in.read((char*)&nNumOfJoints, sizeof(int));
 
		//Temporary variable created to store the position data of the bone
		matrix4 cLocalMatrix;
 
		for(int currJoint = 0; currJoint < nNumOfJoints; ++currJoint)
		{
			//Reading in the Bone information from the file
			in.read((char*)&tTemp.m_nBoneIndex, sizeof(int));
			in.read((char*)&nNameLength, sizeof(int));
			char szBuffer[50];
			in.read((char*)&szBuffer, nNameLength);
			tTemp.m_szName = szBuffer;
 
			//Reading in position data
			float fTemp;
			for(short matIndex = 0; matIndex < 16; ++matIndex)
			{
				in.read((char*)(&fTemp), sizeof(float));
				cLocalMatrix.mat[matIndex] = fTemp;
			}
			tTemp.SetLocal(cLocalMatrix);
			this->m_vImportedHierarchy.push_back(tTemp);
		}
 
		int nNumOfBones = -1;
		int nCurrBoneIndex = -1;
		int nCurrParentIndex = -1;
		in.read((char*)(&m_nNumOfRoots), sizeof(int));
		for(int currRoot = 0; currRoot < m_nNumOfRoots; ++currRoot)
		{
			in.read((char*)(&nNumOfBones), sizeof(int));
 
			for(int currBone = 0; currBone < nNumOfBones; ++currBone)
			{
				//Reading in the information needed to set up the Skeleton Hierarchy
				in.read((char*)&nCurrBoneIndex, sizeof(int));
				in.read((char*)&nCurrParentIndex, sizeof(int));
				this->m_vImportedHierarchy[nCurrBoneIndex].m_nParent = nCurrParentIndex;
			}
		}
 
 
	}
	in.close();
 
 
 
	//Setting up the bone hierarchy
	for(unsigned int i = 0; i < this->m_vImportedHierarchy.size(); ++i)
	{
		if(this->m_vImportedHierarchy[i].m_nParent > -1)
		{
			//Adding a child to the proper parent
			this->m_vImportedHierarchy[this->m_vImportedHierarchy[i].m_nParent].AddChild(\
				&this->m_vImportedHierarchy[i]);
		}
	}
 
	//Updating the Skeleton Hierarchy
	for(unsigned int i = 0; i < this->m_vImportedHierarchy.size(); ++i)
	{
		this->m_vImportedHierarchy[i].Update();
		this->m_vImportedHierarchy[i].GetWorld();
	}
}
 
void CSkeleton::Update(float fElapsedTime)
{
 
	this->m_pInterpolator->AddTime(fElapsedTime);
 
	while(this->m_pInterpolator->GetCurrTime() >= this->m_pAnimation->GetDuration())
		this->m_pInterpolator->AddTime(-this->m_pAnimation->GetDuration());
 
	while(this->m_pInterpolator->GetCurrTime() < 0.0f)
		this->m_pInterpolator->AddTime(this->m_pAnimation->GetDuration());
 
	//Interpolate the animation's keyframes
	this->m_pInterpolator->Interpolate(this->m_vImportedHierarchy, this->m_pAnimation);
 
 
	for(unsigned int i = 0; i < this->m_vImportedHierarchy.size(); ++i)
	{
		this->m_vImportedHierarchy[i].Update();
		this->m_vImportedHierarchy[i].GetWorld();
	}
}

I’m excited about it because…well mostly because it means that it will be only 5 months till graduation, which is always good to keep in mind. But seriously, I’m excited about it because it will be the first real project we get ourselves into. A whole game from the ground up. Do everything. GO! One thing we have been discussing though it’s the third party libraries that you are allowed to use.

For what I’ve been hearing from people that were in final project or that are already done with it, the team are allowed to use only one third party library, and that’s excluding OpenGL and DirectX. Basically, the choices comes down to only sound libraries, which is somewhat asinine, since this would mean that , for example, if you chose a physics library or a networking library, that’s it for your team; you then would need to use DirectSound for all the sounds and music in your game.

Yeah…our class is really hoping that this is not the case, heh. We’ll know soon enough though. Together with the teams. Aaaarghhh!

So you might be wondering, ok, we know how the last hour of the last day was, but what can you tell me about the conference itself, what about the main thing? Well, all I can say is that overall it is a very good experience.

Don’t expect anything too fancy, or too big for what it matters: the expo was really small this year, and only a few developers showed up and had booths set up; among them Vigil Games, Bioware, EA Sports, Turbine and WB Games, 38 Studios. The rest of the booths were set up for Universities, companies like Dell or BigPoint Games, and middleware software companies. For an aspirant game programmer, not exactly a whole lot of opportunities to grasp on there, but still, better than nothing.

What really threw me off was the quantity and level of programming sessions. Let alone the fact that I could attend only a limited number of them, there weren’t nearly as many as I would have liked. The two sessions I have attended were from Intel, and they were about multithreading, rendering analysis and optimization, and parallel rendering using Directx11. Now, I didn’t know what to expect from those, in fact I had little or no idea what they were going to cover, but in the end, they left me with mixed feelings, a bittersweet taste.

The talks were a little bit too much dry, and the first guy that was presenting didn’t really seem like the public speaking figure you’d expect to see from someone who’s holding a public session, but the things that they showed were really something cool. The software that they have at Intel for analyzing and optimizing rendering bottlenecks could be extremely useful to developers, and it also seemed pretty user friendly. The idea of having a system where the data is parallel and you can basically use a parallelized Render function was at the core of the session. All in all, they were good.

The coolest about events and conferences like GDC, though, is that you have a chance to talk to people that have worked on the games that you play, games that are still in development, but you can’t wait to hold in your hands, and games that are just waiting for you to try them out. I had the great opportunity of talking to a good number of people from Vigil Games and they all seemed extremely nice and very open, giving me the impression that their company might be a very good place to work at. I met a few programmers that are working on both Warhammer 40k the mmo, and Darksiders 2, together with people from the marketing department, game design, and animation. All of them seemed to be very happy about their position, and they didn’t seem to mind the fact that they have been crunching for a long time, and they are probably going to again. And they are also looking for a lot programmers : )

Another company that left me a very good impression was 38 studios. The girl I talked to, Lindsey, was very very nice, and she had no problem at all in having a little chat about what they do, what they were working on, what kind of positions they were trying to fill in. I really had a nice chat with her, and it seemed like 38 studios could be another good choice. We’ll see what happens from there.

We also had a chance of attending the GDC Online Awards. They were really something different, and the feeling of the whole thing was really hollywoodian. And Riot Games won 5 awards, so I was happy : )

In the end, though, I was able to overcome the difficulties that I had, and really enjoyed the latter half of the class, which ended with the creation of a simple rendering project, showing example of different rendering techniques using shaders, lights and textures. Mine was called Hypercube, and it consisted in a few rooms, each containing a different polygon rendered using a specific technique.

Our teacher was Richard Wright, which is really cool, since he’s not only the author of one of the most important books for OpenGL, the OpenGL SuperBible, but he’s also been working with OpenGL for 20+ years and he constantly updates the contents of the class so that they implement the latest versions of OpenGL, graphics library that is rapidly changing and evolving.

Overall, I really liked this class, and I really liked the way Richard taught it. He really made it more interesting and fun for everyone.

Not really sure what to expect from it, but I’m sure that it’s going to be a lot of fun, and I’m also going to know a lot of new people, which is fantastic. Last week there’s been a meeting at school, sort of a preparation for the conference, and everybody that was going to Austin was there.

Rob Coble went over a few ways of approaching people, which really boiled down to don’t be a douche, be normal and friendly, and you’re good to go. Kind of expected that from people already, but you’d be surprised by the average guy in our school, or in general in game development studies. Some people can be really awkward.

So yeah, I can’t wait!