jump to navigation

Pursuit of innovation February 1, 2011

Posted by Cesar in thinking me, working me.
Tags: , , , ,
2 comments

As usual Mathew Sakey had an interesting column last month . He writes about innovation in games and analyzes the concept of innovation itself, making a split between the conservative innovation we tend to see in most AAA games and the wild innovation we so rarely have a chance to appreciate.

The idea made me look at the industry as a whole and try to place the development team in that system. Although passion-driven, the games industry is still an industry, and as such it has a very strong financial component we cannot ignore.

It is true that developers now have way more efficient means to reach the market without a publisher, a development studio or even a team. Indie developers can publish games on Steam, Apple Store, XBox Live Arcade and others, all very valid options to share game experiences with the world.

But in the end, the vast majority of the content players will enjoy comes from professional developers plugged into the games industry production chain, which includes development studios, first party publishers, third-party publishers… you know the drill.

So when we look at innovation in indie games, it is fair to expect anything. There are no strong strings tying indie developers to market fluctuation, advertising, sales, development time. On the other hand, when a development studio works on a project for a publisher, all these factors come into play and true innovation becomes a greater challenge for the team.

And this is what I want to talk about. The fact that the standard game production chain involves so many factors other than gameplay and immersion does not mean innovation is not an option. Instead, it means the development team needs to evolve and adapt in order to be truly creative. While we can’t deny the industry wants profit, it is also true that profit can come from innovation. It is up to everyone involved to come up with a new idea and sell it convincingly.

If it wasn’t for this creative effort, we wouldn’t see some amazing games like ICO, Shadow of the Colossus, Indigo Prophecy, the Katamari series, Heavy Rain and many others. I know, I know, these represent an extremely small fraction of all games produced since, say, ICO was released. And the industry could use a bit more. But these games and studios prove my point: it is possible.

It is certainly a factor that the industry itself many times presses developers against innovation, but we cannot ignore the fact that there’s still some wiggle room for those willing to adventure in less known territory. If you have a good idea, try it. Sell it right. If it doesn’t sell, maybe you need to explore innovation in another direction that suits the company better. No developer should simply drop an idea and blame the world. Look at the picture above: we can’t control what happens inside the pipeline. But someone has to drop the ideas at one end to see what will come out on the other side.

See you space cowboys…

Advertisements

The PS3 hack and the freedom umbrella January 13, 2011

Posted by Cesar in gaming me, working me.
Tags: , , , , , , ,
2 comments

Another year, another post. I went back to Brazil for the holidays (it was great!) and came back decided to keep up with the PostAWeek challenge. Let’s see what happens, this is my first entry.

What got me the most interested during my vacation was the PS3 hack drama. As a computer engineer, I find the whole subject very interesting. It is amazing what these guys went through to hack a piece of hardware like the PS3. Even though the security system had a significant and easy to avoid flaw (this is a good start on the subject), finding it required serious skill from the notorious George Hotz, aka geohot, and the chaps from fail0verflow.

As a guy who likes math, programming and puzzles to an extreme, I can easily see the appeal of searching (or should I say researching?) for such hack. It is a huge project which demands a very deep knowledge of the field: digital security systems, cryptography and other theory heavy subjects. And on top of it all, success is highly dependent on creativity, insight and tenacity.

Unfortunately for Sony, that’s not all. The uncovered security breach is embedded so deep into the system hardware that apparently there’s no way to prevent it through firmware updates. Now that the security key is known, no matter what Sony does the hack can be redone. Sony denies the allegation, but while Sony shouts without arguments, fail0verflow’s explanation seems solid.

Anyway, from a programming point of view, I think this guys are fantastic and deserve applause. However, I can’t help thinking of the big picture and, all things considered, I’m not so sure I like geohot and the others all that much.

Both geohot and fail0verflow are firmly against piracy. They say their only goal is to be able to dual-boot Linux + GameOS and be able to develop for the platform. Hotz claims the efforts to hack the PS3 were only intensified in face of Sony’s decision to remove support for OtherOS from the console. I confess I never even considered playing with the PS3 hardware, by the time I got it support for OtherOS wasn’t there anymore. But it was definitely a nice feature that any interested programmer would love to use.

