Classes vs IDs: CSS/HTML Crash Course (Free Tutorial)

Classes and IDs?! You may have heard of them before when referring to HTML and CSS.

If you are a beginner and want to learn the basics of coding, check out our FREE 30-minute intro course here: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

Classes and IDs are SUPER useful because they allow us to target certain elements on a page. For instance, if you create an item, giving it a class or ID will be useful later on when you want to stylize the item, such as change its color or size.

Classes are used to give a group of items the same style. Identifiers (IDs) are more specific than classes and are also used to stylize.

To follow along with this tutorial, visit jsbin.com, which allows you to test your code in real time. In JS Bin, click on the HTML tab to open a blank HTML file.

Whenever you make a class, first make a div within the body tag:

  <div>
  </div>
 A div is a container. You can wrap a div around anything, and it is useful for styling everything within that container.

Give the div a class, and name it vegetables. It is good practice to name the class after its function or what it contains.

  <div class="vegetables">
  </div>
In the class, we will make an unordered list using the format shown in the next box of code. Give the list the items Carrots, Onions, and Broccoli.
  <div class="vegetables">
     <ul>
       <li>Carrots</li>
       <li>Onions</li>
       <li>Broccoli</li>
     </ul>
  </div>

If you wanted to make the list ordered, you would simply need to change ul to ol.

Next we will make another div containing fruits.

  <div class="fruits">
    <ul>
      <li>Apples</li>
      <li>Bananas</li>
      <li>Watermelon</li>
    </ul>
  </div>

Now we have two unordered lists each in a different div. We also have a class for each div. Let’s see what happens when we target these classes. Open the CSS tab. To target a specific class in CSS,m type the class name with a dot in front of it. For instance:

.vegetables {

}

Any styling in here will be applicable to the div vegetables. For example, to change the color of the text “Carrots Onions Broccoli” to blue, write:

.vegetables {
color: blue;
}

Likewise, we can change the font style to something like italic, and font size to 20 pixels.

.vegetables {
color: blue;
font-style: italic;
font-size: 20px;
}

There are times when you will want to be more specific. Let’s say you have a class but there is something within the class that you want to style differently from the rest. For instance, if you want to single out Broccoli, you can put an ID on it in HTML, as shown in the following code. An ID is meant to be used for one element only.

  <div class="vegetables">
     <ul>
       <li>Carrots</li>
       <li>Onions</li>
       <li id="least-favorite">Broccoli</li>
     </ul>
  </div>

To actually change the styling of this ID, you have to select the ID and apply styling on it in CSS. Selecting an ID is a bit different from selecting a class. The following code selects the ID least-favorite:

#least-favorite {
color: red;
}

IDs override classes because IDs are more specific. For this reason, you want to use IDs sparingly because they are harder to fix later on if you have a lot of code.

From here, why don’t we add a new list item in the vegetables div that is a link? The following box of code shows how to add links in HTML.

  <div class="vegetables">
     <ul>
       <li>Carrots</li>
       <li>Onions</li>
       <li id="least-favorite">Broccoli</li>
       <li><a href="#">Test link</a></li>
     </ul>
  </div>

In place of # you would put a link to a website.

Now in our vegetables list we have a new item: Test link. You can apply styling to this, but it is in its own tag. Thus, in CSS, you can target every a tag in the vegetables div like so:

.vegetables a {
text-decoration: none;
color: purple;
}

As you can see, you can select tags within classes. You can do the same with any other div or class.

Those are the basics of classes and IDs! A large part of learning to code is experimentation, so play around with creating more classes and IDs. For more FREE tutorials, check out our 30-minute beginners course on coding: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

Button Hover: CSS/HTML Crash Course (Free Tutorial)

Today we’re making a quick and easy button in HTML and CSS. We will look at some cool transitions that we can code to happen when we hover over the button!

If you are a beginner to coding, check out our FREE 30-minute beginners course here: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

To follow along with this tutorial, visit jsbin.com, which allows you to test your code in real time. In JS Bin, click on the HTML tab to open a blank HTML file.

The code that visitors to your website will see goes in the body of the HTML. As such, in the body tag, let’s create a button!

We can do that using the button identifier. Give the button a class. A class is something you give to an HTML element that you know you’ll want to style or do something with later. In this case, label the class “button” and name it “I am a button!”. Your line should read: <button class=”button”>I am a button!</button>.

