Mail has been fixed; you should now be able to confirm your e-mail address, watch pages, and the like.
Please report any issues on Discord.

The Simpsons Game (PlayStation 3, Xbox 360)

From The Cutting Room Floor
Jump to navigation Jump to search

Title Screen

The Simpsons Game

Also known as:
(ES) Los Simpson: El Videoguego
(FI) The Simpsons Videopeli
(FR) Les Simpson, le jeu
(IT) I Simpson: Il Videogioco
Developer: EA Redwood Shores
Publisher: Electronic Arts
Platforms: PlayStation 3, Xbox 360
Released in US: October 30, 2007
Released in EU: November 9, 2007
Released in AU: November 15, 2007


AreasIcon.png This game has unused areas.
SourceIcon.png This game has uncompiled source code.
CopyrightIcon.png This game has hidden developer credits.
DevTextIcon.png This game has hidden development-related text.
GraphicsIcon.png This game has unused graphics.
TextIcon.png This game has unused text.
DebugIcon.png This game has debugging material.
LevelSelectIcon.png This game has a hidden level select.
Carts.png This game has revisional differences.


PrereleaseIcon.png This game has a prerelease article

This cactus is UNDER CONSTRUCTION
This article is a work in progress.
...Well, all the articles here are, in a way. But this one moreso, and the article may contain incomplete information and editor's notes.

The Simpsons Game is what you get when you make a Simpsons game with every game genre.

Early Level Names

At some point in development, the episode names were changed to what they are now. The old names still remain in the code and file/folder names.

Early Name Final Name
The Treehugger Lisa The Tree Hugger
Cheater Cheater Enter the Cheatrix
Day of the Dolphins Day of the Dolphin
The Day Springfield Stood Still Invasion of the Yokel-Snatchers
Gamehub Game Engine
Rhymes with Complaining Five Characters in Search of an Author
Meet Thy Player Game Over
SPR_HUB Springfield

Debug Replay

Hmmm...
To do:
  • See if there's a way to add or bring back the Debug Replay button like in OldGen.
  • These codes are raw memory offsets as I currently have no knowledge on any potential PS3/X360 cheat device and how it may work! --Edness
Debug Replay menu on PlayStation 3
Debug Replay menu on Xbox 360

There is a hidden menu internally called DebugReplay. It can be accessed in both the Old Generation release as well as here.

All Regions
PS3 00AF65B0 100012E8
00AF65BC 100012B8
360 8239F71C 388B22A4
8239F76C 388B22D4
(Source: Edness)

One slight difference, however, is that currently there is no way to add the Debug Replay button on the main menu in this release. Instead, these codes will replace the regular Episodes & Challenges menu with Debug Replay.

Note: The 2nd code line may not be necessary as it can load the Debug Replay menu with only the 1st code active! It's mainly there just as a safeguard from any potential issues of Menu IDs colliding.

Unused Graphics

Downloadable Content

This game was planned to have DLC expansions. There is a button in the menu that would be used for DLC, but it never ended up being used. Frontend.str contains textures that were meant to be used for said DLC.


To get a better idea of where exactly these expansions were meant to take place in Springfield, this mockup image with all the textures combined to form a single image will help you out.

SimpsonsGamePS3-FIN episode download-combined.png


Movie Placeholders

The colloquially called Old Generation version has a few more movies available in the menu, those being In-Game Cutscenes that are pre-rendered there, but are played in real-time in the New Generation as they happen. Frontend.str still has placeholder textures for those unavailable movies.

And then there is one more blank movie placeholder icon with no text in it.

SimpsonsGamePS3-FIN Frontend-assets rws-135 fmv browser.png

Xbox Leftover

Since this game was initially prototyped on the Xbox, the final Xbox 360 release happens to have a leftover from this stage - the Xbox controller texture.

SimpsonsGame360-Frontend-assets rws-03 controller.png

Unused Textures

Hmmm...
To do:
Confirm these are actually unused, and find more!

Shared

Bartman Begins

Mob Rules

Game Over

Frontend

(Not including already shown textures!)

Unused Level Areas

Hmmm...
To do:
Get populated/textured renders. Right now these photos are just the plain level meshes with no props, enemies or lighting.

Springfield Hub

SimpsonsGameNG-Retirement1.png
SimpsonsGameNG-Retirement2.png
Retirement Home Interior

Underneath the retirement home, there is an unused interior. This seems to be very basic, with little furniture.

SimpsonsGameNG-House1.png
SimpsonsGameNG-House2.png
Unused house

Located underneath the Sleep Eazy Motel there is an interior for an unused house. The house contains detailed models for furniture. Strangely, there is more furniture located underneath the floor and outside the walls.

Enter the Cheatrix

SimpsonsGameNG-Zone3.png
Zone 3

Labeled as Zone 3 of Enter the Cheatrix. Only uses the simpsons_palette texture, and generally looks very unfinished. There is no ceiling mesh, so either there would have been a fixed camera angle or the mesh was never finished. From the fact that it uses no textures, we can assume that it was cut very early into Cheatrix's life, or was never intended for the final game at all.

SimpsonsGameNG-Zone4.png
Zone 4

Labeled as Zone 4 of Enter the Cheatrix. Only uses the simpsons_palette texture, bar from 3 pipes. At the top section, next to the green pipe, the wall covers a small corridor leading out, so this was presumably the exit to this zone. There is a movable bridge in the middle, leading to sign saying "POWER BOOST" and "OFF".

