How to Make UI Components for FlashPunk Games


Start a hosting plan from $3.92/mo and get a free year on Tuts+ (normally $180)

It's not easy to create the UI side of your game with FlashPunk, as it doesn't include any UI components like buttons or text fields by default. This isn't a restriction, though; it just means you're completely free to create the UI exactly as you like. But you need to know how to do it first! This tutorial will teach you how to build some custom UI components, and show you the different ways you can customize them to exactly fit the style of your game.

Final Result Preview

Let's take a look at the final result we will be working towards:

Step 1: Introduction

Many FlashPunk users tend to have problems with the UI side of their games. There's no 'easy' way of making buttons and other interactible-elements like text fields or checkboxes, for example, in FlashPunk. No Button class.

That may seem of a restriction, yes, and many newcomers find it a little bit confusing at first... but there's a reason behind that. Games, each one of them, tend to have a custom user interface unique to themselves, which design is related to the mechanics or theme of the game itself. You won't see any good game (generally speaking) that has the default window buttons for its controls!

We could argue that, in this case, there could be some classes providen with the bare-bones of the functionality, the minimum required for some buttons to work, and leave the graphic side to the user... yes, that is true... but the generalization we would have to use in those classes would be either too big and confusing or too specific and not costumizable enough. (believe me, I was in charge of the semi-failed semi-working Punk.UI project.) We will learn how to code our own components instead!

So what this tutorial is going to show you is how to build your own UI elements for your game in FlashPunk, give them behaviour, and show some tricks to make their graphic part with the most used techniques... but remember that each of your games will need a different UI graphically-wise!

As the tutorial is really lengthy, it's been divided into multiple parts. This first part will teach you how to build each component, without the eye-candy and costumization. We will introduce these later.

To code the example SWF with our UI, we are going to use FlashPunk, as this is a FlashPunk tutorial, and FlashDevelop for the IDE. If you feel more comfortable with another IDE, like FlashBuilder, you are free to use that, just adapt the specific parts of this tutorial.

Previous knowledge on FlashPunk is needed to follow this tutorial. This is not a general FlashPunk tutorial, this is a UI tutorial using FlashPunk. If you don't know FlashPunk, you can take a look at the Introductory FlashPunk tutorials on Activetuts+ and also check out the official FlashPunk tutorials.

Step 2: Create a New Project

Open FlashDevelop and click Project > New Project to open the New Project window.

FlashDevelop New Project Window

Choose ActionScript 3 > AS3 Project. For the name of the project, put in "FlashPunk UI". For the location, click and navigate to the folder you would like to save it into. Leave the "create directory for project" checkbox selected and click OK.

Step 3: Download the Latest FlashPunk

The Downloads page of FlashPunk

Go to the official FlashPunk webpage,, and click the Download button on the navigation bar. Then click the "Download FlashPunk" link on the top of the page. It should take you to the GitHub download webpage. Click the "Download .zip" button (or "Download .tar.gz" if you prefer that format) and save the file somewhere you know.

Step 4: Add FlashPunk to Our Project

Added FlashPunk to our project

Now that we have downloaded FlashPunk, we have to add it to our project. To do so, we will simply copy the "net" folder from the FlashPunk zip to our "src" folder in our project, like usual.

Step 5: Starting the Engine

We have to initialize FlashPunk in our document class now, so it takes control of our game, like on every FlashPunk project. We do so by making our document class extend the Engine class, and calling super with the required parameters. We will give our application a size of 550x400 pixels. Don't forget to right-click on our project, go to Properties and configure the dimensions to 550x400 pixels as well.

Setting our project's dimensions

Step 6: Creating Our World

Now, we have to create a FlashPunk World to hold our entities. We will place every UI component we create there, so we can test them. In a real-world case, each of our Menu States would be a different World, as well as the Game itself. So we will create a new class which will extend World, called TestWorld, in our "src" folder.

Then we'll tell our Engine class to go to our TestWorld on startup by overriding the init function. Don't forget to import the class FP from net.flashpunk!

Step 7: The Button Entity

The first thing we are going to build is our Button component. Every component we're going to make will be an Entity, as it's the most logical step for making something in FlashPunk which will live in a World.

First of all, we will create a new folder inside the "src" folder, to keep things a bit organized. We will name this folder "ui", and will hold all of our components.

Then we create a class there named Button, which will extend Entity. The package will be ui, as it's inside the ui folder.

Now we will add a new instance of this Button class in our World, so we can see it working... when we finish it, as at the moment it's an invisible Entity. So, add this in our TestWorld class, and don't forget to import the Button class using import ui.Button;

Step 8: Graphic for Our Button

To make our button visible, it will need a graphic. I have created an image for our Button, which you can use freely, but you can also create your own graphic if you want:

Button graphic

Save this as "button.png" without the commas in a new folder named "gfx", situated inside an assets folder which will be in the root of your project (at the same level of your src folder).

Now we need to insert this button graphic in our game. To do so, we will embed the image and then tell FlashPunk to use it as our graphic. To keep things a bit organized, we will embed everything we need in a new class called Assets. This is what I tend to do on all my projects, and it works like a charm! So we will proceed to create a new Assets class, and embed the graphic as a public static constant, so we can access it from outside:

Finally, we will tell FlashPunk to use this as the graphic of our Button. We can use it as an Image or as a Stamp. The difference is, Image will consume more memory but will allow us to transform the graphic, and the Stamp will consume less memory but won't allow any transformation at all, unless they are applied manually directly to the BitmapData. We will currently use a Stamp, as we don't need to transform the button yet. Add this to our Button class, and don't forget to import Stamp.

If you test the project now, you will see our graphic on the World, but clicking on it won't do anything. We will add some behaviour now!

Step 9: Adding Interactivity

To make an Entity respond to mouse clicks on FlashPunk, we just need to: check the mouse is over the entity and check if the mouse was released this frame. The second step is really easy, we just have to check the value of the mouseReleased variable in the Input class, but for the other, we must do a collision test between a point (mouse coordinates) and the entity, and to do so, we will need to define the entity collision. At the moment we will use a hitbox, as it's the simplest option.

So here's the code achieving all of what we just said, with an explanation below:

  • Line 15: We set the Entity's hitbox to our graphic, so it will have the same Width and Height of the Stamp.
  • Line 22: We check if the mouse position in the world we are collides with the entity.
  • Line 24: If the mouse was released this frame, we call the click function.
  • Lines 28-32: This code will be executed when the button is clicked. It will trace a click message and change the background colour, so we notice the button has been pressed.

Some of you may notice this class would perform better if we checked the mouse state first and then check the collision, but as we will have to add the hover graphics, we would have to change it back to this, so we'll leave it this way.

If you test the game now, it should look like this, but with your button graphic:

Step 10: Hover and Down Graphics

Right now, our Button is really boring, and it does not show ANY sign of interactivity, apart from its callback. It's the time to add some graphics to show the different states: normal, hover, and down.

First of all, we need to make different graphics for each, so let's get working! You can grab these two I made or simply make your own. Put them in the gfx folder with the names button_hover.png and button_down.png.

Button Hover Graphic
Button Hover Graphic

Then, we will add them in our Assets class.

Now we have to hold those graphics somewhere in our button, and switch to the correct one when it's needed. So we will create three variables to hold the normal, the down, and the hover graphics respectively, and switch the graphic properties to each of the three as appropriate.

Step 11: Fix a Little Bug

Before making the graphic behaviour, we want do something else. We need to keep track of some data which will also solve a little issue: if I press the mouse outside the button, then go to the button and release the mouse, it will detect as a mouse click. We don't want that. So we will create a new protected boolean called clicked, which will simply tell us if the mouse was first pressed over the button or not.

Then we will apply the following changes on the update function: first, inside the collision check, if the mouse was pressed this frame (Input.mousePressed) we will set the clicked boolean to true. Then, on the check for the released mouse button, we will also check for the clicked variable, so we will only detect a button click if the mouse was pressed while over it before. Finally, outside of the collision check, we set clicked to false when the mouse is released.

Step 12: Assigning the Hover and Down Graphics

For the graphics itself, we must first plan the behavior we have in mind. When the mouse is over the graphic and it's not pressed, we will display the hover state. If the mouse is over the graphic and it's pressed, we will display the pressed state. If the user presses the button and, while keeping the mouse button down, moves the mouse out of the button collision, we will display the hover state, imitating AS3's SimpleButton behavior. In all the other cases, we will display the normal state.

Inside the button collision check we also check if the mouse button is being pressed at the moment. We will check that using the clicked variable, and not the Input.mouseDown variable, because we want to be sure we show the pressed graphic the mouse has been clicked while over the button, not when clicked outside of the button and then dragged on top of it. In case the mouse is being pressed, we will display the down state, if not, the hover state, because the mouse will be over the button but it won't be pressed.

In the other pair of checks, when the mouse isn't over the button, we check first if the mouse has been clicked. If it has, we will display the hover state as we said before. If not, the normal state will be shown.

Here you can see how it should look at the moment, but with your own graphics instead:

Step 13: Checkboxes

If you think about it, a checkbox isn't really that different from a button. The only difference, apart from the graphic, is they also have a state which determines whether they are checked or not. In fact, a checkbox and a push button - which is a button that remains pressed until you click on it again - are the same.

For that reason, creating a checkbox is really easy if we know how to create a button. All we need to add is an extra variable that is toggled on each click, and with a few extra checks on the graphic changes, where we determine which version of the graphic to show: the checked or the unchecked one.

I would also like to teach you something extra as we do the checkbox. For the button, we created the graphics in different files, but what if we want all of the states in the same graphic? That's pretty simple, we just need to use the clipRect property of the Image class, as we will show when assigning our checkbox graphics.

So, as checkboxes and buttons share so many features, it's logical that we want our checkbox class to extend the button class. But, if we did that with the current code, we would have to replace the full update function to considerate our checkbox checked state on the graphics changes. Thus, before creating our Checkbox class, we will refactor our Button class a bit before, so things are easier and cleaner for us.

Step 14: Refactoring Our Button

To be able to insert the checked consideration when our graphics change, all we need to do is abstract the graphic change. So, instead of setting the graphic directly in the update function, we will call another function telling what state we want, and that function will do the actual graphic switch.

The function we will create will be called changeState, and will accept one argument as an integer, the state. 0 will mean normal, 1 will mean hover and 2 will mean down. As we could get a bit confused and forget the meaning of those numbers easily (well, not in THIS case, but this technique may be useful to you in other, more complicated cases), we will create some constants that will hold this values instead.

First, we create those constants on our Button class:

Then we substitute all the graphic changes to call our yet-to-be-created function:

Finally we create the function, using a switch statement with three cases:

Now we're ready to easily code our checkbox! But first...

Step 15: Checkbox Graphics

As we explained before, we will place all the checkbox graphics in a single file, so you can see both techniques (separate files or same files) and choose whichever you prefer.

The order of the file will be as follows: normal - hover - down; the top row will be the unchecked states and the bottom one will be the checked states. You can use your own graphics or download this one we provide. Don't forget to save the graphic as checkbox.png inside the gfx folder.

Checkbox Graphic

Now we'll add it to our Assets class so we can use it.

Finally, we will create our Checkbox class and setup the variables containing the graphics. So, first we will create the Checkbox class in the ui folder, and make it extend our Button.

Then, we will add three more variables containing the checked graphics. The unchecked graphics will be at the normal, hover and down variables we already have.

And now, we will populate them, as Images so we can clip them using the clipRect variable. This variable accepts a flash Rectangle, which is a Class with x, y, width and height properties. So, when Image sees we provide a clipRect, it will crop itself using that information. That's how it will look like in my case. You might have to adapt the values, so they fit your own graphics dimensions:

If you take a look at the code, you can see that in the end we are also assigning our graphic to the normal state, and resizing our hitbox to match the Checkbox graphics.

Step 16: Adding Our Checkbox

Now we will add the checkbox into our World and see how it looks! Add this in our TestWorld class:

Now test the project... hey, wait! Our checkbox acts just like a normal button, it doesn't check and uncheck itself! We haven't added the behavior yet, that's what we're going to do now.

Step 17: Checking and Unchecking the Checkbox

First of all, we need to create a public boolean which will hold the checked state of our Button. It will be called... oh, surprise! checked. So...

Now, we will need to toggle this variable each time we click the checkbox. The easiest way to do so is to override the click function, and toggle it, so add this in our Checkbox:

But, if we test the project, the checkbox won't change yet. We need to make one last change: make a check when setting each graphic to change it to the checked or unchecked version. To do that, we just need to override the changeState function we refactored before:

So first we check the checked property. If it's true, we check the state we just changed to, and set it to our corresponding checked graphic. Otherwise, if the checkbox is not checked, we call our Button version of the changeState, which simply sets the graphic to the unchecked state. By using the super there, we need to write less code to do the same behavior! Yay!

If we test the project, we can see the checkbox working now. It should look like this, but with your own graphics:

Step 18: Radio Buttons

If we think about it, a radio button is practically the same as a Checkbox. The only difference is, while the Checkbox is totally independent from the other checkboxes, a RadioButton is part of a group, and in that group, only ONE member can be checked at the same time, so we will have to handle that.

So, instead of making the RadioButton open and close itself, it will tell the group it needs to be checked, and the group will uncheck all of the other radio buttons, and check ours... and what's the group?

Basically, the RadioButton Group will be a special class with an Array (well, in our case an AS3 Vector) containing all the RadioButtons belonging to the group. It will also contain methods to add and remove buttons from the group.

First of all, though, we will make the graphics for our RadioButtons...

Step 19: RadioButton Graphics

We will make the graphics for the RadioButton the same way we did it for the Checkbox. You can make your own costumized graphic if you want to, but if not, you can use this. Save your graphic as "radiobutton.png" in the gfx folder.

RadioButton Graphic

Now we'll add it to our Assets class so we can use it.

After that, we create our RadioButton class which will extend RadioButton, and we'll set up the graphics the same way we did it before.

Step 20: RadioButton Group

It's time to make the radiobutton group itself now. The class will hold all the radiobuttons in a Vector of RadioButtons. It will also have the following methods: add(), for adding a new radio button, addList(), to add multiple radio buttons in a single step, remove(), to remove a radio button, removeList(), the equivalent of addList() but for removing, and removeAll(), to remove all the radio buttons from the group at once. It will also have a getAt() method, to get a radio button by the index, and a getIndex(), to get the index of a button. We won't spend much time explaining those methods, as they are basic operations for arrays.

Then, when creating a RadioButton, it will ask for a radio button group as the parameter, and it will be added automatically there if provided. Also, when removing the RadioButton from the world, it will also be removed from its group. Finally, when clicked, it won't do anything by itself but call an internal method of the group, which will be called click(). This method will uncheck all the radio buttons and check the one which called the method.

First of all, we create the group. I have provided some comments to explain a few things, but as it's only basic operations with an array, I won't explain it all:

Now, we will make our RadioButtons ask for a group on the constructor, and add themselves on it when provided:

Finally, we'll add the buttons on the world, so we can test them. We will add 3 buttons in a group, and 2 in a different one.

If you test it now, the radio buttons will still behave as normal checkboxes. It's time to change that now.

Step 21: RadioButton Click Behavior

First of all, we need to override the click function of the RadioButton, and instead of calling the code there is on the checkbox using super, we will call the still-to-be-created click function of our RadioButton group... oops! How are we going to call this function, if we haven't got a reference to the group? A simple solution would be to set a reference from the group provided on the constructor but... then we won't be able to change groups, and all of the methods we can see in the group will be useless.

What we are going to do instead is, first add a variable on the RadioButton which will reference its group, and we will set this on the added method of the group. We will also set it to null when removing the button:

Now we add this on the following methods of the RadioButton group:

And we will also set all the group references to null on the removeAll function:

Now we are ready to call the click function on the RadioButton!

And finally we will build the click function. This function will uncheck all the RadioButtons in the group, and then check the button provided.

Now, just before testing, we will also make our button remove itself from the group when removed from the world.

This is how it will look like, but with your own graphics!

Step 22: Custom Parameters: Text

What if we want our buttons to contain some text? For example, in the menu of our game, we may want to have a Play button, a Help button, etc. and we want those buttons to have some text on them, which tells which of them is the play and which of them is the help. Currently, the only way we can do it is create a new image for each of them, create a new class as well and change the image in the class...

So what we can do is accept an extra parameter in our components: the text. This will be a string we will send to our components, and then they will display it as text. Super easy!

Let's implement it in our Button now. First, we will add the parametrer text as a string, and also a label variable with type of Text, which is a FlashPunk graphic:

Then we will instantiate this text, with a size of 16 pixels and black color, with the width of the button (minus the borders), wordWrap activated and aligned to the center.

We also created an extra variable, a Stamp, which will hold the stamp of the normal graphic, so we can reference its width. We set normal graphic to the normalStamp.

Now we need to display this text somewhere. To do this, we need to include it in the graphic of our button. In FlashPunk, to display more than a single graphic at once, we need to put all of them in a graphiclist, and use this as the graphic instead. So we will do something similar, to make all of our graphics contain the text:

Finally, we will center our text vertically:

So if we add some text in the button we created in our TestWorld, we will see something like this:

Step 23: The Problem With the Text

There is a little problem with the way we are doing Text at the moment: we need to create a new Graphiclist for each graphic. This means we have to write more code for EACH graphic we have, and we can't have text on classes that extends us unless we also change that. A bit inconvenient.

So here's my solution: instead of inserting the text in our graphics, we'll just render it manually by overriding the render function.

Here's a renderGraphic function I created, which mimics the rendering of the Entity class, but accepts the graphic as a parameter. We will add this to our button:

Now we will set the graphics as they were before:

And finally we will override the render function, to render the text as well as the button graphic:

It's time to add text to our Checkbox as well! First of all, we must accept the text as a string. Then, as we want it completely different (width / height and color), we will replace the label, as following:

And, thanks to the power of extending, to have text in our RadioButtons, we only have to accept the text parameter and send it to super (and center it vertically)!

In some applications and UIs, the "hitbox" of the checkbox / radiobutton also includes its text, so we can include that with a simple line in the Checkbox class, at the end of the constructor (and in RadioButton as well):

If we add the text in our TestWorld, and test the project, we will have something like this:

Step 25: Custom Parameters: Callbacks

So now we can create different buttons with different text easily, to differentiate them... but at the moment, all our buttons do is change the background color. There's no use in having zillions of buttons if all of them... well, just change the background color. If we wanted to have different functionalities, with the current code, what we'd have to do is create a Button class for each functionality a button will do... that's a no-no!

What we're going to do instead is use a really similar approach to the text problem: we'll add a parameter for the functionality. This parameter will be simply a function. We'll send a function name to it, and when the button is clicked, the function will be called. This way we can have in our World three functions: gotoGame, gotoOptions and gotoCredits. Then, we can link each of them to the Play button, the Options button and the Credits button.

Doing this is extremely easy. We just need to accept the callback parameter, store it in our Button variables, and call it on the click function. Yay! We'll also remove the background color code.

Part of the button class variables and part of its constructor:

And the click function, only calling the callback if a callback was provided:

That's it... but I want to add an extra feature for the checkboxes. The whole point of creating a checkbox is being able to determine if it's checked or unchecked. The current way to do it is keep a reference of the checkbox in the World class, and then check its clicked property on the callback... but it's a bit tedious having to mantain references to each checkbox in our world, if we have many of them. So what we're going to do is: send a boolean parameter to the callback, with the value of the checked property. So, for the checkbox callback, we'll have to accept a boolean, the value of which will be the checked value of the checkbox. Nice!

Here's the new checkbox click function:

Remember to also ask for the callback parameter, and send it to super, as we show in this fragment of the Checkbox constructor:

And in case of the radiobuttons, I think we need a different approach. Usually, with a radiobutton, you don't want to determine the click of each individual radiobutton... what you want to do is determine which is the new clicked button in the group. That's why I think the callback shouldn't be on the button itself, but on the RadioButton group. Moreover, we also want this callback to provide information to determine which radiobutton was clicked. This can be sorted easily by demanding an extra parameter on the RadioButton: an ID, and sending that to the callback.

So, first of all, we add the id parameter on the radiobuttons, as shown in this fragment of the RadioButton constructor.

Then, we send it to the group in the click function.

Now it's the turn of the RadioButtonGroup. First, we add the callback parameter:

Then, we call it with the id provided when a RadioButton from the group is clicked:

That's it!

Step 26: Custom Parameters: Custom Parameters

Custom parameterception! Basically, let's say we have a game with 30 levels. We want to create a Level Screen, where the user can select the level they want to play. If we had to create a function to go to each level, it would be a pain... really simpler if we were able to pass the level number to the callback! This way, we assign the level number when creating the button from, possibly, a loop, and then the callback reads the number and shows us the correspondant level.

If we asked for an extra argument called level number, though, this solution wouldn't work for any other case where we need extra parameters. What we are going to do instead is, ask for an optional parameter Object. As it will be an object, it can be an int, a String, a custom class, even an array to contain multiple params... or an Object itself, in this syntax: {param: "value", param2: 1, param3: false}. This way, we can have multiple parameters which can be retrieved like this: object.param, object.param2, etc.

To implement this is really simple. We just need to ask for an extra param, called params, and send it to the callback. You should be able to do it on your own, but just in case, here's the code for Button and Checkbox:

And now the checkbox:

Now, for the RadioButton, we want the params to be in the button, but they will be transfered to the group and sent using the group callback... wait a minute! We already have something which does just like that! But it's called ID and it is a String. I think we can safely say we can change ID to params and set it to object, and we will be able to use it for the same reason as ID and as extra params as well.

Basically, we need to remove the id variable on the RadioButton and rename the param in the constructor:

Then we send the params on the click function instead of the id:

And we change the click function on the group reflecting these changes as well:

Step 27: Arcade Text Input

Text Inputs (text fields) are commonly used in games. Most games need at least one text input from the user: to set their name for the score. Depending on the game, there might be other uses for text inputs. Now we're going to learn how to make them in FlashPunk, without using the AS3 TextField.

Note that, by implementing the TextInput directly in FlashPunk, there are some kind of characters, like accents (àáèéìíòóùú) which can't be typed. If you need those, you may want to add AS3 TextFields to FlashPunk directly by adding them on the stage (FP.stage.addChild) or to the engine MovieClip (FP.engine.addChild). Those won't really be necessary if you are using English text, but other languages have them so keep that in mind.

First of all, we'll build the TextInput component. The class will extend Entity, and will have two custom properties: text, as a String, and textGraphic, of the type Text. text will contain the text inputted in the TextInput, and textGraphic will be the visual representation of it. We will implement text as a getter/setter, because when we change it through code, we also want to update the visual representation.

Now we need to check for each key and write them on the text string... or use a really helpful variable provided in the Input class! The variable is called keyString, and registers the last 100 keys that were written by the user. This way, we can retrieve the string to know what the user typed. The simplest way is to add an update function to our textField, add all the keys in the variable to our text, and clear the variable so we don't duplicate the keys we already retrieved.

Step 28: Erasing Text and Multiline Text

One thing the Input keyString variable doesn't support is erasing text. We must add the functionality by hand. But it's really easy, we just check if the backspace key was pressed, and if it was, delete a character from the string.

The problem is that this method won't erase if the user keeps the backspace key pressed. To do so, we will use a KeyboardEvent, which we will add to the stage. We will also remove the event when the text input is removed, and it won't do anything if it detects the current world is not the world the text is in.

From here, adding multiline is really simple. We just need to check for the Enter key on the onKeyDown function, and insert the "\n" character to the string:

We could even add a boolean to allow or not multiline. This way we can have the "textfields" and the "textareas". First, we add it to our variables and ask it as an optional parameter for the constructor:

Then, we just add the check to the onKeyDown function.

Now, if you add a multiline textfield to your world, this is approximately what you will see:

Step 29: Multiple Text Operations

If you try adding two TextInputs at the moment, what you're going to see is: normal characters will only work on the most recently added TextField, while erasing and new line keys will work on all of them at once. What we want to achieve is that the user can only type to one textfield at the same time.