If you go to the Output tab, you will see the button “I am a button!” with built-in styling from HTML.

You can click on the button, but it doesn’t do anything at the moment. Jump over to the CSS tab. In that file, select the button we just defined. You can do that by calling the class name we gave it. Remember that we gave it the name “button”.

To call classes in CSS, we use the following format:

.button{
}

It’s a good idea to give classes names that are descriptive to what the classes are.

Next we will do a couple of things that will change the styling of the button. The first thing we’ll learn how to do is make rounded edges for our button. In CSS, we use border-radius to achieve this. To see an example, edit your code so it looks like the following:

.button{
border-radius: 50%;
}

Instead of 50%, you can use pixels to set the roundness of your button, such as:

.button{
border-radius: 4px;
}

You will notice a shadow around the button. To delete this, write border: none;.

.button{
border-radius: 4px;
border: none;
}

Here you can also resize the button. If you resize its font, the button will expand to fit the font. The following code shows how to change the font size.

.button{
border-radius: 4px;
border: none;
font-size: 20px;
}

Another button characteristic we can adjust is padding, which refers to the space between the text and the border of the button. For instance, we can have 10 pixels like so:

.button{
border-radius: 4px;
border: none;
font-size: 20px
padding: 10px;
}

Next we can adjust the width of the button. For instance, we can make the button’s width 200 pixels by coding the following:

.button{
border-radius: 4px;
border: none;
font-size: 20px
padding: 10px;

width: 200px;
}

We can adjust the height in a similar manner. Now, when you hover over the button, it still doesn’t do anything. To modify how the button looks when you hover over it, you can use a pseudo-selector. To call a pseudo-selector, first again call the class you put onto the button earlier on a new line. Then specify hover.

.button:hover{

}

Within the curly brackets, we can code for something to happen when you hover over the button. One thing we can do is change the background color of the button:

.button:hover{
background-color: lightblue;
}

When you hover your mouse over the button, the gray inside of it changes to light blue. When you move your mouse away, the button’s color goes back to gray.

Another thing we can do is change the button’s size. For this, you can use transform in CSS. You can call several attributes on this. For instance, scale changes the button size based on the number you input. For instance, to make the button 80 percent of its original size, write:

.button:hover{
background-color: lightblue;
transform:scale(0.8)
}

If you don’t want the button to jump in size when you hover over it, you can smooth out the transition. To do so, add a transition in the initial button class.

.button{
border-radius: 4px;
border: none;
font-size: 20px
padding: 10px;

width: 200px;
transition: all 1s;
}

This means that all transitions will take one second. You can make the transition slower with 5s, or faster with .1s. A smooth standard to go with is 0.5 seconds.

Now you can change how a button looks when hovered over! Feel free to experiment with the transitions and designs of your button. For more FREE tutorials, check out our 30-minute beginners course on coding: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

Touches and Moving Sprites in XCode SpriteKit: Swift Crash Course (Free Tutorial)

If you’re designing a game, you probably need your players to move around. In this article, we’ll look at the different ways of doing so in SpriteKit. Want more FREE coding lessons? You’re in luck! We have a free 30-minute beginners course: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

To start a new project, go to File > New > Project. The template we’re using today is the iOS application, which is for the iPhone and iPad. Go to iOS > Application > Game. For Device, specify iPhone. Let’s make our Product Name “Getting started with SpriteKit”. Push Next and then Create. An iPhone app set-up will appear on your screen.

In the left sidebar, open “GameScene.swift”. Delete any excess code until you’re left with this:

import SpriteKit

class GameScene: SKScene {
override func didMoveToView(view: SKView) {

}

override func touchesBegan(touches: Set, withEvent event: UIEvent?) {
/* Called when a touch begins */

for touch in touches {

}
}

override func update(curent Time: CFTimeInterval) {
/*Called before each frame is rendered */
}
}

Let’s create a sprite! On a line below import SpriteKit, declare the variable player, and make it equal to SKSpriteNode. You can use the keyword var and the following format:

var player = SKSpriteNode?()