On the other hand, the implications of the hack for the industry are considerable. Sony will now have to deal with the issue actively since there seems to be no way to truly avoid the exploit. I could be wrong, but we are probably looking at more frequent updates and the eventual ban of consoles from online space. But that’s the smaller of the problems. Piracy rate will probably increase considerably, making the PS3 a less desirable platform for publishers and, as a consequence, for developers. It shifts the stability of the ecosystem, every investment in the PS3 a little less safe.

It is very hard to tackle the problem from a legal standpoint, if anyone can explain what rights a PS3 owner has, please do! What I can say is that while it seems fair to demand and pursue the ability to develop for Sony’s console, it doesn’t seem right to cause so much trouble to manufacturer, publishers, studios and ultimately consumers that invested in the PS3. Not everything is meant to be public, some things are better off encrypted. Throwing everything under the umbrella of freedom and claim the right to information is just as dangerous as it is easy. As sad as it is, the good intentions of an individual cannot be translated to humanity as a whole; we cannot forget that homo homini lupus, there’s always someone looking for profit at the expense of everyone else.

Ultimately, geohot’s intentions don’t matter. In face of his discovery, some very few will indeed dual-boot Linux + GameOS quietly from their homes and just enjoy free access to the Cell processor. The vast majority, however, will use it to play all sorts of illegal software on the console, considerably stimulating the pirate software industry. Let’s not pretend otherwise.

See you space cowboys…

Back to the roots: computer vision ftw July 9, 2010

Posted by Cesar in working me.
Tags: , , ,
1 comment so far

crazy image montage that makes me think of computer vision

Here at Other Ocean, I recently shifted from an iPad/iPhone4 game to another project. While it was great to work with shaders, glsl and what not on the previous project, the interesting thing about this new one is that it will give me an opportunity to work with computer vision again, after a long time.

And I confess I missed it. A lot.

Without getting into details, I’ve been researching image processing and analysis like crazy again and the whole experience has been a lot of fun. Looking for algorithms, going through the IEEE Xplore digital library, searching the ACM Portal, it all brings me back memories from my time at Unicamp, working on my MSc.

The system I’m developing uses what I already know of computer vision, but also incorporates a bunch of new stuff, so there’s a lot of learning involved. I know it means I’m a super geek but right now I have a big pile of printed papers on my desk and I love it.

I’ll write more about it when the project is released.

See you space cowboys…

New game: Toy Story 3! June 9, 2010

Posted by Cesar in working me.
Tags: , , , ,
2 comments

Toy Story 3

I’m proud to say that my latest project here at Other Ocean, Toy Story 3 for the Leapster Explorer,was recently announced!

The Leapster Explorer is a gaming platform from Leap Frog and has a heavy focus on kids and educational content. But don’t be fooled by the colorful look of the device. The Leapster Explorer has a very solid performance and the touch screen only adds to the fun. It was announced yesterday (I guess most kids don’t care about the iPhone 4) and is being very well received.

Toy Story 3 was a joy to develop. It follows a style similar to Mario Party, with board games and plenty of mini-games. Working with the game logic was fun and the development cycle had several interesting challenges. But the best part was dealing with the Toy Story 3 characters. Our team did so well with the animations! I had a lot of fun just watching things happen on the screen.

Congratulations to everyone involved, that was a job very well done.

See you space cowboys…

AI navigation in Left 4 Dead: Part II June 8, 2010

Posted by Cesar in working me.
Tags: , , , , , , , , ,
add a comment

After a long period of inactivity, it’s about time we continue our analysis on Michael Booth’s presentation about the AI in Left 4 Dead.

If you remember the last post on the subject, I tried to give a bit more depth to the reactive path following algorithm described in the slides. With that side implemented, we got a nice and fast path finding / following algorithm that offers a pretty optimized trajectory without looking artificial. But that’s just half the problem. The macro management half. Now we need to look at micro management and define how the bot moves when following the path.

