Developing Games on the Raspberry Pi: App Programming with Lua and LÖVE

Appendix A: Drag and Drop

The examples in this book have primarily used clicking or key presses for user interaction. LÖVE is capable of responding to other forms of input, such as gamepads, touch screens, and mouse movement.

All of the input functions are documented on love2d.org/wiki, so mostly you can use them as easily as key presses and mouse clicks. However, dragging and dropping requires more code than simple if statements.

A word of caution: dragging and dropping as the only way to interact with an application has accessibility issues. Selecting a source and a target with either a click or a series of key presses is easier for both users who need a screen-reader or have limited mobility or are just plain uncoordinated, while controlling a mouse can be difficult. Dragging and dropping also assumes that whatever device your application is running on has the ability to process a drag and a drop; while most devices today have either a touch screen or a mouse, you never know what tech will bring in the future.

On the other hand, dragging and dropping is a valid mechanic, and it can be useful for some styles of games.

Draggable object

For this demo , you need an object that you can drag. In practise, this object would be whatever game asset you want your user to move. For this example, create a file called dot.lua and create the essential attributes: the X and Y coordinates, the item rotation, and whether or not the item is currently moving.

Dot = { }

function Dot.init(x,y)

local self = setmetatable({}, Dot)

self.img = love.graphics.newImage("img.png")

self.x = x

self.y = y

self.moving = 0 --is it being dragged

self.r = 0 --rotation

return self

end

Code

The main code doesn't contain anything you haven't already encountered, it just uses concepts in a way that's new to you.

A mouse press uses collision detection to determine whether the user has clicked on a movable object. Even though there's only one movable object in this example, all movable objects are in a table, which this code calls hot . If the object that has been clicked is movable, then it is rotated as a visual cue and its moving variable is set to 1 . The love.update function ensures that the X and Y values of any moving object in the hot table are constantly updated.

A mouse release action sets the object's rotation back to its original orientation and sets its moving variable back to 0 .

Create a second file called main.lua , and add this code:

require("dot")

hot = {}

function love.load()

Dot = Dot.init(300,300)

hot[#hot+1] = Dot

end

function love.update(dt)

for i,obj in ipairs(hot) do

if obj.moving == 1 then

--DEBUG print(obj.x,obj.y)

obj.x,obj.y = love.mouse.getPosition()

end

function love.draw()

for i,obj in ipairs(hot) do

love.graphics.draw(obj.img,obj.x,obj.y,obj.r,1,1,79,79)

end

function love.mousepressed(x,y,btn)

for i,obj in ipairs(hot) do

if x > obj.x and

x < obj.x + obj.img:getWidth() and

y > obj.y and

y < obj.y + obj.img:getHeight() then

obj.moving = 1

obj.r = 0.3

end

function love.mousereleased(x,y,btn)

for i,obj in ipairs(hot) do

obj.moving = 0

obj.r = 0

end

Add any image file , called img.png to your project and test the code. You should be able to drag and drop the object around your game window.

To detect whether one object has been dragged onto another object, add more collision detection to this code to detect whether two objects are overlapping or not. It's the same principle as detecting mouse clicks.

Appendix B: Using Git

Git is vital technology in modern software development, so the more comfortable you are with it, the better. Researching Git online can be overwhelming, though, because writing software is a complex industry, and Git can adapt to nearly every development style. Learning Git in this book is useful because it limits the scope of what you need to learn. This appendix covers the Git basics that you need to follow the coding exercises in this book and in your daily computing life.

You can create a Git repository within any directory. While it is technically possible to make your entire home directory one big Git repository, it is not recommended. Logically, a Git repository is best when it has clearly defined boundaries. A Git repository makes the most sense when it encompasses a specific project or set of data. For instance, if you have set up Geany in a specific way, you could manage its configuration folder with Git; that’s not what you would traditionally think of as a project, but it has a single, clear purpose and set of data.

To create a Git repository, change the directory to the folder you want to use as the basis of the repo. In this example, the directory is called project . Then issue this command:

$ mkdir ~/project

$ cd ~/project

$ git init .

The command is git , and the option is init . The argument, a single dot, means here ; in other words, it ensures that Git initiates a repository precisely where you are currently “parked” in your terminal.

A directory is a Git repository if it contains a hidden folder called .git .

$ ls --almost-all

.git/

If you prefer to use git-cola, launch it, and then click the New button in the lower-left corner of the git-cola window. You can either select an existing directory or create a new one, and git-cola instantiates the .git directory.

git add

To add a file to a Git repository, use the git add command. This command marks a file as a trackable object for Git.

To try this out yourself, you must create a sample file. You can use Geany or another text editor to do this, if you want, but it’s also valid to use the echo command in the Bash shell. The echo command does exactly what you probably imagine: it echoes whatever you type back at you.

$ echo "print('hello world')"

print('hello world')

However, in a terminal, you can redirect anything the computer prints back at you into a file with two >> symbols. If a file doesn’t exist, one is created automatically.

$ echo "print('hello world')" >> hello.lua

$ ls

hello.txt

Create a second file called dummy.lua . It can contain whatever text you like.

$ echo "print('Dummy file')" >> dummy.lua

You have just created two files, but Git is not aware of either file because they have not been added to Git.

If you’re working with git-cola, select File ➤ Refresh or press Ctrl+R to refresh. Your files appear in the Status panel.

Tell Git to track the hello.lua file.

$ git add hello.lua

In git-cola, right-click the file in the Status panel and select Staged. The result is shown in Figure B-1 .

Figure B-1

Git add in git-cola

git commit

Letting Git track a file and actually committing a change made to a file are two different things. Adding a file gives Git permission to manage the file. Committing a file tells Git to record changes made to a file, which in turn lets you play those changes back, or rewind the changes to revert to a previous version, or even fast-forward to changes that don’t yet exist (because those changes were made by someone else on your team).

Commit your sample hello.lua file now.

$ git commit --message "created hello.lua"

The git commit command doesn’t take a specific file as an argument. It commits the current state of your repository, which includes anything you have told Git to track.

In git-cola, add the commit message to the text field in the Commit panel, and then click the Commit button, as shown in Figure B-2 .

Figure B-2

Git commit in git-cola

You can view a log of your commits with the git log command.

$ git log

Press Q to exit your Git log screen.

In git-cola, select View ➤ DAG to view your log.

Reverting Changes

Git’s stated goal is to provide version tracking. That means it lets you keep a record of all the changes made to files, allowing you to revert, or undo, a change when, for instance, some code you thought worked well later reveals a serious bug.

There are many ways to access the history of a Git repository, and in practice, you might have to search the Internet for the best way to grab data from an older version. The most important thing is understanding the basic principles of the process.

To demonstrate, you need a file that’s changed. Open your hello.lua file and change its text from hello world to hello git . If you prefer to do that in the terminal, you can.

$ sed -i 's/world/git/' hello.lua

However you choose to make the change, verify that the file has been altered.

bash-4.3$ git diff hello.lua

diff --git a/hello.lua b/hello.lua

index 3b18e51..8d0e412 100644

--- a/hello.lua

+++ b/hello.lua

@@ -1 +1 @@

-print('hello world')

+print('hello git')

In git-cola, the Status and Diff panels (see Figure B-3 ) show what has changed.

Figure B-3

Git diff in git-cola

Look at the state of your repository.

$ git status

On branch master

Changes not staged for commit:

(use "git add <file>..." to update what will be committed)

(use "git checkout -- <file>..." to discard changes in working directory)

modified: hello.lua

Untracked files:

(use "git add <file>..." to include in what will be committed)

dummy.lua

no changes added to commit (use "git add" and/or "git commit -a")

You can see from Git’s report that the hello.lua file has been modified but not yet committed, and that the dummy.lua file exists, but it is not being tracked by Git at all.

Restoring with git reset

At this point, with a file that has changed but has not yet been committed, you can reset your repository state back to the last known committed version with the git reset command.

$ git reset --hard HEAD

The --hard HEAD options tell Git to wipe the slate clean and to reset all tracked files to their state as of the latest commit. This is important to understand, because a git reset doesn’t just reset one file, but all the files in your repository. This is very efficient if you have spoiled multiple files in your repository, and you want to start from a safe place again, yet it’s overkill and possibly detrimental if you have many good changes but you only want to reset one or two files.

Confirm that hello.lua is back to its original state.

$ lua ./hello.lua

hello world

The dummy.lua file remains entirely unaffected by your reset because it is not being tracked by Git.

$ git status

...

Untracked files:

dummy.lua

Restoring with git checkout

If you only want to resurrect one or two files from your history, then use the git checkout command. The checkout option manipulates a file tree, which includes pulling a file from a previous commit into your current workspace.

To demonstrate this, change the file again and then commit the change.

$ sed -i 's/world/git/' hello.lua

$ git diff

...

-hello world

+hello git

$ git add hello.lua

$ git commit --message "changed world to git"

Now assume that you need to restore hello.lua to its original state. You can’t reset, because reset always restores the latest commit.

First, use git log to obtain the unique ID (or hash , in technical terminology) of each commit. The hashes in this example and your workspace may differ.

$ git log --oneline

42e6b85 (HEAD -> master) changed world to git

ef5288a created hello.lua

The commit you want to restore from is not the latest (the one marked HEAD, at the top of the log), but the original commit, with the ef5288a hash.

The git checkout command can take a hash and a specific file name as an argument. To signal Git that you are giving it a file name, however, you must use two dashes as a break point in the command.

$ git checkout ef5288a -- hello.lua

Confirm that your file has changed back to its original form.

$ cat hello.lua

hello world

If you’re happy with your new old file, then you can add it and then commit it back into your master timeline.

The dummy.lua file is still untouched, because it isn’t being tracked by Git.

To perform the same operation in git-cola, select View ➤ DAG to launch the Git log interface so that you can find the file that you want to restore. Once you’ve located it, right-click it and select Grab File (see Figure B-4 ), and then save the file to your drive.

Figure B-4

Restoring with git-cola

git branch

When you reach a point that involves many changes to many different files, erasing mistakes with resets and checkouts becomes complex. If there are several people working on a single code base, then resets and checkouts become nearly impossible due to all the changes constantly happening. Luckily, Git provides an infinite number of workspaces, called a branch .

When Git initializes a repository, it creates a branch named master . A branch is meant to serve as a kind of overlay, or if you’re inclined to science fiction, an alternate timeline or parallel universe. Branches let you look at the natural timeline of your Git repository and then “branch” off into any direction you think you might want to go. If the work you’re doing in a branch turns out to be less successful than expected, you can abandon the branch and return to the original master timeline, but if it goes well, then you can merge it into the master— even if the master timeline has changed since you last left it .

To test this out, first confirm that a master branch exists.

$ git branch

* master

Create a new branch.

$ git branch dev

$ git branch

dev

* master

And then switch to the new branch.

$ git checkout dev

$ ls

dummy.lua hello.lua

To do this in git-cola, select Branch ➤ Create and create a new branch called dev with all the default options. You are automatically switched to your new branch, as indicated by the star icon in the Branches panel.

Make a change to hello.lua .

$ echo "print('I am practising Git')" >> hello.lua

Confirm that your change has been made.

$ git diff hello.lua

diff --git a/hello.lua b/hello.lua

index 3b18e51..0eb0a16 100644

--- a/hello.lua

+++ b/hello.lua

@@ -1 +1,2 @@

print('hello world')

+print('I am practising Git')

Add and commit your change, and finally, add dummy.lua to your repository.

$ git add hello.lua dummy.lua

$ git commit -m "added a second line to hello.lua"

Get a summary of your dev branch.

$ git log --oneline

db5968c (HEAD -> dev) added a second line to hello.lua

42e6b85 (master) changed world to git

ef5288a created hello.lua

$ lua ./hello.lua

hello world

I am practising Git

$ lua ./dummy.lua

Dummy file

Now check out the master branch to see what your original timeline is like.

$ git checkout master

In git-cola, right-click the master branch in the Branches panel and select Checkout.

View your Git log in the terminal, or use DAG in git-cola.

$ git log --oneline

42e6b85 (HEAD -> master) changed world to git

ef5288a created hello.lua

$ lua ./hello.lua

hello world

$ lua ./dummy.lua

lua: cannot open ./dummy.lua: No such file or directory

The change that you made to hello.lua in the dev branch doesn’t exist in your master branch, and the dummy.lua has seemingly vanished entirely.

You haven’t lost your work—it just doesn’t exist in this workspace. The version of hello.lua in the master branch is the original version, before you added a second line. And dummy.lua is no longer floating around the repository; it has been added to the dev branch exclusively so that it no longer shows up as an untracked file in the master branch.

Jump back over to your dev branch again to verify this.

$ git checkout dev

$ git log --oneline

db5968c (HEAD -> dev) added a second line to hello.lua

42e6b85 (master) changed world to git

ef5288a created hello.lua

$ lua ./hello.lua

hello world

I am practising Git

$ lua ./dummy.lua

Dummy file

Generally, you can and should work with Git branches so that you always have a safe, functional code base at the core of your project.

git merge

When two Git branches have diverged, at some point you might want to merge them together. This is a common task in software development just before a release date; the development branch is merged into an official release branch, and then the update is announced to users.

When you’re ready to merge two branches, check out the target branch—the one you want to bring your work into.

$ git checkout master

$ git merge dev

In git-cola, the process is similar: check out the master branch, and then right-click the dev branch and select “Merge into current branch” (see Figure B-5 ).

Figure B-5

Git merge with git-cola

Verify that the merge has brought in all of your changes.

$ ls

dummy.lua hello.lua

$ lua ./hello.lua

hello world

I am practising Git

$ lua ./dummy.lua

Dummy file

This is a common workflow in software development: clone a Git repository, create a personal branch for yourself, do your work, and then merge your work into the master branch. When you’re finished with a branch, you can delete it.

$ git branch --delete dev

Deleted branch dev (was b5dbe64).

git push

Using Git locally on your Pi is not very different from using it with a coding website like GitLab or GitHub. The most significant difference with Git hosting sites is that you must also perform a git push in order to upload the state of your repository to your Git hosting site. For example, if you had a Git repository on GitLab for this practice exercise, the final step would be

$ git push origin HEAD

In this example, origin is the default alias for your Git hosting site, whether it’s GitLab, NotABug.org, GitHub, or any other service. In this example, the term HEAD refers to the current commit .

As with Lua, practice with Git makes perfect. It’s a big system with lots of options and many different ways to achieve many different results. As long as you commit your work often, you run little chance of losing work by mistake, and you stand a good chance of recovering work that’s been spoiled by buggy code. Understanding how Git works is what enables you to ask sensible and clear questions when looking online for specific commands.

Index

A

Android

Animation

audio

B

Battlejack

assets

bolt

bolts and updates

doors

draw function

floor tiles

hero

monster movement

monsters

rogue code

room

trap

treasure

Battlejack game

framework

menu selection

modes

pseudo code

tricks

Blackjack game

competition

C

Card.init function

card.lua file

Cards

conflict, resolving

into battle

playable

visual effects

Card table

chest.lua library

Clip art

collide function

Colormap

Color scheme

Configuration

parsing

Consistency

Creating directories

D

Debian Linux

Deck building

deck.ini file

Decks, building

for loop

game.mole() function

game.setup() function

Joker card

math.random() function

setup() function

shuffling

stacks

Desktop

explore

Desktop Navigation

icon

installing

LXQT

dnfdragora

Documentation

door.lua class

door.lua file

dot.lua file

Drag-and-drop

draw function

draw() function

E

Etcher

Even algorithms

F

F-droid

Fedberry

Fedora Linux

FG Color

Flatpak

floor.lua file

Font

Fonts

Fullscreen mode

G

game.activate function

Game and GUI logic

game.backs function

game.cleanup function

Game data

Game distributor

game.load function

game.new function

Game state

Game theory

Garbage collection

Geany

configuration

installation

Genre

basic tenants

broad themes

color scheme

font

GIMP. GNU Image Manipulation Program (GIMP)

graphics

Git

add

checkout

commit

merge

reset

restore

status

tracking

Git-cola

Git commit

Gitlab

Global variable

gmatch() function

GNU Image Manipulation Program (GIMP)

backdrop

color code and value

color scheme

exporting

images

installation

integration

layers

new document

rotate and flip tools

text element

.xcf format

GNU Public License

Graphical game creation

game code

graphics

load and loop

Lua

mouse

win/lose

package

tables

Graphics

GUI libraries

H

Head-related transfer function (HRTF)

Health points

heets

hero.lua file

hot. code

I

img.png file

inifile module

inifile

INI format

Input

io.read() function

Install

dnf

Geany

Linux

LÖVE

Lua

iOS

Itch.io

Iteration one

sample play

Iteration three

Iteration two

rule set

suggestions

J

Join string

K

keypressed() function

L

lastwon variable

Leveling up

LICENSE file

Linux image

Linux Multimedia Studio (LMMS)

Local variable

Loot

love.draw function

love.draw() function

love.first function

love.keypressed function

love.keyreleased function

love.load function

love.load() function

love.mousereleased function

LÖVE on Mobiles, limitations

love.update function

love.update(dt) function

lua command

Lua code

Lua code with LÖVE

Lua documentation

Lua, learing

Lua library, configuration

path

Lua library, installation

luamake file

Lua pratice

Luarocks

Lua script

die roll

variables

ideas

Lua scripting

Lutris

LXQT

M

main.lua file

Making music

math.random

math.random() function

menu.draw() function

menu.mousepressed()/menu.mousereleased() function

MicroSD card, disk image

Minimalism

Mobile market

monster.lua file

Mouse

click

collision detection

press

release

msg.lua

N

newQuad function

newQuad() function

O

Object-oriented programming (OOP)

OGG-File

OpenAL

Open source

os.clock() function

os.execute() function

os.rename() function

os.time() function

P, Q

package.path

Packaging

Palette

Particle effects

POSIX

Poweroff

Powerup

game.draw function

game.mousereleased function

game.setup() function

lastwon variable

mechanism

mouse click function

msg.lua

Powerup Double Draw

Programming languages

Pseudo code

R

Raspberry Pi

Raspbian/NOOBS

README file

Reset

Resolution

Rogue-like

Roguelike

definition

room.lua file

S

Save file, loading

Save states

Lua code

inifile module

os.rename() function

saver.lua

Scale

Scaling

Self

self.face variable

setWrap()

sheet:getDimensions() function

Shuffling cards

Sleep

snd directory

Sound code

Sound effects

exporting track

export window

LMMS

making music

Piano Roll editor

Sayonara player

track label

Sprites

Spritesheets

SSH

.ssh directory

SSH for Git

STATE.mousepressed()/STATE.mousereleased() function

string.len function

System configuration

System-on-a-Chip (SoC)

T

Tables

Technical documentation

online

understanding

Tile

Tiles

tonumber() method

trap.lua file

Treasure

trim function

U

UI consistency

update(dt) function

Usability

User configuration

User settings

V

vcollision detection

Versioning

W, X, Y, Z

Web browser

Win condition

winner function

Previous Chapter

14. Next Steps

Table of Contents for Developing Games on the Raspberry Pi: App Programming with Lua and LÖVE

Index

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P, Q

R

S

T

U

V

W, X, Y, Z

Table of Contents for
Developing Games on the Raspberry Pi: App Programming with Lua and LÖVE