Next, above the line override func update(currentTime: CFTimeInterval) {, create a new function named spawnPlayer.

func spawnPlayer(){

}

To give our sprite a color and a size, we also need to add the following line within that function:

player = SKSpriteNode(color: UIColor, size: CGSize)

To set the color of the sprite, below var player = SKSpriteNode?(), declare the variable playerColor. We can give it an orange color by typing the following:

var playerColor = UIColor.orangeColor()

Below that, we can also set the background color of our display by declaring the variable backgroundColorCustom and setting it equal to UIColor. For the background to be dark grey, set its Red, Green, and Blue (RGB) values to 0.2 like so:

var backgroundColorCustom = UIColor(red: 0.2, green: 0.2, blue: 0.2, alpha: 1.0)

Note that Alpha refers to transparency. Likewise, we can specify that the size of our sprite is, for instance, 50 by 50 pixels by declaring another variable:

var playerSize = CGSize(width: 50, height: 50)

Now, back within the spawnPlayer function, we must replace UIColor with playerColor, and CGSize with playerSize.

Thus our sprite has a color and dimensions. Why don’t we also give it a position? On a new line within the same function, write:

mySprite?.position

As you can see whilst typing “position”, it is a CGPoint. For this reason, we have to set the sprite’s position equal to CGPoint. Furthermore, we can set our sprite’s position inside parentheses after CGPoint. For instance, for our sprite to be positioned in the center of the screen, add onto the existing line so it looks like so:

mySprite?.position = CGPoint(x: CGRectGetMidX(self.frame), y: CGRectGetMidY
(self.frame))

If, after y: CGRectGetMidY(self.frame), you add + 200, the sprite will be positioned slightly above the center point of the screen. Remember that X refers to the horizontal axis and Y refers to the vertical axis.

But we’re not done yet! We need one more line in our function:

self.addChild(player!)

Within the override function didMoveToView, we need to reference the background color variable we created:

self.backgroundColor = backgroundColorCustom

Also, we must add a line saying spawnPlayer().

Run the simulator, and you will see an orange square appear on the display. We’ve successfully created a sprite! Next we will add code so that the square on the display moves whenever we drag and pull it with our cursor. To achieve this, first delete the override function touchesBegan.

Instead, we will have a new one called touchesMoved. In the place of the old override function, insert:

override func touchesMoved(touches: Set, withEvent event: UIEvent?) {
for touch in touches{

}
}

Also, within the curly brackets after for touch in touches, type:

let touchLocation = touch.locationInNode(self)

player?.position.x

This will allow us to add in a touch location. As you can see in the tab that pops up when you type it, touch.locationInNode is a CGPoint. This means that we can delete the let before touchLocation = touch.locationInNode(self). This allows us to create a global variable, which we can use throughout the program. We just need to create another variable where we created our other variables, such as on a line beneath var playerSize = CGSize(width: 50, height: 50). Name the new variable touchLocation.

var touchLocation = CGPoint?()

We can now set up our code so that our touch on the screen changes the position of our sprite. In the touchesMoved function, make player?.position.x equal to (touchLocation?.x)!. As well, add the line:

player?.position.y = (touchLocation?.y)!

If you run the simulator, you will be able to move the square around by clicking on it and dragging it. touchesMoved allows you to do this. On the other hand, if you don’t want to drag it and want to have it move to where you touch the display, you can use touchesBegan. Above the touchesMoved function, type override func touchesBegan, and push Enter. XCode will auto-complete the following:

override func touchesBegan(touches: Set, withEvent event: UIEvent?) {
code
}

Now cut the following code from the touchesMoved function:

for touch in touches{
touchLocation = touch.locationInNode(self)

player?.position.x = (touchLocation?.x)!
player?.position.y = (touchLocation?.y)!
}

Replace code in the touchesBegan function with that text. Likewise, you can follow the same steps to create the function touchesEnded. When you click on the display and drag your cursor, the square will move to wherever you let go of the cursor.

 

For our next example, let’s mimic a spaceship shooter game. First off, go back to having only the function touchesMoved. Also, in the spawnPlayer function, change + 200 to - 500.

Let’s say, like in a game of this kind, we want our spaceship to be able to move left and right but not up and down. We can achieve this by simply deleting this line from the touchesMoved function:

player?.position.y = (touchLocation?.y)!

When you make big games, moveThePlayer could have 20 lines of code in it. You don’t always want to put things into your override function. They’re there to set up the functionality. They’re not meant to carry all the programming weight. Instead, since we set touchLocation as a global variable, we can call a new function in order to move our sprite. Below the touchesBegan function, you can create the new function moveThePlayer:

func moveThePlayer(){

}

As well, cut the following line from touchesMoved, and paste it into your new function:

player?.position.x = (touchLocation?.x)!

Run the simulator. You will see the sprite moving left and right when you click and drag your cursor.

There you have it! Not only can you now spawn a new player, you know how to use touchesMoved, touchesBegan, and touchesEnded to make your players move like you want them to. To keep learning how to code for FREE, check out our 30-minute introductory course here: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

Changing Background Color in XCode SpriteKit: Swift Crash Course (Free Tutorial)

Designing an application? One of the first things you need to think about is a color scheme, which includes the background color of your app. Today we’re looking at how to set the color of the display (background color) of an iPhone or iPad app. Want more FREE coding lessons? We have a free 30-minute beginners course: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

To start a new project, go to File > New > Project. Select iOS > Application > Game. For Device, specify iPhone. Let’s make our Product Name “Getting started with SpriteKit”. Push Next and then Create. An iPhone app set-up will appear on your screen.

In the left sidebar, open “GameScene.swift”. Delete any extra code until your screen looks like this:

import SpriteKit

class GameScene: SKScene {
override func didMoveToView(view: SKView) {

}

override func touchesBegan(touches: Set, withEvent event: UIEvent?) {
/* Called when a touch begins */

for touch in touches {

}
}

override func update(curent Time: CFTimeInterval) {
/*Called before each frame is rendered */
}
}

On a line underneath import SpriteKit, declare a variable using the keyword var. I like to call this variable backgroundColorCustom because backgroundColor too closely resembles a reserved word. Swift needs reserved words, such as class, SKScene, and override, in order to run code.

var backgroundColorCustom

To give our background a custom color, add onto that line until it looks like this:

var backgroundColorCustom = UIColor(red: CGFloat, green: CGFloat, blue: CGFloat,
alpha: CGFloat)

We are now able to set the Red, Green, and Blue (RGB) values for our color, as well as the alpha (transparency). Let’s say we want a dark gray. Replace the CGFloat after red, green, and blue with 0.2. Likewise, give alpha a value of 1.0.

var backgroundColorCustom = UIColor(red: 0.2, green: 0.2, blue: 0.2, alpha: 1.0)

If you prefer to use one of Swift’s default colors, such as orange, you can make your variable equal to UIColor.orangeColor(). Regardless, within the override function didMoveToView, we must reference our new variable:

self.backgroundColor = backgroundColorCustom

Run the simulator to see an iPhone display with a dark gray background. If you zoom in, you will notice that the bottom right-hand corner of the display gives you some values: nodes and fps. What are they?

Let’s find out. Exit out of the display, and open a sidebar listing your SpriteKit files. Then open GameViewController.swift, which controls which scene gets shown on an application. Therefore, if you want to change the scene, you need to edit this file.

As you may be able to tell, the reason our display showed the node count and frames per second (FPS) is because there are the following lines in the GameViewController.swift file:

skView.showsFPS = true
skView.showsNodeCount = true

To not show these values, simply add // in front of each of the lines to turn them into comments, which aren’t read by the compiler.

That is how to set the background color in XCode SpriteKit with Swift. To keep learning how to code for FREE, check out our 30-minute introductory course here: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

Introduction to UIColor in XCode SpriteKit: Swift Crash Course (Free Tutorial)

Trying to figure out how to make your iOS game stand out? Colors are a key part of game design and can make or break the difference between a game’s success and flop. In this tutorial, we’re going to experiment with colors in SpriteKit and how they can be used to make your application unique. Want more FREE coding lessons? You’re in luck! We have a free 30-minute beginners course: training.mammothinteractive.com/p/learn-to-code-in-30-minutes

To start a new project, go to File > New > Project. The template we’re using today is the iOS application, which is for the iPhone and iPad. Go to iOS > Application > Game. For Device, specify iPhone. Let’s make our Product Name “Getting started with SpriteKit”. Push Next and then Create. An iPhone app set-up will appear on your screen. Firstly, it’s a good idea to run the simulator in order to test that the project loads correctly.

In the left sidebar, open “GameScene.swift”. Delete any excess code until you’re left with this:

import SpriteKit

class GameScene: SKScene {
override func didMoveToView(view: SKView) {

}

override func touchesBegan(touches: Set, withEvent event: UIEvent?) {
/* Called when a touch begins */

for touch in touches {

}
}

override func update(curent Time: CFTimeInterval) {
/*Called before each frame is rendered */
}
}

Let’s begin placing a sprite! A sprite is a 2D bitmap graphic that’s part of a larger scene. On a new line above override func update(currentTime: CFTimeInterval) {, add in a function using the keyword func. Name the function spawnSprite.

func spawnSprite(){

}

In order to spawn a sprite, you also need to add in a variable using the keyword var. On a line below import SpriteKit, create the variable player, and set it equal to SKSpriteNode:

var player = SKSpriteNode?()

Add spawnSprite() on a line below override func didMoveToView(view: SKView) {. This will call the spawnSprite function, which will then create a sprite.

In addition, within the spawnSrite function, write this line:

player = SKSpriteNode

At the end of the line, in parentheses, you can add different items. For this example, let’s specify the color and size of our sprite. Insert the following into parentheses: color: UIColor, size: CGSize.

We’ll set the User Interface (UI) Color first. Below var player = SKSpriteNode?(), create the new variable var playerColor, and make it equal to UIColor. At the end of that line, insert: (red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat).

Editing the Red, Green, and Blue (RGB) values allows us to manipulate the color. Replace the CGFloat after red with 1. As well, replace the CGFloat after green and blue with 0.5. Alpha refers to the transparency. Give alpha the value 1.0.

We can also decide the size of our sprite by declaring a new variable. Let’s call it playerSize. Make the variable equal to CGSize. In parentheses, you can set the width and height to values such as 50:

var playerSize = CGSize(width: 50, height: 50)

Then, in the spawnSprite function, replace UIColor with playerColor. Likewise, replace CGSize with playerSize. You may be thinking: why create new variables rather than setting the specifications in the function itself? Well, if you need to tweak your values later, they will be easier to find.

As such, our sprite has a color and dimensions. How about a position? On a new line within the same function, write:

mySprite?.position

As you can see whilst typing “position”, it is a CGPoint. Thus we have to set our sprite position equal to CGPoint. Furthermore, we can set our sprite’s position inside parentheses after CGPoint. For instance, for our sprite to be positioned in the center of the screen, add onto the existing line so it looks like so:

mySprite?.position = CGPoint(x: CGRectGetMidX(self.frame), y: CGRectGetMidY
(self.frame))

But we’re not done yet! we need one more line in our function:

self.addChild(player!)

Run the simulator, and you will see a salmon square appear on the display.

We can manipulate the colors even more! Change the Green and Blue values of playerColor from 0.5 to 0.0. Additionally, change the Red value to 0.85. If we left the value at 1, we would get a standard red color. By making the value not quite 1, our color and therefore game are more unique.

Let’s also edit the background color. Declare a new variable backgroundColorCustom, and make it equal to UIColor. Set the RGB values to 0.2. Set the alpha value to 1.0. Note that these values are CGFloats.

var backgroundColorCustom = UIColor(red: 0.2, green: 0.2, blue: 0.2, alpha: 1.0)

Then, in the override function didMoveToView, write a new line:

self.backgroundColor = backgroundColorCustom

To manipulate our color further, we can add a blue. Declare another variable colorBlue. Use this format:

var colorBlue : CGFloat = 0.0

Also have:

var floatColorAdd : CGFloat = 0.0

Next, we can have the color of our sprite alter slightly whenever the display is touched. To achieve this, type the next line underneath for touch in touches {:

colorBlue = colorBlue + floatColorAdd

player?.color = UIColor(red: 0.8, green: 0.0, blue: colorBlue, alpha:
1.0)

To test the code, run the simulation. Every time you click on the display, the square will become more purple-ish.

We can actually take this concept to another level. For example, declare two new variables:

var colorRed : CGFloat = 0.85
var floatColorSubstract : CGFloat = 0.05

In the override function touchesBegan, change the Red value from 0.8 to colorRed. In addition, below colorBlue = colorBlue + floatColorAdd, type:

colorRed = colorRed - floatColorSubtract

By running the simulation and clicking on the display, you will notice the square’s changing color more rapidly from red to blue. This is because we are both adding blue and subtracting red. The ability to change color is useful when you’re a game designer because it gives you the ability to mimic nature. Just like some animals change color when they are threatened, so can characters in your game. This is just one of the many benefits of being able to manipulate colors in XCode.

To learn even more coding for FREE, check out our 30-minute introductory course here: training.mammothinteractive.com/p/learn-to-code-in-30-minutes