The first step is simple obstacle avoidance. Our path finding algorithm deals with the static objects, the level itself. But it already introduces, with reactive path following, the concept of steering, which is very important and is used also in this stage. So now our bot must steer towards the next point in the path but also go around moving things that might be in the way: crates, other bots, whatever.

The most simple steering algorithm we can use is to select a direction and try to go around the object. Say the bot bumps into a box. The algorithm must try to pick a direction that leads to the closest way around it, left or right, and steer that way until the path towards the next goal becomes clear again. A simple way to attempt to select the closest way around the obstacle is to use the object center (for simplicity we’ll assume the center is the actual position of the object). All we do is apply a steering force in the opposite direction.

In the presentation, Booth mentions hull trace a lot and I’ll use it for obstacle avoidance too, so it is definitely worth describing. It is not clear if the algorithm uses a collision mesh or a simple box but, for simplicity, let’s consider that it uses an OOBB (Object Oriented Bounding Box). Let’s assume the OOBB fits the bot inside it and it has the same position and orientation as the bot. Hull trace is then an algorithm that projects that OOBB in a given direction and returns the first point of collision. Like a ray tracing algorithm, but with a box instead of a line. If we were using the bot’s collision mesh, we would do the same with the whole mesh instead of the OOBB.

The Hull trace algorithm can be a little complex because in order to make sure we get all collisions we need a sweep test (or a way to fake it, but I digress). It is performance intensive if we use a complex shape. However, with the OOBB the cost is minimal.

With that out of the way, here’s some C++ high level code for the obstacle avoidance algorithm:

// computes obstacle avoidance movement components
void Bot::ObstacleAvoidanceUpdate(f32 m_fDeltaTime)
{
	Entity* pEntity; // what it hit
	f32 fDistance; // how far it is
	Physics::HullTrace(m_vPosition, m_pHull, m_vSpeed, m_pWorld,
		pEntity, fDistance);

	// We only avoid close dynamic objects. If it is static and the path goes
	// there, it means the bot will climb
	if ((pEntity == NULL)
		|| pEntity->IsStatic()
		|| (fDistance > m_fMaxSteerDistance))
	{
		return;
	}

	Vector3 vObstaclePos = pEntity->GetPosition();
	Vector3 vSteeringDirection = (m_vPosition - vObstaclePos).Normalize();

	RequestMovement(
		ComputeAvoidanceTranslation(vSteeringDirection, fDistance),
		ComputeAvoidanceSteering(vSteeringDirection, fDistance),
		OBSTACLE_AVOIDANCE);
}

OK, with this our bots can now go around dynamic objects and other bots. Note that, as in the previous post, I made a call to RequestMovement(). Now that we have 2 systems making requests, the function shows its purpose: to select what to follow. I also chose, again, not to show exactly how to compute the parameters for RequestMovement(). These algorithms are somewhat empirical and usually involve tweaking constant values to get a good looking behavior.

Anyway, now there’s only one step left: climbing. In L4D, it is really cool how the bots climb walls and jump over ledges to reach the players. To do that, our navigation mesh, mentioned in the previous post, must also consider  reachable moving areas on higher ground. If we have that, all that is left is to figure out how to reach the higher points of the map.

This is what Booth talks about in the remaining slides related to navigation. Essentially, every time a bot gets close to a not so high level obstacle in the way to the next point in the navigation mesh, be that the level itself or a movable object, it is going to attempt to jump and climb.

Let’s get to the algorithm per se. Take a look at the image above, the figures are very helpful. Once we detect there’s an obstacle ahead that justifies climbing, the very first step is to check if there’s space above the bot’s head. If there isn’t, he can’t climb. To do that, we perform the infamous hull trace upwards. Once we know there is space above, we need to know if there’s some sort of space in front. So, starting from the bottom, we do a hull trace in the forward movement direction, but changing the y coordinate, so we look for a passage in several different heights. Once a path is found, all that is left is to precise the ledge of the passage way. That is done by performing the hull trace multiple times downwards, until we get what I will call a grabbing point.

At this stage, all the bot really has to do is move. By the height of the grabbing point we can define which animation set to use in order to climb the object.

This concludes this stage of the AI. Below is a high level algorithm with my interpretation of the algorithm that finds the climbing edge. Get ready, it is big:

bool ComputeClimbingEdge(Vector3& p_vEdge)
{
	Vector3 vSpeedDirection = m_vSpeed.Normalize();

	Entity* pEntity;
	f32 fGroundDistance;
	Physics::HullTrace(m_vPosition, m_pHull, vSpeedDirection,
		m_pWorld, pEntity, fGroundDistance);

	// We only climb static objects that are in proper range.
	// If the bot is steering to avoid the obstacle, we also
	// return
	if ((pEntity == NULL)
		|| !pEntity->IsStatic()
		|| (fGroundDistance > m_fTestClimbingDistance)
		|| (m_fSteering > m_fTestClimbingSteering)
	{
		return false;
	}

	//Climbing will start, now we need to find the edge

	// First the maximum height
	f32 fCeilingDistance;
	Entity* pCollidable;
	Physics::HullTrace(m_vPosition, m_pHull, m_pWorld->GetUpVector(),
		m_pWorld, pCollidable, fCeilingDistance);
	if (pCollidable == NULL)
	{
		fCeilingDistance = m_fMaximumClimbingHeight;
	}

	// now we look for the horizontal gap in the wall, starting from the bottom
	Vector3 vForwardTracePosition;
	for (f32 fTestHeight = 0;
		fTestHeight < fCeilingDistance;
		fTestHeight += m_fHullStep)
	{
		f32 fForwardDistance;
		vForwardTracePosition = m_vPosition
			+ (m_pWorld->GetUpVector() * fTestHeight);
		Physics::HullTrace(vForwardTracePosition, m_pHull, m_vSpeed,
			m_pWorld, pCollidable, fForwardDistance);

		// the diameter of the hull is just a guess of a decent value
		if (fForwardDistance
			>= fGroundDistance + m_pHull->GetHorizontalDiameter())
		{
			break;
		}
	}

	// move forward a bit so we trace from the top of the new level
	Vector3 vDownTracePosition = vForwardTracePosition
		+ vSpeedDirection
			* (fGroundDistance + m_pHull->GetHorizontalDiameter());
	// trace down to get the precise height;
	f32 fLevelDistance;
	Physics::HullTrace(vDownTracePosition, m_pHull, -m_pWorld->GetUpVector(),
		m_pWorld, pCollidable, fLevelDistance);

	// now we trace back
	// creating first final edge position candidate:
	p_vEdge = vDownTracePosition - m_pWorld->GetUpVector() * fLevelDistance;
	for (f32 fBackDistance = 0;
		fBackDistance <= fGroundDistance + m_pHull->GetHorizontalDiameter();
		fBackDistance += m_fHullPrecisionStep)
	{
		Vector3 vTestEdgePosition = vDownTracePosition
			- (vSpeedDirection * fBackDistance);
		f32 fDownDistance;
		Physics::HullTrace(vTestEdgePosition, m_pHull, -m_pWorld->GetUpVector(),
			m_pWorld, pCollidable, fDownDistance);

		if (fDownDistance > (fLevelDistance + m_fSafetyLevelDelta))
		{
			break;
		}
		else
		{
			p_vEdge = vTestEdgePosition
				- (m_pWorld->GetUpVector() * fDownDistance);
		}
	}

	// we got a valid result in p_vEdge
	return true;
}

I should mention that some assumptions are made about the environment: we assume the passage is not too narrow and that it is at a regular height. I also assumed after the first check the HullTrace() method always hits a valid entity.

The Bot::ComputeClimbingEdge() function is called in the Bot::Update() function, together with the other ones previously defined. After everything is done, the system processes the several movement requests and actually moves the bot.

I think that closes the subject at least for now. I hope what I left unexplained is not to hard to figure out. But I’m tempted to post more on the subject so who knows? Maybe we’ll have another one in the series.

Ah, if you decide to implement it, don’t forget that everything that goes up must go down. The bot has to check for edges on the ground too in order to climb or jump back to the ground!

See you space cowboys…

[/sourcecode]

AI navigation in Left 4 Dead: Part I February 25, 2010

Posted by Cesar in gaming me, working me.
Tags: , , , , , ,
1 comment so far

The other day my good friend (and great game designer) Bruno Palermo pointed me to this presentation that Mike Booth used last year at the Artificial Intelligence and Interactive Digital Entertainment Conference. I found it extremely interesting and useful. I didn’t know Valve made publication material available through their website!

I didn’t have the pleasure to watch it, but by the slides you can tell his presentation goes through a lot of cool stuff. So what I want to do is focus only in the AI for pathing and movement and try to get closer to an actual implementation of the system. See it as my version of the presentation. Is that possible? I think it is, let’s try (I didn’t think this through when writing, but if you are reading it is because it worked. Don’t worry and continue reading).

The most important thing is to remember that the goal is not the best possible behavior but instead the most realistic one. And an exact, perfect path or movement is not very realistic. So let’s begin.

To move the bots (let’s call them bots, right?), the system works in two phases: path finding and movement. One could think after path finding, moving is easy. Well, it isn’t. The L4D system computes the paths in a navigation mesh and the bots extract a rough direction from the path finding system, not an exact guide on how to get from point A to point B. That means it is up to the movement phase to figure out how to reach the next point in the path (jumping, climbing, crouching, whatever).

So the very first step towards the navigation AI is to generate or edit a navigation mesh for the map. I won’t get into specifics (googling navigation mesh should be a good start), but essentially the algorithm tracks “walkable” areas from the map and then grows rectangles in a way that best fits the areas. The result should be a graph-like structure with a bunch of bounding boxes representing areas where the bots can walk. If a bot can move between boxes, we add a bidirectional connection connecting them.

With the mesh properly generated (never at run-time, eh?), the path finding algorithm goes through the graph with a simple A* algorithm. After running A* in our walkable rectangles graph, we have an ordered list of rectangles in the path. At this point it is obvious things are already imprecise, which means the movement phase has to find the best way to go from one rectangle to the other.

The optimal approach, rejected by Booth because it looks robotic, is to look for the rectangle further away with a clear, direct path to it. Because the pathing system is not the only one acting on the bot at run-time (there’s also flocking, small obstacle avoidance, etc), this alternative also requires a lot of repathing: every time something obstructs the path to the target node, the system would have to compute a new path.

Instead, the navigation system uses what Booth calls Reactive Path Following. The decision is very local and sets as a target the unobstructed node further down the path in the direction the bot is facing. Booth mentions this makes the path fluid which wouldn’t be true unless some steering behavior were in place, so here’s my very high level interpretation of that algorithm:

// Rough example of the path update function.
void Bot::PathUpdate(f32 m_fDeltaTime)
{
	// unless the bot got too far from the path, we don't have to compute it
	// again. In this case, the realism of the algorithm helps performance!
	// Of course we also have to find a path if we don't have one yet.
	if (!HasPath() || (DistanceFromPath() > m_fMaxPathDistance))
	{
		m_lPathNodes = AStar::FindPath(
			m_pWorld->GetNavigationMesh(),
			m_vPosition,
			m_vTarget);
		m_iCurrentNode = 0;
	}

	// looking for the best node to track. Notice that the next node is local,
	// the decision is made every frame.
	Node* pNextNode = m_lPathNodes[m_iCurrentNode];
	for (s32 i = m_iCurrentNode; i < m_lPathNodes.GetSize(); ++i)
	{
		if (IsFacing(m_lPathNodes[i]) && IsClearPath(m_lPathNodes[i]))
		{
			pNextNode = m_lPathNodes[i];
		}
	}

	// assuming some complex heuristic might take place to decide which
	// priority each system gets, we don't update the member variables
	// directly. Instead, make requests informing the current system
	RequestMovement(
		ComputePathTranslation(m_fDeltaTime),
		ComputePathSteering(pNextNode, m_fDeltaTime),
		PATH_FOLLOWING);
}

Ok, that’s it for path finding and basic path following but there’s a lot more to cover. However, I haven’t posted for a really long time and it would take me another week to finish the whole subject. So let’s stop at this point and in the next post I’ll continue to object avoidance and ledge climbing.

See you space cowboys…

Every day the same dream January 23, 2010

Posted by Cesar in living me, thinking me, working me.
5 comments

Every day the same dream is an amazing game. If you’ve heard about it before, continue reading. Otherwise, I recommend you play first; it is very short, you’ll finish in minutes.

I found out about this deep and disturbing game at Tap-Repeatedly and was very… surprised at how the experience moved me. Every day is in all technical aspects extremely simple. That is a compliment and goes to show how games are unquestionably an art form. Even stripped from all graphical advances, realistic AI and complex controls, playing it is a touching and immersive experience (here I go talking about immersion again). I had had such feelings before watching short movies, never playing games.

Playing Every day made me think of two movies: Modern Times, by Charlie Chaplin, and Groundhog Day. There’s a tad of both in this game.

Modern times has a direct relation to Every day: Chaplin’s movie is also a critic to the massification of modern life.

In Groundhog Day, Phil Connors, played by Bill Murray, lives the same day over and over again, oblivious as to why that’s happening to him. The repetition acts as a metaphor to the stagnation caused by the main character’s life style. In a scene in the bowling alley, Phil asks two locals, “What would you do if you were stuck in one place, and every day was exactly the same and nothing that you did mattered?” One guy replies, “That about sums it up for me.” That right there explains the connection. The magic power that makes Phil live the same day every day only brings to the surface the drama both the locals in the movie and the character in Every Day the Same Dream experience by simply living their lives.

In both movie and game, the break from the repetition that plagues existence comes from self-improvement. They represent a search for enlightenment and offer a valuable lesson.

If you still haven’t played the game, do it now. And go rent Groundhog Day. You won’t regret it.

See you space cowboys…

Cogs in the Brazilian games industry machine January 22, 2010

Posted by Cesar in working me.
Tags: , , , , , , , , ,
add a comment

brazilian flag + marcus fenix

Gamasutra recently published a great article from Divide By Zero CEO James Portnow. In the article, Portnow makes a very interesting analysis of Brazil as an ecosystem for the games industry, investigating aspects from law and taxation to technical quality and piracy.

If you are just looking for the conclusion, here it is:

Now is the time to get into Brazil. The margin is right. If I were a betting man, I’d say the odds are about three to one that the Brazilian industry never gets off the ground. But at the same time, I’d say the return on resources invested in Brazil at this point will be at least ten to one if the industry does get past its infancy. I also believe that foreign entities have an opportunity to better those odds of the Brazilian industry becoming successful.

I find the probabilities he estimates very interesting. It’s like analyzing pot odds in poker: in a nutshell, it means he does not think his pair of 8s will win, but if it does he’ll get much more than he put on the table.

While I do agree with most of what is in the article, I believe some remarks are in order.

First let’s talk about piracy. It truly is, like Portnow says, an elephant in the room. In Brazil, every time there’s a debate about the games industry, the subject comes up. It is almost boring. I think Brazil will not bring the numbers down any time soon to be honest. And to expect the government to drop taxes on external games to something that would cause an impact is a distant dream. That being said, I noticed a significant improvement with the new generation of consoles. No one bought original PS2 titles. On the 360, however, I believe the piracy percentage is better. Unfortunately, like someone mentioned in a comment on the aforementioned article, most of these purchases are made from stores that get their products illegally across the border. Nonetheless, while it is still a crime, it puts some of the money back into the games industry (probably in Miami somewhere) and I think that represents an improvement. Microsoft also officially distributes 360 games in Brazil. I don’t have the figures, but I would love to know how that’s going.

Anyway, even a small drop could make the market very interesting, as the base of gaming platforms is very significant. Mexico also had a high piracy rate, above 90%. When NAFTA came and games became cheaper, it dropped to around 80% if I am not mistaken (if someone has the exact numbers please let me know. I couldn’t find them). And while that’s still a huge percentage, those 10-15% meant a huge increase in sales, enough to get the Mexican games industry going.

I found it very curious, however, that Portnow didn’t talk to Abragames. It doesn’t matter if you agree with the association actions or not, it is an important organization that could have added even more depth to what already is a great article. I also had the pleasure of working at TecToy Digital and went back to visit one and a half years later. Boy did they grow. They are behind the Zeebo platform and are a sound example that game development can go very well in Brazil.

The other interesting point I would like to have seen in the article was the 2008-2009 financial crisis. It had a major impact in the Brazilian games industry and the waves are still propagating now in 2010. I fell victim to that, when in 2008 Gameloft shut down their development studio in São Paulo as a measure to cut costs during the crisis. And I know other game studios struggled with the lack of new projects. For that reason, I would say the industry in 2010 is still crawling back to where it was in 2008. So when you look at the industry now, you have to dig deep to get past the crisis ripples and see the actual potential for game development in the land of Samba and Bossa Nova.

Finally, my experience as a game developer in Brazil, specially when helping with recruitment, is that Brazil has a long way to go in a whole cultural aspect associated to game development. Until recently (I’m talking 2004-2005) the industry was so small it wasn’t considered a career option. That means students fresh out of the top universities in Brazil were getting to the market lacking the drive or the background to jump right into game development. But that’s slowly changing. With that cultural change alone, with the undergraduates knowing the number of opportunities in game development is not so small, we should have a pretty qualified work force. The quality of the computer science/engineering courses in Brazil is well known and a reason to be proud.

So all in all, I have more faith in the Brazilian game developers than James Portnow. I think the cards on the table are low and that pair of 8s has a good chance of winning the pot.

See you space cowboys…

About stonecutters and game developers January 16, 2010

Posted by Cesar in working me.
Tags: , , ,
add a comment

When my parents came to visit us here in St. John’s, my father told me a very interesting parable Peter Drucker used in many of his seminars about management:

A traveler, walking down a road, came upon three stonecutters working in a quarry. Curious as to what those three men were working on, the traveler approached the first one and asked what he was doing. The stonecutter turned to him, sighed but smiled a little and then explained, “I am cutting stones trying to make enough money to support my family.” Feeling very little enlightened, the traveler walked to the second worker and asked the same question. The worker turned angrily, as if the answer was obvious, and replied full of pride: “I am a very skillful stonecutter and I am cutting the most beautiful, uniform and smooth stones in the whole country.” Still no wiser, the traveler made his way to the third worker and once again asked what he was doing. The worker turned to him with a smile and answered: “I am building a cathedral.”

The first one, just trying to earn a living, is the classic uninterested worker who does his hours but no more and performs his tasks at an ok quality never looking for improvement. You can count on his work, but when push comes to shove, that’s not someone you want to rely on to get the job done. The most dangerous kind is the second. These care a lot about quality but their priorities are all wrong, as he is only worried about his own work. Of course the ideal is the third worker. He thinks of the big picture, he understands his work is just a necessity to get the cathedral built. His work is not the final goal, the cathedral is.

I brought this up because we see the three kinds of stonecutters every day. But the second one is much more common in creative environments, where every task can be over thought, become more complicated than it should be. The games industry is one of these creative environments: it is easy to get carried away by the current algorithm or art asset you are working on and forget that’s just a small piece of the game. I think we all have days we work like each of the three stonecutters. Some days we just can’t focus, others we are consumed by our own stones and forget we are building cathedrals. It is not easy to see which one better defines us in everyday life. Nonetheless, it is still important to always try and be like the third worker. It is good for productivity and leads to personal improvement and to a far more pleasant work experience.

So… the Stonecutters in the video have very little to do with the parable (although it is a fantastic Simpsons episode and song! Check it out), but can you guess what kind of stonecutter Homer Simpson is? Not too hard, eh? Which stonecutter are you?

See you space cowboys…

Review for The Hidden Cases January 8, 2010

Posted by Cesar in working me.
Tags: , , , , , ,
add a comment

A quick update: IGN just recently released a review for CSI: The Hidden Cases, my first DS title! I am very happy with the 7.5 they gave it. It does not seem like such a high score at first, but if you look IGN criteria and other CSI game reviews, you’ll see it is a respectable accomplishment!

They even mention the new visual style and the gameplay engine as big improvements on previous games. Well done, team!!!

Anyway, I am very proud and just wanted to share.

%d bloggers like this: