tech(){annotations}

We can check if Web Storage is supported and available with following code:

function isStorageAvailable(type) { try { window[type].setItem('StorageTest', 'DataTest'); window[type].removeItem('StorageTest'); return true; } catch(e) { return false; } } if(isStorageAvailable('localStorage')) { // Code for localStorage } else { // localStorage not supported or not available } if(isStorageAvailable('sessionStorage')) { // Code for sessionStorage } else { // sessionStorage not supported or not available }

Data can be stored in key/value pairs using 3 different ways:

localStorage.setItem('Storage1', 'Data1'); localStorage.Storage1 = 'Data1'; localStorage['Storage1'] = 'Data1';

Data can also be retrieved using 3 ways:

var myData = localStorage.getItem('Storage1'); var myData = localStorage.Storage1; var myData = localStorage['Storage1'];

We can also retrieve data using the key() method and passing the index of the item:

var myData = localStorage.key(0);

A data item can be removed using removeItem() and passing the key name:

localStorage.removeItem('Storage1');

It is possible to remove all items using clear():

localStorage.clear();

The number of items stored locally can be retrieved with length:

var numStoredItems = localStorage.length;

It is possible to listen for changes to the Storage object using the StorageEvent on the window object.

However, this event will not be fired on the page changing the Storage object, but it will be fired on other pages on the same domain, so that pages can be synchronized.

window.addEventListener('storage', onStorageEvent); function onStorageEvent(ev) { console.log('Key: ' + ev.key); console.log('Old Value: ' + ev.oldValue); console.log('New Value: ' + ev.newValue); console.log('URL: ' + ev.url); console.log('Storage Area: ' + ev.storageArea); }

The StorageEvent has the following properties:

key: The key changed

oldValue: The original value of the key

newValue: The new value of the key

url: The URL of the file whose key changed

Package Control

Press CTRL + SHIFT + P on Windows or CMD + SHIFT + P on Mac to open the Command Palette.

Start typing Package Control and chose "Package Control: Install Package".

Then search for "Theme - Spacegray" and select it.

Manual Installation

Otherwise the theme can be manually downloaded and installed.

Download the theme ZIP forlder (spacegray-master.zip) from here. Click on the "Download ZIP" button in the page.

Unzip the folder and rename it "Theme - Spacegray".

Open the "Packages" directory by clicking Preferences > Browse Packages... on Windows, or Sublime Text > Preferences > Browse Packages... on Mac, and copy the "Theme - Spacegray" folder inside it.

Enabling the theme

Open the user preference file by clicking Preferences > Settings - User on Windows, or Sublime Text > Preferences > Settings - User on Mac.

To use the ocean dark style add the following lines between the brackets {}:

"theme": "Spacegray.sublime-theme", "color_scheme": "Packages/Theme - Spacegray/base16-ocean.dark.tmTheme"

If you have also installed the Source Code Pro font and want to use it, add the following lines:

"font_face": "Source Code Pro", "font_options": ["medium"], "font_size": 11

Remember to add a comma (,) at the end of the previous line of settings, before adding any other new lines.

You can also try the other two styles for the Spacegray theme.

Ocean light

Change the firts two lines to:

"theme": "Spacegray Light.sublime-theme", "color_scheme": "Packages/Theme - Spacegray/base16-ocean.light.tmTheme"

Eighties

Change the firts two lines to:

Add effects

1) In the Hierarchy panel select Create > UI > Text

2) With the newly created Text element selected, add an Outline and a Shadow component in the Inspector panel. Click “Add Component” then “UI” followed by “Effects”, or simply type the names of the component in the search field.

3) Adjust the settings like Effect Color and Effect Distance in the respective component section.

Format

The Text element has a Rich Text option that when selected allows to use markup tags within text. So, it is possible to display some text in bold by using the tags <b></b>.

It is also possible to use these tags in scripts.

timeText.text = "<b>" + minutes + ":" + seconds + "</b>";

This code can be used to load images after a user interacts with an ad, and then check that all images are loaded before executing other code, like assigning an image to the src attribute of an <img> tag, or implementing an animation.

1) Visual Studio Code

Download and install Visual Studio Code from here.

2) Mono

Download and install Mono from here.

3) VS Code package

There are two different ways to setup this.

The easiest way is to open the VS Code package in Unity.

The second method is to manually download the files, and then copy them in your project. The files are available here. You can either download the ZIP folder, or clone the project using GIT. Once you have the files, you’ll need to copy the “Plugins\Editor\dotBunny” folder into your project in the Assets folder.

4) Enable Visual Studio Code

Once the VS Code package is in place, we need to enable Code as our editor. Go to Unity > Preferences... , you’ll find there is a new item called VS Code in the preferences window.

Select it, and implement the following options:

Check "Enable integration", this will make Code our default editor.

Check "Output Messages to Console", this will allow to write output messages (e.g. Debug.Log) to the Unity console.

Click on "Write Workspace Settings", this will hide non code files in the project structure displayed on the left pane of Code.

5) Open the project in Code

In order for Visual Studio Code to recognise the project as a Unity project, and use some of the features like IntelliSense with Unity API, we need to open the C# project in Code from within Unity. Go to Assets > Open C# Project In Code

IntelliSense will show Unity API reference when we start typing code.

Once we have installed VS Code package for the first time, it will be possible to include it when we create new projects by selecting it from the Asset Package.

If you want to run a server on a different port, specify the port number after the command.

python -m SimpleHTTPServer 8080

To stop the server press CTRL + C in terminal.

