Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
12. October 2017


Version 2017.2 of the Unity game engine was released today.  2D game tools received a lot of love in this release with new tiled based worldUnity building tools.  Unity also teamed up with Autodesk to improve FBX format support from 3DS Max and Maya.  VR platforms also got some love with ARCore, ARKit, Vuforia and Windows Mixed Reality support all added.


Further details from the Unity blog:

  • tilemap support for grid based 2D titles
  • Cinemachine support in 2D
  • sprite packing speed improvements and cleaner box collider
  • timeline visualization of audio clips
  • interactive tutorials ( previously discussed here )
  • NavMesh visualization
  • improved FBX importer/exporter directly using Autodesk’s FBX SDK
  • support for embedded materials in FBX files
  • exporting of animated custom properties from DCCs
  • importing support for Stingray PBS shaders
  • new AssetBundle API
  • support for XR platform Vuforia
  • support for Microsoft’s Mixed Reality platform
  • OpenVR support on MacOS
  • Google ARCore support ( via plugin )
  • Apple ARKit support ( via plugin )
  • Stereo Instancing ( single pass instanced rendering )
  • Editor simulation of Vive headsets
  • low level rendering support for the Nintendo Switch
  • Retina support for the MacOS player
  • GI profiler ( Global Illumination )
  • improved Progressive Lightmapper
  • linear rendering in WebGL ( details here )
  • particle system improvements
  • remoting settings, remotely change game settings without creating a new binary


You can read complete details in the release notes.

GameDev News


8. September 2017


In the most recent release of Unity 2017.2 Beta, Unity added a new feature for interactive tutorials.  Basically these are step by step beginner tutorials that run directly in the Unity engine and introduce basic concepts like running your scene or present scenarios where you need to fix a problem within an existing project.  They are accessible in the Learn tab when you first launch Unity.

image

If you want more information, I take a hands on look at this new feature in this video:


Again, you need to be running Unity 2017.2 beta or higher in order to have access to the interactive tutorials.  You can download the latest beta here.

GameDev News


11. August 2017


All the way back to Unity 1.0, the Unity game engine has supported a version of JavaScript called UnityScript.  Today on the Unity blog, Unity have announced that they will no longer be supporting UnityScript going forward.  Starting in Unity 2017 beta 2, they will remove the ability to create JavaScript files directly inside the editor.  Then they will be removing the ability to submit .js files to the Asset Store.  Then at some point in the future they will be removing the compiler completely, although it will be available to be forked on Github.  According to Unity analytics numbers on a very small portion of the community is even using UnityScript at this point, with under 4% using it as the primary language. 

They actually published some fairly interesting stats about language usage:

  • To date, of all the projects that have used Unity 5.6, about 14.6% of them have at least one file with a .js extension in it. 14.6% sounds quite high, but then we broke the numbers down further, and looked at how many files were .js files as a fraction of total script files in the project (.js + .cs).
  • So, that leaves 85.4% of all projects which are entirely in C#, with no UnityScript files at all.
  • 9.5% of all projects are mostly in C# – they have some UnityScript files, but fewer than 10% of their total script file count. Another 1.5% of all projects have between 10% and 20% of their code in UnityScript files.
  • That leaves 3.6% of all projects that have more than 20% of their code in UnityScript.
  • Only 0.8% of all projects are exclusively (i.e. 100%) in UnityScript.


With only a small portion of the community using UnityScript it does make very little sense to continue supporting it, especially now that C# support isn’t stuck in the stone ages.

GameDev News


29. June 2017


In this section of our Bowling with Game Engines series, we will be implementing our bowling game in Unity. The idea is straight forward, implement the same simple 3D game across a number of game engines.  The Unity game engine is a logical place to start, as it is perhaps the most popular game engine in use today.  We will go step by step through the process of creating our game, both in text as well as a video version available here.   I am not a regular Unity user, so please do keep in mind, a lot of what I am about to show may not be best practice!  All of the assets used in this tutorial are available for Patreons as part of the bowling game kit, along with project files and this document in PDF form.  Don’t worry, these aren’t needed to follow along.

Let’s jump in.  Fire up Unity and create a new project.  In this example I am using Unity 5.6.1, however any recent version should work.


First, let’s start by dragging all of our required assets into Unity.  Simply select all of the game assets you will be using (FBX models, textures, audio files) and drag and drop them from Explorer or Finder into the assets folder.  If you are using the Patreon assets, simply copy the contents of Raw Assets in the Unity project folder.

clip_image002[4]


Unity does an extremely good job of importing assets and you should require no additional steps.  We now have all of the assets we are going to need to create our game, let’s get started.




Creating the Title Screen


First, we are going to start by creating a simple title screen with some awful looping background music.  We will be using our default scene for the splash screen and later we will create another scene for our actual gameplay.  We start off by saving our untitled scene.  Simply select File->Save Scene As…

clip_image004[4]

I saved it as TitleScreen. You should now have a new item in your assets list:

clip_image006[4]


We now have a few setup tasks to take.  We are going to be showing our title image and this requires us to alter the Main Camera entity. In Hierarchy panel select Main Camera, then in Inspector we change Clear Flags to Don’t Clear.

