Official Endless Runner Sample Game Q&A

Lots of objects in the project use vertex color (painted in the 3D software like maya/3ds/blender) to cut down on textures size (and because they all started as using only vertex color and some had textures added later when there was a need for more details).

If you find the mesh (e.g. search for WheelyBinBody) you can see on the preview at the bottom the inspector that the mesh have uv and colors information per vertex.

The shader (CurvedCode.cginc) then multiply the vertex color by the texture color (which is greyscale) allowing for varaition in tint across the mesh.

To keep thing relatively simple, the game use the character name as the key saved in the save file to know which character is owned & used (to be more robust we could build some kind of unique ID system per character so you can change the name and retain the character, but that is left as an exercise to the reader )

When the game create a savefile, it grant ownership of Trash Cat by default. So the game will try to instantiate the character called Trash Cat and will fail if it don't find it.

To modify that, look for the PlayerData.cs script, and for the function NewSave() in that script. You will see there that we add to the character list Trash Cat (and to the theme list Day). You can change that to the name of your new character here so it work.

*Note*: after modifying the script, you will need to Clear the save file (either through the Trash Dash Debug menu in the editor or in game, in the settings popup with the Delete Data button) so that the game regenerate a new one with the proper character added to the player save.

 

If you look in TrackManager.cs, there is a function called SpawnCoinAndPowerup() that take care of spawning the "coins" (here the fishbones), premium currency and powerup. It will pick a purcentage of chance that a powerup will be spawn instead of a "coin" (that purcentage grow with time, so that after a while we are sure to spawn one).

 

For the time it took, it is a bit hard to tell precisly because it was made in parallel with other thing, But I would reckon that combined, it was roughly 6 month of works from start of the project to release on store.

As for the team, "full time" : one producer, one artist & one programmer.

We had an animator who worked a couple of week for the animations and a contractor for sounds/music.

Finally some "external" QA (i.e. not done by the full time team ) was done at the end of the project before submitting on the stores by an additional person.

 

Note : you will require some basic understanding on shaders (what are vertex/pixel shader, model/view/clip space etc.) to grasp how the shader work.

CurvedCode.cginc is actually nearly the full shader. It is put in a include file just so I don't have to rewrite the whole shader code when I just want to switch some parameter like Blending, Zwrite or the render queue etc.

As you can see in the file, it define

sampler2D _MainTex;

chance are your custom lit shader already define that _MainTex smapler, hence the conflict.

But what make the curving is just a part of the vertex shader in the CurvedCode include file :

Code (CSharp):

1. v2f vert(appdata v)
2. {
3.     v2f o;
4.     o.vertex = UnityObjectToClipPos(v.vertex);
5.  
6.      //THIS PART----------------------
7.  
8.     float dist = UNITY_Z_0_FAR_FROM_CLIPSPACE(o.vertex.z);
9.  
10.     o.vertex.y -= _CurveStrength * dist * dist * _ProjectionParams.x;
11.  
12.     //----------------------------------------------------------------
13.  
14.     o.uv = TRANSFORM_TEX(v.uv, _MainTex);
15.  
16.     o.color = v.color;
17.  
18.     UNITY_TRANSFER_FOG(o, o.vertex);
19.     return o;
20. }

For each vertex of every object using that shader, it compute the distance of the vertex from the camera (UNITY_Z_0_FAR_FROM_CLIPSPACE) and use that distance as a ratio to offset it on the y axis in clip space (so the vertical axis).

o.vertex.y -= _CurveStrength * dist * dist * _ProjectionParams.x;

_CurveStrength is a float that is passed from script ( see the script WorldCurver.cs) so we can tweak the strength of the curving from a single point in the editor and we multiply by _ProjectionParams.x because some platform render with a flipped projection matrix, so negative y direction on some platform would curve the world upward. _ProjectionParams.x contains -1 on thsoe paltform, so the curve is happening in the right direction everywhere.