Five Characters in Search of an Author

SimpsonsGamePS3-FIN RWC-Zone2.png
Zone 2

Labelled as Zone 2 of Five Characters. This would have come right after the outside lawyer fight.

SimpsonsGamePS3-FIN RWC-Zone3.png
Zone 3

Labelled as Zone 3 of Five Characters. This would have come right after Zone 2. The design of this zone is very reminiscent of Old-Gen Five Characters. The player starts in the bottom left, somehow crosses a gap, makes their way across a bowling lane at the back (maybe there would have been bowling balls to dodge?), then back towards the camera. Then, there is a platforming section across floating notepads. The Homer and Bart statues are seemingly textureless, so either they were meant to look like that or the materials were cut.

Developer Credits/Text

In simpsons_gameflow.lua, simpsons_gameflow_helpers.lua and simpsons_scores.lua there are copyright, author and usage messages.

simpsons_gameflow.lua

--///////////////////////////////////////////////////////////////////////////////
--/// \file simpsons_gameflow_helpers.h
--/// \brief Simpsons Gameflow
--///
--///	Builds the Gameflow Structure for the Simpsons
--///
--/// \par Copyright:
--///   (c) 2006 - Electronic Arts Inc.
--/// \author 
--///   Kaye Mason
--/// \date 
--///   12/12/06
--///////////////////////////////////////////////////////////////////////////////

--Syntax notes:
--Create a Game First.
--Create Episodes.
--Create Movies for episodes.
--Create Maps for episodes.
--Create Game modes for Episodes.
--Attach Maps to Modes.
--Attach Movies to Modes.

--NB: Requires simpsons_gamelfow_helpers.lua to be loaded first.

simpsons_gameflow_helpers.lua

--///////////////////////////////////////////////////////////////////////////////
--/// \file simpsons_gameflow_helpers.h
--/// \brief Simpsons Gameflow Helpers
--///
--///	Contains Wrapper functions to assist in building the gameflow model
--///
--/// \par Copyright:
--///   (c) 2006 - Electronic Arts Inc.
--/// \author 
--///   Kaye Mason
--/// \date 
--///   12/12/06
--///////////////////////////////////////////////////////////////////////////////

simpsons_scores.lua

--About the ScoreKeeper: The Score Keeper system is a flexible and data driven way to store scores.
--It supports basic scores, which store values, as well as Score Events (collections of operations that
--may be issued as one) and Score Watchers (which trigger actions based on the values of scores).
--The syntax of this document is described in the function SetupTestScores.

--When using this document, please add your scores to the appropriate epsiode function. If you are unsure
--where to attach scores, please see Tom Wilson (tmwilson@ea.com) or Brad McKee (bmckee@ea.com). This will
--help keep the document readable and maintainable as the number of scores grows.

Lower down in "simpsons_scores.lua", there is a warning from a developer to the other developers :