clip_image008[4]

This causes our camera to no longer have perspective ( things aren’t drawn smaller the farther away they get from the camera ).  Generally an Orthographic camera is what you use when working in 2D in a 3D world. Setting Clear Flags to don’t clear simply causes the default skybox to not be drawn, we could have optionally defined a background clear colour if we preferred. 


Now in Hierarchy panel, click the Create button, select UI->Canvas.  Next, with the newly created Canvas selected, click Create again and this time select UI->Panel.  At this point we should have this hierarchy.

clip_image010[4]


Next we have to make a slight modification to our imported Titlescreen image.  Select the Tilescreen.png image file in the assets view, then in Inspector change Texture Type to Sprite (2D and UI).  Then scroll down in the Inspector and click the Apply button.

clip_image012[4] 


Next select Panel in the Hierarchy view, and drag our newly created Sprite over to the Source Image section in the Image (Script) section.

clip_image014[4]


If you press Play now, you should see your Title screen in the viewport.

clip_image016[4]


Now let’s add a looping music file to our title screen.  In the Hierarchy view, select the Canvas entity.  Then in inspector scroll down and click Add Component, then Audio->Audio Source.

clip_image018[4]


In the newly created Audio Source in Inspector, drag our imported audio file over to the audio clip section.  Down below, make sure Play on Awake is set and then tick the box next to Loop.

clip_image020[4]


Ok, we now have a title screen and a sound track playing!  Good work so far… now let’s add a simple script that changes scenes on click. Let’s create our script.  Right click in the Assets area, select Create-> C# Script.

clip_image022[4]


Name it PanelScript.cs.

clip_image024[4]


Double click the newly created script file and it will open in your editor of choice.  Now enter the following code:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

public class PanelScript : MonoBehaviour {

   // Use this for initialization
   void Start () {
      
   }
   
   // Update is called once per frame
   void Update () {
        if (Input.GetMouseButtonUp(0))
            SceneManager.LoadScene("GameScene");
    }
}


Here we are simply checking every single pass through the game loop if the Left (0th) mouse button (or touch) is clicked, and if it is, we load the scene named “GameScene”.


Hmm… guess we should make a scene called GameScene now shouldn’t we?  Once again right click the Assets panel, then select Create->Scene.

clip_image026[4]


Rename the newly created Scene to GameScene.

clip_image028[4]


We are now done with our title screen scene.  Make sure you save.  Before we open our newly created GameScene, we have one last step to perform.  In the File menu, select Build Settings…, then select Add Open Scenes.

clip_image030[4]


Now double click our newly created GameScene to open it up.  If prompted to save, do so.  Now it’s time to create our game!


Click here to continue to part two!

Programming


29. June 2017

Click here for Part One

Creating the Game Scene


Now it’s time to get to work on creating the game itself.  Start off by dragging BowlingLane into the scene.

clip_image002


Now move the lane so it’s at position (0,0,0) in the Inspector under the Transform component.

clip_image004


One thing I noticed is the Normal map is way too strong.  Select the Bowling Lane material (either in the Materials panel, or drill down to it).  Dial back the Normal Map strength from 1.0 to 0.2.

clip_image006


We are almost done with our bowling lane.  The final thing we need to do is add a Collision Shape to it, so the rest of the stuff in our game world will interact with it properly.  With the BowlingLane selected, click Add Component->Physics->Box Collider

clip_image008


The nice thing with Unity is, it will automatically shrink wrap the collider geometry to match your mesh, so you should have to do no additional work!

clip_image010


So, that’s it for the lane, now time to create the Bowling pins.  Simply drag the Bowling Pin into the scene:

clip_image012


Hmmmm… pretty dark. What’s going on here?  Well, right now we are getting our lighting from the Directional Light in our scene.

clip_image014


We don’t want to mess around with advanced lighting, so instead right click and get rid of it. Now lets set up Ambient lighting instead.  Select Window->Lighting->Settings

clip_image016


Change Environment Lighting->Light Source to Color, then select the Ambient Color as white:

clip_image018


Now our scene will have universal consistent lighting:

clip_image020


Now it’s time to add some physics to our pin.  Once again we have to make a collision object component, but we also need to create a RigidBody component.  Add a Box collider just like before.  Then add another Component and select Physics->Rigidbody

clip_image022

The default settings are about right, so there is nothing else we need to do here.


The final thing we need to do with our pin is apply a tag to it so we can locate it using code later. With the Pin selected, in the Inspector at the top drop down the Tag drop down and select Add Tag…

clip_image024


Click the + Icon, then in the resulting text box enter “Pin” then Save.

clip_image026


Now select the Pin again, and in the Tags list, select Pin which should now be an option.

clip_image028


Now we simply need to create 4 ( or 9… depending your bowling preferences ) clones of our pin. Select the BowlingPin in the scene graph, right click and select Duplicate.  This will create a copy with all of the settings and components defined. 

clip_image030


After duplicating, position the pin and repeat the process until you have enough pins.

clip_image032


Click here to continue to part three.

Programming


See More Tutorials on DevGa.me!

Month List