This is being an enriching experience for me, so I have decided to document my discoveries in my blog. I will be writing a series of posts about my progress. Let’s call the game for now NOTAN.

Today I am going to talk about Scriptable Objects. They are just data containers, but with them I will be able to edit and manipulate my objects in the Unity Editor. This will be quite helpful.

In my game I am going to have a wide catalogue of weapons and armors. The weapons are going to have a certain type of attack: blunt, slash or ranged. The armors on the other side are going to have a resistance to every kind of attack, which will be ranked Low, Med, Strong or Super.

First let’s create Enumerations for this kinds of attributes

public enum WeaponType { Blunt, Slash, Ranged };
public enum Defense { Low, Med, High, Super };

Good! Now that those are defined, let’s create our data classes

// Weapon.cs
using UnityEngine;

public class Weapon : ScriptableObject {

    // Enums
    public enum WeaponType { Blunt, Slash, Ranged };

    // Attributes
    public WeaponType type;
}

// Armor.cs
using UnityEngine;

public class Armor : ScriptableObject {

    // Enums
    public enum Defense { Low, Med, High, Super };

    // Attributes
    public Defense blunt, slash, ranged;
}

We have defined an attribute for the weapons to decide the type of attack that it will have.

We have also defined 3 attributes on the Armor class. These will define what its resistance is to every tyre of attack.

Finally we also moved the enums inside the classes. Semantically they make sense to live there.

Now that our data structures are defined, let’s see how can we create them in Unity. We will aim to create an entry in the menu bar that allows us to create new instances of our classes. To achieve this, we will add the following directive on top of each class:

[CreateAssetMenu(fileName = "Armor", menuName = "NOTAN/Armor", order = 1)]

The first attribute is the class name that will be used to create the Scriptable Object. The second attribute will be the path that will be created to achieve such instance. The last parameter is the position that this element will take inside the menu.

Now let’s take a look at our finished classes

// Weapon.cs
using UnityEngine;

[CreateAssetMenu(fileName = "Weapon", menuName = "NOTAN/Weapon", order = 1)]
public class Weapon : ScriptableObject {

    // Enums
    public enum WeaponType { Blunt, Slash, Ranged };

    // Attributes
    public WeaponType type;
}

// Armor.cs
using UnityEngine;

[CreateAssetMenu(fileName = "Armor", menuName = "NOTAN/Armor", order = 2)]
public class Armor : ScriptableObject {

    // Enums
    public enum Defense { Low, Med, High, Super };

    // Attributes
    public Defense blunt, slash, ranged;
}

With this, our scriptable object is finished. If we try to create a new element inside one of our project’s folder, we will encounter the following menu.

Wonderful! Now we can create object with scripts attached to them. This will make them much easier to manipulate and use, thanks to Unity’s inspector.

How does it look in the inspector, you ask me? Well, let’s take a look.

Great, isn’t it? Now we can change the properties of our gear without even having to touch any code. And we can easily assign our gear to another Unity scripts as simple parameters!

I hope you liked this first episode on developing with Unity. Tell me your opinion and experience about Scriptable Objects in the comments section.

Cheers!

Enemy[] enemies = GetEnemies();

bool anyEnemyAlive = false;
foreach (Enemy enemy in enemies) {
    if (enemy.alive) {
        anyEnemyAlive = true;
        break;
    }
}
if (anyEnemyAlive) {
    // Do something
}

I am sure most of you have written this loop about 1 million times. I recently discovered there is a simpler way to do this:

using System.Linq;

Enemy[] enemies = GetEnemies();

if (enemies.Any(enemy => enemy.alive)) {
    // Do something
}

Much more pleasant to the eye, right?

But this approach should be use with care, since it can have unexpected performance hits or garbage allocations. It would be best used for one-time set up methods, probably.

Feel free to comment on this technique and share your thoughts.

Credit: ADAMGRYU

If we look at the timeline, we see 2 lines. One is blue and the other one is red. Looking at the footer from that same panel, we see the blue one is called “DOMContentLoad” and the red one is called “Load”. But what is the difference between them?

DOMContentLoad: This is the time it takes to download all the DOM tree, and parse it. This means not only download the content of the HTML file, as in its characters, but also the time it takes to understand the relationship between the nodes of the DOM and form the tree structure inside Chrome. Basically to form the DOM hierarchy.

Load: This event includes all things from DOMContentLoad, and includes also all the sub-resources included in the document. This means: CSS files, JS files, images, iframes, etc… Basically all that is needed for the page to render completely.

From a Javascript and jQuery point of view, DOMContentLoad is enough most of the times to start executing. This is the reason why most jQuery code is attached to the event “ready”, which fires with “DOMContentLoad”.

On the other side, if some code needs to access things like the size of an image, or the CSS attribute of a certain DOM node, waiting for the “load” event is necessary, since this information will not be available until this event fires.

If you want to understand better how these events are fired, here is a great demo for it.

Hopefully now you have a better understanding of what these 2 events mean, and they help you know better how your own websites work and perform.

Cheers!

This tutorial is to set up the certificate on an Apache Web Server

Get the client

First of all we will download the “Let’s encrypt” client. That is right. They made a client-side app, to make it extra easy for you. So we will save it under /opt, which seems to be the standard directory to place 3rd-party software, or so I am told.

sudo git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt

Set up the certificate

Keep in mind how many domains you want to support with a single certificate. For instance, this blog should work only with the URL https://enriquemorenotent.com, but it could also be set to work with https://www.enriquemorenotent.com which means that we have 2 domains to support:

• enriquemorenotent.com
• www.enriquemorenotent.com

cd /opt/letsencrypt
./letsencrypt-auto --apache -d enriquemorenotent.com -d www.enriquemorenotent.com

Notice how I add a -d for every domain I want to support. It is important that the first domain is the base domain.

After a few questions like email address and others, you will be all set!

Renew your certificate automatically

The certificates from Let’s Encrypt only last 3 months. But updating them is quite easy. Just download the following script and install it

sudo curl -L -o /usr/local/sbin/le-renew http://do.co/le-renew
sudo chmod +x /usr/local/sbin/le-renew

Now all you have to do is run

sudo le-renew enriquemorenotent.com

and the cerfiticate will update (or it will tell you that is too soon for it).

We can make this task automatic using crontab:

crontab -e

30 2 * * 1 /usr/local/sbin/le-renew enriquemorenotent.com >> /var/log/le-renew.log

This will run every Monday at 2:30 am the script, updating the certificate if necessary

Update the client

Remember that the client you cloned with git might be in development, so every now and then it might not be a bad idea to do this:

cd /opt/letsencrypt
sudo git pull

Just to make sure we are using the latest version 😉

—

Based on this tutorial

Choosing themes was not usually an easy task. Usually involves choosing theme, activating it, and checking it, which shouldn’t take more than 10 seconds, but if you are doubting between 20 themes, it can get quite tedious.

Luckily we have a good solution now. It is called Colorsublime. This website has a huge collection of themes, with nice previews of how it will look like, so you can decide faster. But that is not the deal-breaker. The real breakthrough is the plugin they offer to switch between themes quickly. I could explain it, but an image says more than 1000 words, so…

This way, switching between and choosing themes can’t get any simplier. Just follow the install instructions, and you will check out how dead simple it is 🙂

Whether you like this decision or not (I do not), this is the actual status for Laravel 5, so if you want to recover those facades, you will have to follow these steps if you want to recover these facades:

1. Edit your composer.json to include this “illuminate/html”: “5.*”

2. Update composer

composer update

3. Add the `ServiceProvider` in `/config/app.php`

Illuminate\Html\HtmlServiceProvider::class

4. Add to the same file the aliases

    'Html'      => Illuminate\Html\HtmlFacade::class,
    'Form'      => Illuminate\Html\FormFacade::class,

Now you are ready to use it. But it appears that its usage has also changed from Laravel 4. Now you will have to use “{!!” and “!!}” instead of “{{” and “}}”. (Do not ask me why. I have no idea.)

Examples:

{!! Form::open([]) !!}

    {!! Form::text('name', @$name) !!}

    {!! Form::password('password') !!}

    {!! Form::submit('Send') !!}

{!! Form::close() !!}

Every time I want to update my repositories I had to do

git push origin master
git push bitbucket master

As you see I had to define 2 remotes, one for each repo. But this is kinda cumbersome, since I want to test everything that I upload to my main repository. I could chose to use BitBucket as my main repository as well, but for personal reasons I chose not to.

So to avoid having to input this 2 codes everytime all I have to do is this.

git remote set-url origin --add git@bitbucket.org/USERNAME/PROJECT.git