-- DO NOT CHANGE BELOW HERE! (unless you know what you're doing and are willing to bear the consequences :-) )

Uncompiled Source

vsh_ff_all.hlsl

The Xbox 360 versions .XEX has an uncompiled source file, likely coming from an SDK.

/////////////////////////////////////////////////////////////////////
///	
/// vsh_ff_all.hlsl
///
/// Implements fixed function vertex processing for the Xenon
///	
/////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////
///	
/// D3D9 types for effect files
///	
/////////////////////////////////////////////////////////////////////

typedef float4 D3DCOLORVALUE;
typedef float3 D3DVECTOR;

typedef struct _D3DMATERIAL9
{
    D3DCOLORVALUE   Diffuse;
	D3DCOLORVALUE   Ambient;
	D3DCOLORVALUE   Specular;
	D3DCOLORVALUE   Emissive;
    float           Power;
} D3DMATERIAL9;

typedef int D3DLIGHTTYPE;
#define D3DLIGHT_POINT          1
#define D3DLIGHT_SPOT           2
#define D3DLIGHT_DIRECTIONAL    3

typedef struct _D3DLIGHT9
{
	D3DLIGHTTYPE    Type;
    D3DCOLORVALUE   Diffuse;
    D3DCOLORVALUE   Specular;
    D3DCOLORVALUE   Ambient;
    D3DVECTOR       Position;
    D3DVECTOR       Direction;
    float           Range;
    float           Falloff;
    float           Attenuation0;
    float           Attenuation1;
    float           Attenuation2;
    float           Theta;
    float           Phi;
} D3DLIGHT9;

typedef int D3DFOGMODE;
#define D3DFOG_NONE          0
#define D3DFOG_EXP           1
#define D3DFOG_EXP2          2
#define D3DFOG_LINEAR        3

typedef int D3DTRANSFORMSTATETYPE;
#define D3DTS_WORLD          0
#define D3DTS_VIEW           1
#define D3DTS_PROJECTION     2
#define D3DTS_TEXTURE0       3
#define D3DTS_TEXTURE1       4
#define D3DTS_TEXTURE2       5
#define D3DTS_TEXTURE3       6
#define D3DTS_TEXTURE4       7
#define D3DTS_TEXTURE5       8
#define D3DTS_TEXTURE6       9
#define D3DTS_TEXTURE7       10

#define D3DTSS_TCI_PASSTHRU                    0x00000000
#define D3DTSS_TCI_CAMERASPACENORMAL           0x00010000
#define D3DTSS_TCI_CAMERASPACEPOSITION         0x00020000
#define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x00030000
#define D3DTSS_TCI_SPHEREMAP                   0x00040000

typedef int D3DTEXTURETRANSFORMFLAGS;
#define D3DTTFF_DISABLE          0
#define D3DTTFF_COUNT1           1
#define D3DTTFF_COUNT2           2
#define D3DTTFF_COUNT3           3
#define D3DTTFF_COUNT4           4
#define D3DTTFF_PROJECTED        256

typedef int D3DMATERIALCOLORSOURCE;
#define D3DMCS_MATERIAL			 0
#define D3DMCS_COLOR1			 1
#define D3DMCS_COLOR2			 2

/////////////////////////////////////////////////////////////////////
///	
/// Defines
///	
/////////////////////////////////////////////////////////////////////
#ifndef K_NORMALIZENORMALS
#define K_NORMALIZENORMALS true
#endif
#ifndef K_TWEENENABLE
#define K_TWEENENABLE false
#endif
#ifndef K_TEXTURETRANSFORMFLAGS0
#define K_TEXTURETRANSFORMFLAGS0 D3DTTFF_DISABLE
#endif
#ifndef K_TEXTURETRANSFORMFLAGS1
#define K_TEXTURETRANSFORMFLAGS1 D3DTTFF_DISABLE
#endif
#ifndef K_FOGENABLE
#define K_FOGENABLE true
#endif
#ifndef K_RANGEFOGENABLE
#define K_RANGEFOGENABLE false
#endif
#ifndef K_FOGVERTEXMODE
#define K_FOGVERTEXMODE D3DFOG_LINEAR
#endif
#ifndef K_SPECULARENABLE
#define K_SPECULARENABLE false
#endif
#ifndef K_LIGHTING
#define K_LIGHTING true
#endif
#ifndef K_SCREENSPACEPOSITIONS
#define K_SCREENSPACEPOSITIONS false
#endif
#ifndef K_DIFFUSEMATERIALSOURCE
#define K_DIFFUSEMATERIALSOURCE D3DMCS_COLOR1
#endif
#ifndef K_SPECULARMATERIALSOURCE
#define K_SPECULARMATERIALSOURCE D3DMCS_COLOR2
#endif
#ifndef K_AMBIENTMATERIALSOURCE
#define K_AMBIENTMATERIALSOURCE D3DMCS_MATERIAL
#endif
#ifndef K_EMISSIVEMATERIALSOURCE
#define K_EMISSIVEMATERIALSOURCE D3DMCS_MATERIAL
#endif
#ifndef K_TEXCOORDINDEX0
#define K_TEXCOORDINDEX0 D3DTSS_TCI_PASSTHRU
#endif
#ifndef K_TEXCOORDINDEX0ENABLE
#define K_TEXCOORDINDEX0ENABLE false
#endif
#ifndef K_TEXCOORDINDEX1
#define K_TEXCOORDINDEX1 D3DTSS_TCI_PASSTHRU
#endif
#ifndef K_TEXCOORDINDEX1ENABLE
#define K_TEXCOORDINDEX1ENABLE false
#endif
#ifndef K_COLOR0ENABLE
#define K_COLOR0ENABLE false
#endif
#ifndef K_COLOR1ENABLE
#define K_COLOR1ENABLE false
#endif

/////////////////////////////////////////////////////////////////////
///	
/// Lighting state
///	
/////////////////////////////////////////////////////////////////////
D3DMATERIAL9			g_Material;
D3DLIGHT9				g_Lights[8];
bool					g_LightEnable[8];
float					g_SpotLightCosHalfTheta[8];
float					g_SpotLightCosHalfPhi[8];

/////////////////////////////////////////////////////////////////////
///
/// Renderstates
///
/////////////////////////////////////////////////////////////////////
D3DCOLORVALUE	g_Ambient;
float			g_TweenFactor;
D3DCOLORVALUE	g_FogColor;
float			g_FogStart;
float			g_FogEnd;
float			g_FogDensity;

/////////////////////////////////////////////////////////////////////
///
/// Transform state
///
/////////////////////////////////////////////////////////////////////
float4x4		g_Proj			 : PROJ;
float4x4		g_WorldViewProj  : WORLDVIEWPROJ;
float4x4		g_WorldView      : WORLDVIEW;
float4x4		g_World          : WORLD;
float4x4		g_WorldViewIT;
float4x4		g_ViewIT;
float4x4		g_TexTrans0;
float4x4		g_TexTrans1;
float			g_PosScaleX;
float			g_PosScaleY;


/////////////////////////////////////////////////////////////////////
///
/// Vertex shader output
///
/////////////////////////////////////////////////////////////////////
struct VS_OUTPUT
{
    float4 Pos           : POSITION;
	float4 Color0        : COLOR0;
	float4 Color1		: COLOR1;
	float4 Tex0         : TEXCOORD0;
	float4 Tex1			: TEXCOORD1;
	float  Fog           : FOG;
};

/////////////////////////////////////////////////////////////////////
///
/// Color pair for lighting computations
//
/////////////////////////////////////////////////////////////////////
struct COLOR_PAIR
{
	float4 Color0        : COLOR0;
	float4 Color1		: COLOR1;
};

/////////////////////////////////////////////////////////////////////
///
/// Compute the contribution from a directional light
///
/////////////////////////////////////////////////////////////////////
COLOR_PAIR																///< Returns diffuse/ambient and specular components
	DoDirLight			
	(			
		float3			viewSpaceNorm,									///< Normal in view space
		float3			viewSpaceViewVec,								///< View vector in view space
		int				i,												///< Light index
		uniform bool	k_SpecularEnable								///< Specular enabled?
	)																
{																	
   COLOR_PAIR ret;													
																	
   //
   // Ambient
   //
   ret.Color0 = g_Lights[i].Ambient;								
   ret.Color1 = 0;													
																	
   float3 L = mul((float3x3)g_ViewIT, -normalize(g_Lights[i].Direction));	
   float NdotL = dot(viewSpaceNorm, L);							
   if(NdotL > 0.f)													
   {																
      //compute diffuse color										
      ret.Color0 += NdotL * g_Lights[i].Diffuse;					
																	
      //add specular component										
      if(k_SpecularEnable)											
      {															
         float3 H = normalize(L + viewSpaceViewVec);   			
         ret.Color1 = pow(max(0, dot(H, viewSpaceNorm)), g_Material.Power) * g_Lights[i].Specular;	
      }															
   }																
   return ret;														
}																	
																	
/////////////////////////////////////////////////////////////////////
///
/// Compute the contribution from a directional light
///
/////////////////////////////////////////////////////////////////////
COLOR_PAIR																///< Returns diffuse/ambient and specular components
	DoPointLight													
	(																
		float4			vPosition,										///< Position in model space
		float3			viewSpaceNorm,									///< Normal in view space
		float3			viewSpaceViewVec,								///< View vector in view space
		int				i,												///< Light index
		uniform bool	k_SpecularEnable								///< Specular enabled?
	)																
{																	
   COLOR_PAIR ret;													
   ret.Color0 = g_Lights[i].Ambient;								
   ret.Color1 = 0;													
																	
   float3 L = mul((float3x3)g_ViewIT, normalize((g_Lights[i].Position-(float3)mul(g_World,vPosition))));	
   float NdotL = dot(viewSpaceNorm, L);							
   float fAtten = 1.f;												
   if(NdotL >= 0.f)												
   {																
      //compute diffuse color										
      ret.Color0 += NdotL * g_Lights[i].Diffuse;					
																	
      //add specular component										
      if(k_SpecularEnable)											
      {															
         float3 H = normalize(L + viewSpaceViewVec);   				//half vector
         ret.Color1 = pow(max(0, dot(H, viewSpaceNorm)), g_Material.Power) * g_Lights[i].Specular;	
      }															
																	
      float LD = length(g_Lights[i].Position-(float3)mul(g_World,vPosition));	
      if(LD > g_Lights[i].Range)									
      {															
         fAtten = 0.f;												
      }															
      else															
      {															
         fAtten *= 1.f/(g_Lights[i].Attenuation0 + g_Lights[i].Attenuation1*LD + g_Lights[i].Attenuation2*LD*LD);	
      }															
      ret.Color0 *= fAtten;										
      ret.Color1 *= fAtten;										
   }																
   return ret;														
}																	
																	
/////////////////////////////////////////////////////////////////////
///
/// Compute the contribution from a spot light
///
/////////////////////////////////////////////////////////////////////
COLOR_PAIR																///< Returns diffuse/ambient and specular components
	DoSpotLight														
	(																
		float4			vPosition,										///< Position in model space
		float3			viewSpaceNorm,									///< Normal in view space
		float3			viewSpaceViewVec,								///< View vector in view space
		int				i,												///< Light index
		uniform bool	k_SpecularEnable								///< Specular enabled?
	)																
{																	
	COLOR_PAIR ret;													
	ret.Color0 = g_Lights[i].Ambient;									
	ret.Color1 = 0;													
																	
	float3 L = mul((float3x3)g_ViewIT, normalize((g_Lights[i].Position-(float3)mul(g_World,vPosition))));	
	float NdotL = dot(viewSpaceNorm, L);							
	float fAttenSpot = 1.f;											
	if(NdotL >= 0.f)												
	{																
		//compute diffuse color										
		ret.Color0 += NdotL * g_Lights[i].Diffuse;					
																	
		//add specular component									
		if(k_SpecularEnable)										
		{															
			float3 H = normalize(L + viewSpaceViewVec);				
			ret.Color1 = pow(max(0, dot(H, viewSpaceNorm)), g_Material.Power) * g_Lights[i].Specular;	
		}															
																	
		float LD = length(g_Lights[i].Position-(float3)mul(g_World,vPosition));	
		if(LD > g_Lights[i].Range)									
		{															
			fAttenSpot = 0.f;										
		}															
		else														
		{															
			fAttenSpot *= 1.f/(g_Lights[i].Attenuation0 + g_Lights[i].Attenuation1*LD + g_Lights[i].Attenuation2*LD*LD);	
		}															
																	
		//spot cone computation
		float3 L2 = mul((float3x3)g_ViewIT, -normalize(g_Lights[i].Direction));	
		float rho = dot(L, L2);										
																	
		fAttenSpot *= pow(saturate((rho - g_SpotLightCosHalfPhi[i])/(g_SpotLightCosHalfTheta[i] - g_SpotLightCosHalfPhi[i])), g_Lights[i].Falloff);	
																	
		ret.Color0 *= fAttenSpot;									
		ret.Color1 *= fAttenSpot;									
	}																
	return ret;														
}																	
																	
/////////////////////////////////////////////////////////////////////
///
/// Compute lighting contributions
///
/////////////////////////////////////////////////////////////////////
COLOR_PAIR																///< Returns diffuse/ambient and specular components
	DoLighting														
	(																
		float4			vPosition,										///< Position in model space
		float4			ambientColor,									///< Ambient color to modulate lighting
		float4			diffuseColor,									///< Diffuse color to modulate lighting
		float4			specularColor,									///< Specular color to modulate lighting
		float3			viewSpaceNorm,									///< Normal in view space
		float3			viewSpaceViewVec,								///< View vector in view space
		uniform bool	k_SpecularEnable								///< Specular enabled?
	)																
{																	
	//
	// Initialize return value
	//
	COLOR_PAIR ret;													
	ret.Color0 = 0.f;												
	ret.Color1 = 0.f;												
	
	//
	// Ambient contribution
	//
	ret.Color0 = g_Ambient * ambientColor;
																	
	for (int i = 0; i < 8; i++)										
	{																
		if (g_LightEnable[i])										
		{															
			COLOR_PAIR thisLightContrib;							
			D3DLIGHTTYPE type = g_Lights[i].Type;					
			if (type == D3DLIGHT_DIRECTIONAL)						
			{														
				thisLightContrib = DoDirLight(viewSpaceNorm, viewSpaceViewVec, i, k_SpecularEnable);	
			}														
			else if (type == D3DLIGHT_POINT)						
			{														
				thisLightContrib = DoPointLight(vPosition, viewSpaceNorm, viewSpaceViewVec, i, k_SpecularEnable);	
			}														
			else if (type == D3DLIGHT_SPOT)							
			{														
				thisLightContrib = DoSpotLight(vPosition, viewSpaceNorm, viewSpaceViewVec, i, k_SpecularEnable);	
			}														
			else													
			{														
				thisLightContrib.Color0 = 0.f;						
				thisLightContrib.Color1 = 0.f;						
			}														
			thisLightContrib.Color0 *= diffuseColor;
			thisLightContrib.Color1 *= specularColor;
																	
			ret.Color0 += thisLightContrib.Color0;					
			ret.Color1 += thisLightContrib.Color1;					
		}															
	}																
																	
	return ret;														
}																	
																	
/////////////////////////////////////////////////////////////////////
///
/// Compute the fog value
///
/////////////////////////////////////////////////////////////////////
float4 DoFog(float3 viewSpacePos,									
			 uniform bool k_FogEnabled,								
			 uniform bool k_RangeFogEnable,							
			 uniform int k_FogVertexMode)									
{																	
	float4 ret = 1.f;												
																	
	if (k_FogEnabled)												
	{																
		float d;													
		if (k_RangeFogEnable)										
			d = length(viewSpacePos);								
		else														
			d = viewSpacePos.z;										
																	
		float4 ret = 1.f;											
		if (k_FogVertexMode == D3DFOG_EXP)								
		{															
			ret = 1.f / exp(d * g_FogDensity);						
																	
		}															
		else if (k_FogVertexMode == D3DFOG_EXP2)							
		{															
			ret = 1.f / exp(pow(d * g_FogDensity, 2));				
		}															
		else if (k_FogVertexMode == D3DFOG_LINEAR)						
		{															
			ret = saturate((g_FogEnd - d)/(g_FogEnd - g_FogStart));	
		}															
	}																
																	
	return ret;														
}																	
																	
/////////////////////////////////////////////////////////////////////
///
/// vertex shader
///
/////////////////////////////////////////////////////////////////////
VS_OUTPUT															
	vs_main															
	(																
		float4			vPosition					: POSITION0,	
		float4			vPosition2					: POSITION1,	
		float3			vNormal						: NORMAL0,		
		float3			vNormal2					: NORMAL1,		
		float2			vTexCoord0					: TEXCOORD0,	
		float2			vTexCoord1					: TEXCOORD1,	
		float4			vColor0						: COLOR0,
		float4			vColor1						: COLOR1,
		uniform bool	k_NormalizeNormals,							
		uniform bool	k_TweenEnable,								
		uniform int		k_TextureTransformFlags0,
		uniform int		k_TextureTransformFlags1,
		uniform int		k_TexCoordIndex0,
		uniform bool	k_TexCoordIndex0Enable,
		uniform int		k_TexCoordIndex1,
		uniform bool	k_TexCoordIndex1Enable,
		uniform bool    k_Color0Enable,
		uniform bool    k_Color1Enable,
		uniform bool	k_FogEnabled,								
		uniform bool	k_RangeFogEnable,							
		uniform int		k_FogVertexMode,									
		uniform bool	k_SpecularEnable,
		uniform bool	k_Lighting,
		uniform bool	k_ScreenSpacePositions,
		uniform D3DMATERIALCOLORSOURCE	k_DiffuseMaterialSource,
		uniform D3DMATERIALCOLORSOURCE	k_SpecularMaterialSource,
		uniform D3DMATERIALCOLORSOURCE	k_AmbientMaterialSource,
		uniform D3DMATERIALCOLORSOURCE	k_EmissiveMaterialSource
	)
{																	
	VS_OUTPUT ret = (VS_OUTPUT) 0;									
																	
	//
	// Normalize input normals
	//
	if (k_NormalizeNormals)											
	{																
		vNormal = normalize(vNormal);								
		if (k_TweenEnable)											
		{															
			vNormal2 = normalize(vNormal2);							
		}															
	}																
																	
	//
	// If tweening is enabled, blend the position and normal
	//
	if(k_TweenEnable)												
	{																
		vPosition = (1.f-g_TweenFactor) * vPosition + g_TweenFactor * vPosition2;	
		vNormal   = (1.f-g_TweenFactor) * vNormal + g_TweenFactor * vNormal2;		
	}																
	
	if (!k_ScreenSpacePositions)
	{
		//
		// Transform the position into homogeneous space
		//
		ret.Pos = mul(g_WorldViewProj, vPosition);
	}
	else
	{
		//
		// Screen space transform
		//
		ret.Pos.x  = ( (vPosition.x-0.5)*g_PosScaleX - 1.0 );
		ret.Pos.y  =-( (vPosition.y-0.5)*g_PosScaleY - 1.0 );
		ret.Pos.z  = vPosition.z;
		ret.Pos.w  = 1.f;
	}
										
	//
	// Calculate some vectors used in lighting and texture coordinate generation
	//
	float3 viewSpacePos = mul(g_WorldView, vPosition);					//position in view space
	float3 viewSpaceNorm = mul((float3x3)g_WorldViewIT, vNormal);		//normal in view space
	float3 viewSpaceViewVec = -normalize(viewSpacePos);             	//viewer
																	
	//
	// Texture coordinates
	//
	if (k_TexCoordIndex0Enable)
	{
		if (k_TexCoordIndex0 == D3DTSS_TCI_PASSTHRU)				
		{																
			ret.Tex0.xy = vTexCoord0;									
		}																
		else if (k_TexCoordIndex0 == D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR)	
		{																
			ret.Tex0 = float4((2.f * dot(viewSpaceViewVec, viewSpaceNorm) * viewSpaceNorm - viewSpaceViewVec), 0);	
		}																
		else if (k_TexCoordIndex0 == D3DTSS_TCI_CAMERASPACENORMAL)	
		{																
			ret.Tex0 = float4(viewSpaceNorm, 0);						
		}																
		else if (k_TexCoordIndex0 == D3DTSS_TCI_CAMERASPACEPOSITION)	
		{																
			ret.Tex0 = float4(viewSpacePos, 0);							
		}
	}
	if (k_TexCoordIndex1Enable)
	{
		if (k_TexCoordIndex1 == D3DTSS_TCI_PASSTHRU)				
		{																
			ret.Tex1.xy = vTexCoord1;									
		}																
		else if (k_TexCoordIndex1 == D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR)	
		{																
			ret.Tex1 = float4((2.f * dot(viewSpaceViewVec, viewSpaceNorm) * viewSpaceNorm - viewSpaceViewVec), 1);	
		}																
		else if (k_TexCoordIndex1 == D3DTSS_TCI_CAMERASPACENORMAL)	
		{																
			ret.Tex1 = float4(viewSpaceNorm, 1);						
		}																
		else if (k_TexCoordIndex1 == D3DTSS_TCI_CAMERASPACEPOSITION)	
		{																
			ret.Tex1 = float4(viewSpacePos, 1);							
		}
	}

	//
	// Apply texture transform if called for
	//
	if (k_TextureTransformFlags0 != D3DTTFF_DISABLE)
	{
		ret.Tex0 = mul(g_TexTrans0, ret.Tex0);
	}
	if (k_TextureTransformFlags1 != D3DTTFF_DISABLE)
	{
		ret.Tex1 = mul(g_TexTrans1, ret.Tex1);
	}
																	
	if (k_Lighting)													
	{																
		//
		// Do lighting
		//
		float4 ambientColor;
		float4 diffuseColor;
		float4 specularColor;
		if (k_DiffuseMaterialSource == D3DMCS_MATERIAL)
		{
			diffuseColor = g_Material.Diffuse;
		}
		else if (k_DiffuseMaterialSource == D3DMCS_COLOR1)
		{
			diffuseColor = vColor0;
		}
		else
		{
			diffuseColor = vColor1;
		}
		if (k_SpecularMaterialSource == D3DMCS_MATERIAL)
		{
			specularColor = g_Material.Specular;
		}
		else if (k_SpecularMaterialSource == D3DMCS_COLOR1)
		{
			specularColor = vColor0;
		}
		else
		{
			specularColor = vColor1;
		}
		if (k_AmbientMaterialSource == D3DMCS_MATERIAL)
		{
			ambientColor = g_Material.Ambient;
		}
		else if (k_AmbientMaterialSource == D3DMCS_COLOR1)
		{
			ambientColor = vColor0;
		}
		else
		{
			ambientColor = vColor1;
		}
		COLOR_PAIR lighting = DoLighting(vPosition, ambientColor, diffuseColor, specularColor, viewSpaceNorm, viewSpaceViewVec, k_SpecularEnable);
		if (k_Color0Enable)
		{
		    ret.Color0 = lighting.Color0;
		}
		if (k_Color1Enable)
		{
		    ret.Color1 = lighting.Color1;
		}
	}
	else
	{
		//
		// Use vertex colors
		//
		if (k_Color0Enable)
		{
		    ret.Color0 = vColor0;
	    }
	    if (k_Color1Enable)
	    {
		    ret.Color1 = vColor1;									
	    }
	}
																	
	//saturate
	if (k_Color0Enable)
	{
	    ret.Color0 = min(1.f, ret.Color0);								
	}
    if (k_Color1Enable)
    {
	    ret.Color1 = min(1.f, ret.Color1);
	}
																	
	//apply fog
	float4 fogColor = DoFog(viewSpacePos, k_FogEnabled, k_RangeFogEnable, k_FogVertexMode);	
	ret.Fog = fogColor.x;												
																	
	return ret;														
}																	

VS_OUTPUT
	main
	(
		float4			vPosition					: POSITION0,
		float4			vPosition2					: POSITION1,
		float3			vNormal						: NORMAL0,
		float3			vNormal2					: NORMAL1,
		float2			vTexCoord0					: TEXCOORD0,
		float2			vTexCoord1					: TEXCOORD1,
		float4			vColor0						: COLOR0,
		float4			vColor1						: COLOR1
	)
{
	return vs_main(vPosition, vPosition2, vNormal, vNormal2, vTexCoord0, vTexCoord1, vColor0, vColor1, 
		K_NORMALIZENORMALS,
		K_TWEENENABLE,
		K_TEXTURETRANSFORMFLAGS0,
		K_TEXTURETRANSFORMFLAGS1,
		K_TEXCOORDINDEX0,
		K_TEXCOORDINDEX0ENABLE,
		K_TEXCOORDINDEX1,
		K_TEXCOORDINDEX1ENABLE,
		K_COLOR0ENABLE,
		K_COLOR1ENABLE,
		K_FOGENABLE,
		K_RANGEFOGENABLE,
		K_FOGVERTEXMODE,
		K_SPECULARENABLE,
		K_LIGHTING,
		K_SCREENSPACEPOSITIONS,
		K_DIFFUSEMATERIALSOURCE,
		K_SPECULARMATERIALSOURCE,
		K_AMBIENTMATERIALSOURCE,
		K_EMISSIVEMATERIALSOURCE
		);
}

Unused Text

In simpsons_global.en.LH2, there is unused text for an apparent developer interview.

yeah, Land of Chocolate.  Basically, Homer Simpson has found that there's a land of chocolate, he's running around eating the lamp post and chocolate bunnies, and everything like that, so it's...  Many of us has been in a place like that when we've needed chocolate.The sound design has been a really interesting part of this experience because it's comedy and because it's Simpsons, it does take a slightly different approach from other games.  A lot of times, bigger and beefier is often the answer, in Simpsons, it takes more of a delicate approach to the sound design.  Roughly half of our sounds comes from libraries, the other half we're out there creating on our own or hiring fully artists, whatnot.  Our senior designer, Jay White, spent a lot of time with gloopy bags of balloons to get sounds for Homer ball.  Each sound kind of takes its own different technique.  For physics objects alone, things that you can break and kick and roll around, there's roughly about twelve thousand samples in the product

Treehugger's a level where Bart, and Lisa, and everyone, all the Simpsons need to stop Mr. Burns from ruining our environment.  He's trying to log, so you're in this logging situation, and you've got to go up the conveyor belt and do all kinds of stuff to try and stop Mr. Burns.  So what we did is we really went down the road of mixing the orchestra with things that are a little bit more organic.  We had rattles, and shakers, as well as, we actually used a nylon string guitar.  It's the one level where we really used the acoustic guitar sound and it's got a very quirky off kilter sound to it, much like the early Danny Elfman scores, but also a little out there, there's a little dissonance, a lot of things because everything's all out of whack.  And I think for me, it created the most musical expression, the most interesting, original sound that I did for the game, but it also seems to work with the game play very well, and it keeps you on the edge of your seat

One thing we really put in a lot of time as well is the dialog and mouth shapes.  So when you see the characters talk, they're going to be using the proper mouth shapes not, which is what a lot of games do though, just flap the mouth open and close.  And you kind of get an experience, you kind of get into the character, but when you actually see the mouth and the shapes correctly, and the "Oooo's" and all the different mouth expressions and the lip synch match perfectly, it's pretty rewarding

The Simpsons game is actually one of the biggest games I've ever worked on.  We have 16 unique levels.  Unlike a lot of other games, we actually don't reuse a lot of game ideas between each level.  Each level is pretty unique, and each level kind of stands alone as a really, really good game in itself.  And we spend a lot of time actually, just tweaking the game play and tuning and coming up with a lot of neat little cameos and ideas that not only Simpsons fans, but I think every game fan will just love playing this game

The original ending for Neverquest actually, um, you know, the first design, was that we had a giant troll, played by Nelson Muntz, and for complicated reasons, you never get into production and you make choices about what's the best thing to do for the level, we just decided to just get right into the final boss fight with the dragon and skip the whole waking up the troll puzzle.  So if you play the level now, the finished level, and you get into the dungeon, after the first room in the dungeon, there's a big mural on the wall of Nelson cast as a troll, with a club and he's kicking little creatures around.  And that is an homage to a character that almost made the game, we had the model built, and we just sort of cut him out at the last minute

We never missed any of the family, all of the family is in there as well.  And everyone is playable and that's the great part about it.  We didn't just leave and just take one, but everyone is very unique.  That was a big challenge, a lot of animations, every character is different, I mean this is one game I've worked on...it's phenomenal...we've got I think over 140 in game characters from the show.  I think total you'll see about 200, but everyone is unique, everyone is got a different high and their true to the model sheets.  And the model sheets, the sheets that come from Film Roman that say this is how Homer or a character should look.As many of the people know, most of the Simpsons games that have shipped didn't look anything like the Simpsons.  It just never capture the look from the show, so that was one of the first things we said when we sat down and designed the game

I'm really happy and proud to have finally been on the product that's going to say that this is the Simpsons game, the one's that everyone's been waiting for

I found this really cool quiz on the internet which is like which Simpsons character are you, and you answer like 20 questions and it spits out which Simpsons character you are.  And I took the quiz and I'm Lisa.  Lisa is the kind of philosopher, you know, she's the environmentalist, she's sort of a problem solver, she's a little neurotic, she worries a lot, and I think that sounds about right.I think I'd come probably come out a more, a little more like Homer, which is I think cause Homer represents everyday man, so there you have it, I guess that's me.Willie's my favorite.  The Scottish guy, mad Scottish guy.  I've met people like him, so he's a lot of fun.  He's a violent guy and he has drastic mood swings, so he's my favorite.Montgomery Burns.  It's one of those things that he never has quite enough time, for me, on screen.  And even in the game, there's things that he gets to say and do, but he's just this kind of fun evil.  You can read who he is, but when he says stuff and does stuff, it's still so damn funny.I'm a big fan of Bart, I mean, who isn't.  I just love Bart, I think he's probably most intelligent, crazy ass character on the show

THE SIMPSONS(TM) GAME - The Sound and the MusicHi, my name is Jonathan Knight.  I'm the Creative Director for the Simpsons games here at EA.THE SIMPSONS(TM) GAME - Meet the TeamCreative DirectorI am Scot Amos.  I'm the Executive Producer for the Simpsons game.Scot AmosExecutive ProducerI'm Ash Huang.  I'm the Art Director on the Simpsons the game.12My name is Paul Gorman, I'm the audio director for the Simpsons.  I oversee the creative and technical aspects of audio.  So that entails music, sound design, all dialog, as well as basically how we get things working in the game.  A lot of the games that I've worked on in the past are very sci-fi, fantasy, cops, things like that and this is trying to make sound for a game that's all about humor is really refreshing, and anything from the music, to working with the voice over talent, to sounds we come up with.Paul GormanAudio DirectorCan we real quick just jump back to, um, bar...sorry, what bar Jeff?  OK, can we get clicks at 11 please, and let's play from 13 through to downbeat of 19.  Just to get less click please, so, 8 into 13 please.Here we go.The way the Simpsons game works out is that every level is something that is completely different game parody or idea.  So we've got everything from the last one you just heard, which is sort of a John Barry vibe of early James Bond, we have a Neverquest level which is very much a Lord of the Rings kind of feel.  We have the crazy Willy Wonka feel, and then we have of course the very Elfman-like vibe when it comes to the wacky zany music that usually comes along with the Simpsons.Chris LennertzMusic ComposerThis is probably my seventh or eighth game, somewhere in there.  It's great, I mean, it's probably the most fun environment that you could work with, especially a game like this for the Simpsons.  We're able to write a different, where every level was a different style of music so it kept it changing and dynamic the whole time.  It's great as a composer because you're able to do a wide range of musical styles and it's great recording for the orchestra because every cue is a different Cue and it keeps it light, light and great

At the heart of making games, it is the team.  I can't program, I can't model characters in 3D, it's too complicated.  There's no way that I could do the things that the team does and so it's really about the team coming together and making something.Jonathan KnightCreative DirectorOne thing I love about making this particular product is for the first time, at least in my career from building a game...16 years of doing this, starting from 6 person teams all the way up to 150 person teams, looking around one of the things I've learned through all the different games I've made, from racing, to action games, fighting games, all kinds of different stuff, the game itself to me has become less of I need to make a certain type of game, I need to make RPG or I need to make that, but it's become more about the people.  Because at the end of the day, we probably spend more time with each other than with our own families.  The Simpsons franchise is great, the Simpsons people have been great to work with, the comedy and the fun and everything that's in there, we love it.  So this is a really special family that we get to be a part of now, but really the family comes from the team itself, so that internal culture, it's what...if the teams having fun, the game's going to be fun

I think the other thing that been an interesting and fun thing to do is thinking about how you translate that Simpsons humor from the television show into something that's a game because the television show, most of the time it's a passive experience.  They tell you the jokes, its all based on timing, and then to get that crazy Simpsons wackiness and humor into the game, where its a user experience...  It isn't completely timed for them, you don't know where the player's going to go, where they're going to wander in the environment, and to make sure that level of humor stays true to the show has been a fun and interesting challenge too

Version Differences

Enter the Cheatrix Time Challenge

The bridge in the blood room is damaged in the Xbox 360 version, despite it being fully intact in the PlayStation 3 release.

Xbox 360 PlayStation 3
SimpsonsGame360-FIN CheatrixTimeTrialBridge.png SimpsonsGamePS3-FIN CheatrixTimeTrialBridge.png