We can create a Bash function to simplify the way we run this command. Open .bash_profile either in a text editor or in Terminal. Usually this file is hidden inside Macintosh HD/Users/{name of user}. It can also be opened in the default text editor using Terminal and the following command.

open ~/.bash_profile

Add following function at the end of the .bash_profile, and save the file.

function server() { local port="${1:-8000}"; python -m SimpleHTTPServer "$port"; }

Now it is possible to start a server from a directory by typing server in terminal, or server 8080 to run on port 8080.

If a .bash_profile file does not exist, you can create one with the command:

touch .bash_profile

If you have no permission to edit the .bash_profile, you might need to change ownership of the file, and assign it to yourself.

chown your_user_name ~/.bash_profile

We can also add the functionality to start the browser and navigate to http://localhost by changing the function like this:

function server() { local port="${1:-8000}"; open "http://localhost:${port}/"; python -m SimpleHTTPServer "$port"; }

If you are still in the same terminal session, you’ll need to reload the .bash_profile file in order for the changes to take effect. Type:

source ~/.bash_profile

Start() is called immediately after Awake() and before the first Update(), only if the script component is enabled. It is called only once in the lifetime of the script.

Update() is called once per frame. It is used for regular update,such as moving non-physics objects, timers, inputs. Update() interval times vary depending on the time that takes to process a frame.

FixedUpdate() is called at regular times. It is used for adjusting physics (rigidbody).

OnGUI() is called for rendering and handling GUI events, and could be called several times per frame.

OnDisable() is called when the gameObject to which the script is attached is disabled, or when we move to another scene and all objects on previous scene are disabled.

OnLevelWasLoaded(int level) is called when a new scene is loaded. "level" is the index of the level that was loaded

OnTriggerEnter2D(Collider2D other) is called when the gameObject collider enters the collider of another gameObject that has been set to "trigger". "other" is the parameter referring to the Collider2D component of the other game object.

2) package.json and Gruntfile.js

Grunt CLI requires two files to exist in the folder where the command will be used, the package.json and the Gruntfile.js files.

3) The package.json file

This file is used by npm to store metadata of projects. It is also used to list grunt and the plugins used by grunt in the devDependencies field. This file should be in the root folder of your project. It can be created using the command:

npm init

Running this command in terminal will start a process to create a basic package.json file. Follow the instructions given after issuing the command, and provide the information for the project. Some of these informartion are not required for a grunt package file. The required pakcage.json fields for grunt are name and version.

name: the name of the project (in lowercase) version: version of the project (0.1.0)

The rest of the fields are used by npm and are not required for grunt

description: a description of the project entry point: the javascript file that will run when the module is used test command: this command will run if we type “npm test”. So it is not needed by grunt, but we could also insert “grunt” in the field, so that if we run "npm test” is the same as running “grunt" git repository: our repository if we have one keywords: used to help people to discover your package author: author of the package license: license for the package

After answering all questions, terminal will show a preview of the package. Type yes and press enter to create the package.json file.

Then we’ll need to add grunt and the plugins to the devDependencies object into the package.

To do this we can use a command with format "npm install <module> -- save-dev"

npm install grunt --save-dev npm install grunt-contrib-sass --save-dev

A basic grunt package.json file with sass plugin should look like this

{ "name": "my-project-name", "version": "0.1.0", "devDependencies": { "grunt": "~0.4.5", "grunt-contrib-sass": "~0.9.2" } }

4) The Gruntfile.js

This file is used to configure the tasks and load the required plugins.

You can find out about available plugins here.

The structure of the file is like this

module.exports = function(grunt) { // Project configuration. grunt.initConfig({ pkg: grunt.file.readJSON('package.json'), sass: { // Task dist: { // Target options: { // Target options style: 'expanded' }, files: { // Dictionary of files './css/main.css': './scss/main.scss' // 'destination': 'source' } } } }); // Load plugins grunt.loadNpmTasks('grunt-contrib-sass'); // Default task(s). grunt.registerTask('default', ['sass']); };

grunt.initConfig({…..)}; This is used to configure the project and the tasks.

pkg: grunt.file.readJSON(‘package.json’); This gets the JSON metadata from the package.json file.

sass: {…..} The options for the task we want to run.

grunt.loadNpmTasks(…..); It is used to load the plugins.

grunt.registerTask(…..); It is used to register task names.

In order to process several files at the same time, we can change the files object to be like this

files: [{ expand: true, // Enable to dynamically process more files src: ['**/*.scss'], // Source path of the files to be processed. dest: './css', // Destination for the processed files flatten: true, // Remove original path from processed files ext: '.css' // Replace the original extension with .css }]

5) Install dependencies

Once the package.json and Gruntfile.js files are created, we need to install the dependencies needed to run the tasks.

In terminal navigate to the folder containing the two files, and execute the following command:

npm install

This command will create a folder called node_modules, then download and install grunt and all plugins in that folder.

6) Run a task

Once the grunt project and tasks are set up, it is possible to run a default task with:

grunt

Or another task using its name.

1) Check which location is in the $PATH by opening Terminal and typing

echo $PATH

Terminal will show the locations that are already specified in the $PATH

2) Open .bash_profile either in a text editor or in Terminal. Usually this file is hidden inside Macintosh HD/Users/{name of user}. It can also be opened in the default text editor using Terminal and the following command

open ~/.bash_profile

3) Add a location to $PATH using following syntax: export PATH="locations separated by colon (:) followed by $PATH"

export PATH="/usr/local/bin:/usr/bin:$PATH"