This way we will add a new push URL to the “origin” repository. Now we can do safely “push” once and git will upload the changes to both repositories.

Of course, I have been doing for a long time this command to check if I was actually connected to the internet at all

ping www.google.com

But this just gives you a yes/no answer most of the time, you can not really see the speed of your connection for example. I began browsing around the internet and I came across this clever solution to figure out how fast is your connectivity

wget -O/dev/null speedtest.pixelwolf.ch

This will give you a good reading of how fast your connection is, without needing any graphical interface.

This tutorial is for Ubuntu 14.04, but it should work on most systems. Please leave any comments if you can’t get it working.

What kind of mailing system are we going to use?

There are several different ways to handle mailing inside a system. You could be running your own mail server, but I have discovered, the hard way, that making a mail server is a VERY complicated task. If you are just trying to make a website that sends email to its users (or to you), I have to advice you against this decision.

The best option you could chose is to chose an external service handle the mail server. In this case, we are going to create an account of GMail, let’s call it tutorial@gmail.com. We could be using any other service, like Yahoo or Microsoft, to name some popular ones. That is up to you.

How to configure the system

Install the needed libraries

The first step will be to install msmtp, a small SMTP cliente. All this program does is to send mail to a SMTP server (like GMail’s), and the server will take care of its delivery.

sudo apt-get install msmtp ca-certificates

Configure msmtp

Now we have to configure msmtp. For that we will edit the following file, using vi or any other editor of your liking.

sudo vi /etc/msmtprc

Do not worry if the file is empty or it does not even exist. This is the right location to create the configuration file for msmtp.

Inside the file we will write some general configuration defaults for security, logging, and most important, setting up at least an account which we will use to deliver the mail

# Default settings that all others account inherit
defaults
auth on
tls on
tls_trust_file /etc/ssl/certs/ca-certificates.crt

# Logging - uncomment either syslog or logfile, having both uncommented disables logging at all.
#syslog on
# Or to log to log own file
#logfile /var/log/msmtp/msmtp.log keepbcc on

# Gmail account configuration
account gmail
host smtp.gmail.com
port 587
from tutorial@gmail
user tutorial@gmail
password passwordWeHaveChosen

# Default account to use
account default : gmail

When you write the contents of this file, you will have to replace some values.

• Obviously you will have to replace “tutorial@gmail.com” with your own address, that you have chose to deliver mail.
• You will also have to write your own password, instead of “passwordWeHaveChosen”.
• For people using GMail, the host of their servers is “smtp.gmail.com” with port “587”. If you are using other service different than GMail, you will have to find out that information on your own. Sorry I can not help you there, but you should not have too much trouble locating that information, if you look in the help pages, or browse around the internet for that information.
• The account was named gmail, as seen on the line “account gmail”. At the end of the file, we set that account as the default one. You can keep it as it is, or you can change its name. The name you chose for it is irrelevant, but I would advice to name it accordingly to the service you are using.

Set permissions on the file

Now, because this file contains a password in plain text, you should cut down its permissions. Let’s make use of a group called mail coming from the default Ubuntu installation. Any process which is run under mail group member can read this file and therefore actually send email.

sudo chgrp mail /etc/msmtprc
sudo chmod 660 /etc/msmtprc

Now add any users who needs to be member of mail group (like your webserver user), so they can read the password

sudo adduser www-data mail

Test msmtp

Great, msmtp is in place. Let’s test if it is working. I am going to send myself a test email from the terminal.

echo 'This is a test email' | mail -s 'Test subject' 'enrique@gmail.com'

If you have received an email at this point, everything is working A-ok!

Configure PHP to use msmtp

Now the final step is to tell PHP how to send emails using msmtp. For that we will edit the configuration file:

sudo vi /etc/php5/apache2/php.ini

We have to look for the line with the value ‘sendmail_path’ (it might be a big file, so might be a good idea to ‘grep -n sendmail_path’) and change it to the following value.

sendmail_path = /usr/bin/msmtp -t

Restart the web server

Now we restart the Apache2 server, so that the changes done in PHP take effect

sudo service apache2 restart

and our PHP should be ready to send email! It is quite a lengthy tutorial, but hopefully every step of it has made sense. This is the simplest way to send email, that works consistently. Please leave your comments if you have encountered troubles, so that I might have a chance to improve this guide.