So to use on it on a lit shader, either add that transformation in your vertex shader or if you're using a Surface Shader, add a vertex modifier function and do the same modification in that function (see here : https://docs.unity3d.com/Manual/SL-SurfaceShaderExamples.html the section called
Normal Extrusion with Vertex Modifier for an example of how to write such function)

 

Which version of Unity are you using? I think SendWebRequest was added in 2017.3 (but if you got it through the asset store in Unity, it should have given you a previous version)...

 

It would require quite some modification, as for now, the system assume a single path for all 3 lanes (the character is just offset in the x position based on the lane. Based on where the character is, it ask the TrackSegement what is the position it should be + its lane offset.

One possible solution (very broad overview) would be to modify the script TrackSegment.cs :

The script track segment have a transform property called pathParent. It's a transform that will have children which will define a path to interpolate along. In the current game, this path usually have only 2 child : the entry and the exit and it interpolate between.

But you could add 2 other transform pathParent : pathParentLeft, pathParentRight, that have more than 2 children and define your "elevated" path on each pathParent with as many gameobject you need, and modify the function GetPointAt so it can take a parameter telling the system on which lane you want the path to be interpolated, and select the good pathParent for that path, and in the character controller ask the position for the current lane on which the character is.

(side note, if you want to display the new paths like it is now done with a blue line in the scene view, look at the function OnDrawGizmos from TrackSegement)

Of course that's only part of what need to be done, by default it may act weirdly when changing lane from a high to low lane and vice versa, or jumping/sliding when changing lane etc...

 

I wrote some information about that on that wiki : https://github.com/Unity-Technologies/EndlessRunnerSampleGame/wiki

 

1. It allow to display 3D model in a different position/scale etc. than the game Camera.

Here it is used only for the character you see when selecting which character to play (if you look at the code you'll we assign it to the UI layer in the Loadout screen). We can have a point in front of the camera and just place the character here. Easier than to have to move the game camera just for the selection and place it back properly for the game.

In the project, the UI camera end up using the same settings as the game camera, but a possible extension to that could be to play with FOV setting or stick post processing on it to make the character selection screen more interesting.
We also had on "nice to have/try later" to display the level behind when selected, so it allow to display the character on top from a different perspective than the game camera (think overlay)

2. It does but in a very negligible (read nearly non existing) way, because our UI camera have layer culling mask. it only display object in the UI layer (so nearly nothing, and the game camera don't display UI object, so no object are rendered twice) and render directly to screen on top of whatever was already rendered (so no setup cost of swapping render target etc..). The ratio : less code, easier to setup the shot over performance lost is clearly in favour of the ease of setup here

 

Did you build the asset bundles and put them in the StreamingAssets folder before building for Android? You can get some information on how to do that in the file called INSTRUCTIONS.txt in the Assets folder of the project.

 

Did you download the package in a version post 18.1 in the asset store? Then open a fresh project in 17.3, got to the asset store and clicked "import" on the Endless Runner?

The asset store deliver different package based on which version of the editor is used. If you have a package for 17.3 cached but it got one for 18.1, it will show an "update" button on the Asset Store page to trigger a download of the newest version.

But it don't handle "downgrading" package. So if the package cached on your machine was grabbed for 18.1, it won't trigger a redownload and re-import that in 17.3

One thing to try is :

- Open an empty project
- in 17.3 or 17.4 go to your download page on the asset store (the box icon in the asset store toolbar, next to the home button)
- Find Endless Runner
- Click Download to force a re-download of the package, this time being given the one matching this editor version.
- Then import

Seems to have fixed it for me in 17.4 (with a package I had downloaded first in 18.1)

 

Clearing the save will just delete the file on the disk, so next time the game load, seeing there is no save, will create a default new one.

Versioning is here so you can be retro compatible with save from previous version of the game.

Imagine you release your game to the public, and it save character name, current currency and score, then in your save file you would have those information :

name
currency
score

Now you update the game, and now you also save the max distance they reached. So when you read the save file you read name, then currency, then score then distance as you file now contains :

name
currency
score
distance

The problem is, all the save file on your players machine don't have that score. So reading would fail. So to avoid that, you bump the version, and before reading the distance you check if the version is >= 2. If it's not, it's an old save file, so you put 0 in the score. Next time a save is written for that player, the version written will be 2 so next save file read will read everything.

If you clear the save, as the file is deleted, it will just recreate a default save file with the current version


Now for your problem, it's simply that in the current project, we never restore the previously used accessory nor save it in the save file! I had a bug with accessory being restored on the wrong character and disabled it temporarily...and it slipped through the crack and never re-enabled it

To re-enable it you'll need a couple of thing :

- First in LoadoutState.cs : look for the function PopulateCharacter and comment the 2 line that set usedAccessory to -1 at the top.

Code (csharp):

1. PlayerData.instance.usedAccessory = -1;
2. m_UsedAccessory = -1;

PopulateCharacter is called everytime we refresh the character (e.g. when coming back from the store), so that was resetting the accessory!

- In LoadoutState.cs, at the top of the function ChangeCharacter, add those two line

Code (csharp):

1. PlayerData.instance.usedAccessory = -1;
2. m_UsedAccessory = -1;

otherwise, you could try to use an accessory on a character that don't have it! (e.g Trash Cat have 3 accessory, but Rubbish Raccoon only 2, so if you had the 3rd accessory equipped and switch to Rubbish Raccoon : exception!)

- In Loadout.cs, at the top of the function GoToStore add :

Code (csharp):

1. PlayerData.instance.Save();

otherwise, the currently used character won't be saved, and since the save file is read again when going back to the loadout screen, you would go back to the previous character!

And now your accessory should be persistent! There may be some corner case I don't remember, but fixing those is left an exercise to the reader

 

The wiki (here : https://github.com/Unity-Technologies/EndlessRunnerSampleGame/wiki) contains information on how to make new character and theme, and how the track is made. Usingyour own model & animation you should be able to change the game as you want.

 

If your material are pink, it may be that your asset bundles were built with a different platform than the one you run on.
e.g. if you build your asset bundle with the desktop platform, place them in streaming asset, switch to android and build the game to android, it won't work, because the shaders etc. in the bundle are all compiled for desktop platform, not for android.
Be sure that you build your bundle for the platform you are building the game on (you should have a folder Android in StreamingAssets\AssetBundles. if ther eis only a folder Macox or windows or else, that mean the bundle aren't for the right platform).

The curvature is made through a shader applied to all object. The amount of curvature is defined by a script WorldCurver.cs on the Main Camera. Either put the Curve Strength to 0, or use a simple Unlit shader on every material


(sidenote: You can edit your post if you want to add another question to your post and no one have answer since then, it help keep the forum tidier and easier to follow, thanks!)

 

Indeed the game wasn't tested for WebGL, so I can't say if it would work. Looking at the error though, it look like it can't load the asset bundle, which is normal (read "I never put code to handle WebGL ) :

To find where bundles are located to load them, we use Application.streamingAssetsPath, which return a "classic" path when on Desktop or iOs (e.g. C:/MyGame/Data/StreamingAsset) and a URL on other platform like Android (jar:file://etc...) or WebGL (http://localhost:9999/StreamingAssets/etc...)

To unify the loading through the WWW class, the project use define in code to check for which platform the code is compiled and append file:// in front of the streamingAssetPath if not on Android. So in your case, it add file:// in front of the WebGL path that is already an URL, and it can't load file://https://localhost/etc... cause that's an invalid URL!

To fix that, open AssetBundlesDatabaseHandles.cs in the Scripts folder, and look for

Code (csharp):

1. AssetBundleManager.BaseDownloadingURL = Application.streamingAssetsPath + "/AssetBundles/"+Utility.GetPlatformName()+"/";

Just above it, the line

Code (csharp):

1. #if UNITY_ANDROID

means that this line will only get compiled if you're on android. If you change it to

Code (csharp):

1. #if UNITY_ANDROID || UNITY_WEBGL

then this line is now compiled for WebGL too, and the path should be fixed to the proper one.

Please note that this is all from the top of my head, I didn't tested in the project, and the project could have a lot of other problem with rendering or the services etc..