This can be achieved easily by building some kind of "focus" system. At first, no textfield will be focused, so typing won't do anything. When the user clicks on a textfield, the clicked textfield will be focused, so typing will work, ONLY on that textfield. If then we click another one, typing will work ONLY on the newly selected one. If we then click to somewhere with no textfields, we will remove focus to the previously selected, so typing won't do anything again.

There are two simple ways I can come up with to solve this problem. One involves having a custom World class, the other involves a static variable. As creating a new world class which will have to be used in order to create textinputs is a bit of a hassle, we'll go for the static variable approach. We will have a static variable in our TextInput class, which will contain the focused TextInput. When checking for the type, we will check before if we are this focused TextInput, if we aren't, we'll simply ignore the typing. Moreover, when detecting a click on the textfield, we'll set that variable to ourselves. Finally, we'll build some system to deselect the text inputs, but we'll talk about it later.

First, we create the static variable, on the TextInput class:

Then we add the checks in the update function:

And the checks for the onKeyDown function as well:

Finally, we have to enable the selection of the TextField. We'll make a dynamic hitbox by adjusting its width and height everytime the text changes, to match exactly the text size:

Then, we check for the click an set the focus to us if there is one:

Add another textinput to the world and try to type something. Nothing will happen. Now select one of them and type, you will see typing, erasing and enter (if multiline is enabled) will work only on the selected textinput. You can switch them as well.

Step 30: Ghost Writing and Unselecting

There is a little bug in our TextInput at the moment. Open the swf, type something without having any textinput selected, and then click at one of them. Poof! A ghost has left a message for you!

Don't worry, there is no ghost. The problem is, we remove the keyString from Input on the update, only if the textfield is selected. Thus, if there's no selection, we aren't removing it, and when we select a new textfield, there's the whole last 100 characters we typed appearing at once.

Luckily, it's very easy to solve that. We just need to clear the keyString immediately after selecting a new textfield. So, on the update function, update the selection code to this:

Next thing: unselecting. To unselect, we'll make an additional check when the mouse is clicked and the TextInput was not selected: we'll check if there's any TextInput under the mouse. If there isn't, we set focus to null.

To do that, we'll set our type property. If you have used FlashPunk before, you'll know type is a property used on Entities for collision detection. Usually, when you check for collisions, you check against a type, this way you can filter collisions (for example, if you want to check collision against enemies to recude health, you will only check collisions with the enemy type, so you don't perform unnecessary tasks by checking collision with the walls as well).

In our case, the type will be unique to the textInputs, and will be used for the collision check. FlashPunk world has a method for checking if there's an entity of a type under a point. We will check if there's any textInput under the mouse point. If there aren't, we'll set focus to null.

First, we set the type in the constructor:

Then, we expand the mouse pressed check and add an else condition on the collision with the mouse check, so we'll check if the user has pressed any textinput at all when clicking the mouse:

That's it. Now, we'll add an extra feature: we'll change the color of the text if it's focused. It will be light blue if focused, and completely white if not. To do this, we just need to add these two lines somewhere in the update function:

And that's how it will look like, more or less:

Step 31: Final Demo

We're done now, we've created an extensive set of components. You'll be able to create some good game UIs with those. Here's an example of a simple pet creation application for a game, using the UI we just built:

Here is the code. The images used are available on the source download, as well as the code itself. Basically what it's doing is showing an image depending on the type selected, then hiding or showing transparent images depending on the features selected:

Step 31: Conclusion

This is the end of this first FlashPunk UI tutorial. Here I taught you how to build the components without any customization or eye-candy. In the next parts, we will learn how to customize the graphical side of our components. We'll also learn how to draw them by code directly, how to add some animation to the states change, how to add some particle fun on them, and so on.

We'll also expand the TextInput a little bit with a really needed background, and some blinking text indicator, like the real textfields. We will also learn how to make an advanced component, the Slider, which is basically a very special button. Using that Slider we'll also learn how to make a scrolling bar.

Moreover, we will improve the collision checks. We will learn basically how to detect pixel-perfect collisions with the components, so if we have a really irregular-shaped button, only clicking ON it will make it work, not its whole bounding box.

I hope you learned how to make your own UI components, and that you liked the tutorial! Leave me any feedback, suggestions, and so on in the comments below. Thanks!