Tuesday, 18 September 2018

How did I get into game development?

A couple of people have actually asked me how I got into game development in the first place, and since I've got a headache and nothing else prepared today- why not?

So probably my earliest attempt at game development took place on an old Windows 98 laptop that my dad let me use periodically. I couldn't work out how to connect it to the Internet and in retrospect I'm not sure that it was possible to even do so since it was pretty decrepit.

However, I still somehow figured out how to make little choose-your-own-adventure games in Windows Batch Script. They were really simple and mostly unfinished since I'd just start a new one whenever I got bored, but it was fun enough for a 6 or 7 year old.

After that, I found Macromedia Flash 2008 wherein I created a bunch of really bad games that basically only utilized buttons since I couldn't quite work out how to use ActionScript at the time. I uploaded many of them to Newgrounds and all of them got banned, but I also uploaded a couple on Kongregate which I guess is stuck there for all eternity. One of which is on the account I use currently, but the other is actually on another account which I can't be bothered to find at the moment.

Unfortunately, after this I kinda got demotivated with making games and resigned to playing them a bunch and I decided that I'd become a physicist, since I thought it'd be a bit more dignified and grown-up than being a silly lil game developer. Over the next few years, I began to want to become a software engineer instead, since physics became really quite tedious and I really enjoyed programming.

At some point a couple of years ago, I kinda started thinking about the fact that years of not using my creative brain had actually damaged and degraded it fairly significantly. I was a bit unhappy about that since I think some part of me still really wanted to be a game developer, so I took a bit of thought and decided that being dignified and grown-up is not actually very useful or cool or fun and it's way more cool to say fuck that and literally follow my life-long aspiration.

So this happened in about 2016 I think when I decided I wanted to get into game development. At around the same time, I also made the decision that I want to be indie. Both of these decisions were helped and inspired in no small part by my friend Magos, who made similarly tough decisions at around this time.

So I did a bit of digging around and I found the Phaser framework for HTML5 games. At this point I was extremely bad at pretty much anything that wasn't programming, and even looking back at my code around that time... YIKES.

But I did it anyway and made a few unfinished games with my boyfriend(who contributed the art assets primarily since he's a proper real artist boy), then I realized that I'm a terrible team-mate and stopped doing that pretty quickly.

The problem with Phaser is that it's not super easy to make standalone executables with it, so this means that distributing on proper marketplaces like Steam becomes quite difficult. At this point I had no hope of actually distributing on Steam of course, since this was around when Greenlight was a thing and even the best moments of my games were not very good.

I wanted to try to learn a proper visual engine like Unity, though I had my doubts about how intuitive it might be and the learning curve kind of made me hesitant. At some point, I bit the bullet and spent like 3 or 4 days trying to learn Unity. However, Unity on Linux is absolute trash so I decided fuck that I'll just use Godot.

From there I made some pretty bad small projects, some less bad small projects, some kinda okay medium projects and now I'm here- makin a pretty cool medium project.

That's pretty much all I've got so far, and I'm still not really "into" game development- I've not really got a product that I consider a proper attempt at a game. Mass O' Kyzt is the closest contender, but since that game has so many issues and silly things that I would not do the same way now, I definitely don't consider it representative of my real abilities.

Anyway, thanks for watching, and feel free to let me know in the comments what kinds of things got you into gamedev! Stay tuned for more videos about my games and things related to my games, goodbye!

Wednesday, 12 September 2018

Sporadic Godot Tutorials - Contributing on GitHub

I'll go ahead and assume that if you're watching this video, you are aware that the Godot Engine is open source via the MIT license and the source code is able to be downloaded and edited by anyone, and sometimes people will submit pieces of code to be merged with the main engine codebase, which is how most open source software works.

So basically, if you want to submit one of those little pieces of code (known as pull requests), you're gonna have to learn a little bit about how GitHub works. I'll outline basically what you have to do for any GitHub project right here:
  • "Fork" the repository.
You can think of this like a "fork in the road" type thing, where half the path leads on to your version of the codebase and the other path is the "official" version of the codebase.
  • Create a "branch" in your fork
So your repository already has a few branches. Branches are different versions of the codebase, but on a smaller scale than a fork. You will pretty much always have a "master" branch in your fork, which will usually hold the exact same code as the main repository earlier. This master branch is basically designed as a reference point for the other branches.

For example, you might create a branch called "fix-this-weird-bug". This would be based on your master branch, so most of the code would be exactly the same, but then you'd make changes to the code that fixes whatever weird bug you're chasing. Then you could create another branch that says "add-spiderman" also based on your master branch, then add spiderman... whatever that means. This means that you can create multiple concurrent changes to your codebase, so that when you create a pull request the maintainers of the original repository aren't forced to either take ALL of the changes you've made, or none of them. They can pick and choose which branch to merge.
  • Create a "pull request" from your new branch to the master branch of the original repository(not your fork, the real one!)
Basically, a pull request is a request for one of your branches to be merged with a branch in the original repo. This is pretty much the final step, it'll show up on the original repo's "pull request" list and the maintainers of the repo can either merge the pull request or close it without merging.

Phew, so that's that in a nutshell. I don't know if that made much sense to you, but I hope it did. So let's get on to the specifics for the Godot Engine.

In order to fork the repository, go to its GitHub page, and click the button that says "Fork" in the top-right corner.

 This will create a repository called "godot" under your own account name, rather than that of "godotengine". Next, we have to clone the repo. I don't know how to do this with the official GitHub desktop client, but I do know that it's very simple on the command line or with a third party client with GitKraken, so I'll be using the command line for this.

Go to your profile and click the godot repository. Find the "Clone or Download" button, click it and copy the URL.
Now, go to a terminal and type "git clone" and then the URL that you just copied. This will hopefully clone your entire forked repository into a folder named "godot".

Now, you can move into this folder by using cd or something and type "git remote add upstream https://github.com/godotengine/godot" which will make your master branch point to the mainline godot repository. This means that your master branch will keep up to date with the changes that are happening in the real repo, as long as you regularly uses the"git fetch upstream" command.

Next, go back to the original Godot Engine's repository page and look for something to do under "Issues". If you've already got something to do then just continue, but that Issues tab is the tab where all the bug reports go, so it's a nice place to hang out.

Now, create a new branch. You can do this by going to your command line, cd-ing into the folder you cloned the repo into and typing "git checkout -b fix-some-bug-thing". This creates a new branch on your fork named "fix-some-bug-thing", and puts you into that branch. You can check to see a list of existing branches by typing "git branch", and hopefully it'd give you a list of potential branches, one of them being named "fix-some-bug-thing" with a * just before it to indicate that it's selected.

So, now you can get to work doing some of that amazing programming that you're known for. Done? Good! For the sake of completeness, I'll note at this point that you can compile the engine by typing "scons platform=[windows, osx, x11]". In addition, you can add a "-j4" tag to use 4 threads to compile. This will usually make it a little faster to compile, but your computer may slow down as a result because all the processing power is being used.

If you're like me and you don't have gcc-5 installed(I could install it, but I'm afraid that I'll break something) then you can append "use_llvm=yes" to the end of your scons command, and it'll use clang instead of gcc-5, which is usually easier to install.

Anyway, if you want more on that topic there are a lot of very informative doc pages which give you more information than I'm going to here, so in the mean time let's get back to GitHub.

Once you've made all the changes that you want to make to your branch on GitHub, you can run the command "git commit -m "i fixed a bug thing, woo!"" and then "git push origin master", except make the commit message a bit more informative than that to make things easier for the other contributors. Also, if you've made multiple commits and things are looking a bit messy, you might want to rebase. I don't understand this one as much as I do the others, so I'm just going to copy and paste what Remi, one of the project maintainers, asked me to do on GitHub the last time I made a huge mess.

git pull --rebase upstream master
git push --force origin master

Once you've done this, you can go to the original Godot GitHub page, and find the "New Pull Request" button along the top. Press the "compare across forks" button just under the big "Compare changes" header, and make sure that things look pretty much like this:


It should also give you a list of changes below that box. Once you're ready, you can create the pull request with a nice snappy title and description, then it's just a matter of waiting for one of the maintainers to pop in and talk to you about your pull request- even if you've made a horrible mess, they've always been very considerate and patient in my experience. 

Also, make sure that everything is formatted properly, because if it isn't then Travis CI will throw some errors at you. Just hang around for a few minutes with the Travis CI in mind and before you know it, it'll be yelling at you and telling you to put spaces somewhere or remove spaces somewhere else.

If all of that seems a bit daunting, then you're right on track. It's taken me years to even slightly understand Git and even now, I'm not entirely sure about all of it. However, there are other ways to contribute to Godot! You can write documentation if you're not a programmer(you'll still have to use Git though), you can donate on Patreon, or any of the other things it lists on the doc pag about "Ways to contribute".

I think that one of the best ways to contribute is in fact to just make games with the engine. The more examples and support threads there are out there, the higher number of people will feel more comfortable with adopting the Godot Engine as their primary engine and the healthier the eco system will become. Again, this is listed on the actual doc page so I should probably stop talking right now before I straight-up plagiarize that whole website.

Thanks for reading, and I hope that this has been helpful. I'm aware that a lot of this already exists online in several places, but I think that it might be helpful to have a slightly less scary or daunting tutorial somewhere on the Internet, plus I mean tutorials get me a hell of a lot of clicks, am I just gonna ignore that? Yeah, I don't think so, you better believe that I'm MILKING that, baby!

Saturday, 25 August 2018

Godot - A Complete Guide To Control Nodes - Buttons

Amazing! We're back, and do I have a tutorial for you. I suspect this one is gonna be pretty popular because I mean- pretty much everyone wants to know about Buttons, so let's go!

I'm sure that pretty much anybody watching this video will use Button nodes at some point in their gamedev experience with Godot. If they don't, then that's strange but they probably should.

So let's move onto the big old Node tree and take a look at what's going on- you might notice that all of the Button nodes are actually children of this unselectable "BaseButton" thing. This is exactly what it sounds like, it's an uninstanceable class which aggregates all of the core behaviour for all of the button Nodes in the engine.

Looking at the documentation, that includes things like some methods like _pressed(), _toggled(), is_hovered(), etc. These are things which every button should have, and you will be able to call on any button. It's pretty easy to figure out what each of these do, so I won't go into much detail on them.

Also, every Button node you encounter will have a few SUPER helpful signals- button_down(), button_up(), pressed() and toggled().

Again- these are very self-explanatory, but they're super helpful. Basically, I would usually put all of the button-press logic into a pressed() callback, and then you can set the "action_mode" to determine whether to emit that signal when the button is pressed down, or when it's released. This just gives you a bit more freedom to make changes later on should you change your mind about the way the button works, so I'd recommend it.

So anyway, let's create a proper Button node and investigate some of this stuff. First, let's take a look at the inspector category known as "BaseButton". The first few properties here are pretty easy to understand, there's "Disabled" which when activated will make the button not clickable and in the case of a normal Button node, it'll also make it greyed out.

There's "Toggle Mode" which basically determines whether or not it's a button that you press once to enable, and press again to disable. Kind of like a check-box kind of thing, if you want that then enable the "toggle mode" property but if not then just ignore it and you're good.

"Pressed" is pretty self-explanatory, but you're probably not gonna be adjusting this one from the Node inspector. Chances are, you'll be using that one in some if statements- like if(button.pressed): do a thing.

I briefly mentioned "action mode" earlier, and it basically determines whether or not the "pressed" action happens when the mouse is pressed down on the button, or whether the mouse is released from the button after pressing it down. This is set to "button release" by default, and for most UI or menus I generally leave it that way. However, you could change it if you feel like it.

"Focus Mode" determines whether or not this button is allowed to grab focus, and if so- how. By default, it's set to "All" which means that you can use the arrow keys or the mouse to select it, much like how we did in the first video in this series when I was demonstrating the "neighbours" stuff under the "Focus" category.

"Click" means that you can't use the arrow keys to select this button and you have to click it manually with the mouse, and "None" means that you just can't focus this button.

Now this one is pretty cool and I'm just waiting for an excuse to use it, but you can set a "Shortcut"- this means a keypress that will automatically press that button. So you could make a new shortcut, create a new InputEventKey and you can look up the scancode to the button of your choosing. This makes keyboard shortcuts SUPER easy to work with.

Also, you can set the "group" of the button. You can't really set this one in the inspector, but in a script you can create a new ButtonGroup object which you can then assign to multiple buttons. This means that at any given time, only one of the buttons in the group can be pressed. It's kind of like radio button selections on a webpage.

So now onto the specifics of this "Button" node, since the things we just covered are applicable to any button- they're all members of the "BaseButton" class.

The first property to notice is "Text", which is pretty easy to deal with, if you want your button to say something then you can type it in here and it'll show up on the button.

There are a few other properties that relate to this text like "Clip Text", which will stop the text from leaving the bounds of the button and "Align" which will designate how the text is aligned.

"Icon" allows you to set a nice little image to appear on the left hand side of the button, or if you don't have any text, you can just shrink the button to make it appear in the middle.

Also, you can set the "Flat" property which just changes the style of the button a little bit, by making it not show up by default.

So, now onto some of these simple button derivatives- first of all the CheckBox. This one is literally just a checkbox and is generally used in combination with some text next to it and some other context.

Next, there's the CheckButton. This is functionally identical to a checkbox, but instead of a literal checkbox it actually has a little switch which you can set as "on" or "off".

Now there's the "ColorPickerButton" which is pretty useful. It basically allows you to select a colour using preset Godot UI stuff just by creating the node. From there, all you have to do is connect the "color_changed" signal, and access the "color" property that it has. This makes things like character selection super easy- if you don't mind Godot's built-in UI too much.

Next, there's the "MenuButton". This is kind of like a dropdown menu type thing, if you click "Scene" at the top it'll produce a bunch of options- at the moment, we haven't really set this up. However, when it clicks it creates a PopupMenu and you can see my last video to get a sense for how to make that work. You can use the "get_popup()" function on it to get the PopupMenu node for all your GDScript customization needs.

There's also the super useful "OptionButton", which is again a node that mostly requires customization via script files. You can add items and link the "item_selected" signal to a script of your choosing in order to determine which one got selected. It's not super complicated to use, but yeah- just play around with it.

Now for the one that I use probably the most(excluding the TextureButton), the ToolButton. It's literally identical to the normal Button node, except it automatically sets itself to flat. That's it.

Now there are only two buttons left, and they're both pretty useful. The first one is called a LinkButton and it's just like when you have a hyperlink on a webpage. This LinkButton is functionally exactly the same as any other button with the signals, etc- it just presents itself as a hyperlink.

Then the last one that I definitely use the most, the TextureButton. Again, it's functionally identical as a button node but it takes in several textures instead of relying on Godot's own user interface style stuff.

It has an "Expand" property which basically determines whether the texture should expand to the full extents of the button size. This is in combination with the "stretch mode", which determines how it expands- whether it tiles, whether it stretches, or whether it keeps itself centered and a bunch more options. Generally speaking, I leave this disabled since I make my textures in something like Aseprite and only load them in via the TextureButton to be displayed at the size I designated in my sprite editor.

But the point is yeah, this is a pretty useful node. You can even set a click mask if you don't want the entire Rect to be able to be clickable. Just load in a bitmap with white as the clickable area and black as the non-clickable area, and then Godot will automatically do the rest. It's super useful for making curved buttons, or buttons that are smaller than your TextureButton Rect for whatever reason.

And there you have it, that's pretty much it for Buttons. As always if you have any further questions then feel free to leave a comment, or join my Discord and ask me there- I'm usually quite happy to be distracted from whatever I'm doing so feel free to make use of that. Anyway, thanks for watching and stay tuned for more tutorial videos because apparently you guys LOVE them, I'm getting so many subscribers it's literally the best thing that's ever happened to me. Anyway, I guess next time I'll do Containers- which is a slightly bigger and significantly more scary topic. I might have to segment that one into two or more videos, come to think of it but whatever. Just enjoy what I've done so far!

Sunday, 19 August 2018

Godot - A Complete Guide To Control Nodes - Popups

So, here we are- part 2, which some of you seriously nagged me for you pests.

Anyway, as the title would suggest, let's get into Popup nodes. These are a lot more straight-forward than the messy stuff that I covered in my last video, so let's get going with the base "Popup" node.

You might notice that when you create it, it doesn't actually have any fancy graphics of its own. That's because it really only exists to hold some logic that is utilized by the rest of these popup nodes, but if you want you can add your own logic as children in Sprites, Labels, or whatever you want to put there.

So I'll add a Label as a child of the Popup node just so I can demonstrate some of the behaviour that the Popup node implements. I'll add a built-in script here, too.

I'll also add a simple ToolButton next to our Popup node so that when we press this button, some code will be executed, and we can change this code a few times to demonstrate a few different behaviours.

So by default this Popup node is hidden, unless we call a function specifically to reveal it, which is usually the "popup()" function. If we press the ToolButton with "popup()" in the callback, then as you might expect, it'll reveal the node, with the Label.

There are a few other functions to call here, "popup_centered", "popup_centered_minsize", and "popup_centered_ratio". It'll probably be easier to demonstrate these with some of the other Popup nodes we'll be looking, so I'll wait until then.

The next interesting thing about this node is that it has a VERY useful "about_to_show()" signal that you can connect. This does exactly what it sounds like, and will run the code that you place into the callback right before it shows the popup. This is useful for generating or changing data at the last moment in a nice and clean way, that ensures that you won't open it with old data showing for a moment.

There's also a "popup_hide()" function that is fairly self-explanatory- whenever you hide this popup, it'll emit this signal.

So that's about all for the base Popup node, let's move onto the more interesting ones- starting with WindowDialog. As you can see if you forcibly reveal the WindowDialog node, it has a nice little body, title bar and an "X" to hide it. This is useful if you want to use Godot's default UI, but you can use StyleBoxes to change it up a bit.

So similarly to our base Popup node, this node is hidden by default. Even if you reveal it in the editor and load up the scene, the Popup will still be hidden by default. So we have to call "popup()" on it to make it visible, which we've already got set up using this ToolButton.

So let's look at some of the other functions that I said we'd explore with a more interesting Popup node. First, let's do "popup_centered()". This one will center the node in the middle of the screen, and it's pretty useful. This means that even if we move the Popup node way off-center, it'll still appear in the center when we run this function.

Next, we have "popup_centered_minsize()", and this does the same as above but it takes in a Vector2 quantity for the minimum size of the Popup. I'm not entirely sure why this is useful but in case you wanted to implement that functionality easily, here it is.

Lastly, there's "popup_centered_ratio()", which scales the Popup as a ratio of the size of the screen. This means that it'll appear at the center of the screen, and whatever float you pass via this function will be the proportion of the screen that it'll take up on each axis, relative to the center point. So this means if you input 0.5, every edge will be half-way between the center point and the corresponding edge of the screen. This is very useful too.

So, let's move onto another Popup, and you might in fact notice that there is a child node from the WindowDialog node called AcceptDialog. That's right, we've got another layer to go down! This one is super simple, it basically gives you a pre-defined layout for an "OK" button, a little Alert message and it even gives you a bunch of really helpful signals and methods.

Let's start with the signals, since those are straightforward- "confirmed()" will emit whenever the "OK" button is pressed, and "custom_action()" will emit with the name of the action as an argument whenever we perform a custom action. I'll explain what this means now.

So there's a pretty rad method in the AcceptDialog class called "add_button", which allows you to literally add a button to the AcceptDialog using one line of code- it takes in the text to display on the button, where the button is placed(right or left), and the designated name of the action that you want to bind to this button. So you could bind an action named "explode", and you'd use that "custom_action()" signal that we mentioned earlier to run some code to actually explode something.

But in case that's too annoying for you and you want things to be even easier, there's an even more helpful function called "add_cancel", which just takes in the text to display as an argument and will add a button that hides the AcceptDialog without running the "confirmed()" signal.

So that's pretty nice and I think all you need to know about the AcceptDialog, so let's move onto the next Node.

What's this? AcceptDialog has a child of its own?! That's right, it goes one layer deeper and now we're dealing with ConfirmationDialog. This one is super simple though, as far as I'm aware it doesn't implement any new functionality- it's basically just an AcceptDialog with a "Cancel" button already there.

So let's move on- but wait. Something's not right. You're telling me that there is ANOTHER LAYER to this one?! Yup, I sure am telling you that. We've still got FileDialog to deal with and this one is a little bit more complex. This actually allows you to navigate your hard disk directory stuff and select a file, which is super neat to have already implemented by the engine.

There are a few properties to look at here, the first of which is "Mode". By default, "Mode" is set to  "Save" which means that it'll behave as if it's trying to save a new file. This means that if you select an existing file and click "Save", it'll give you an "are you sure you want to do this?" dialog box.

There are also a bunch of "Open" modes- you can open a folder, you can open a file, many files, or "open any" which I'm pretty sure allows you to select either a folder OR a file.

Next, there's the "Access" property which does do pretty much what it sounds like, it designates what sort of file this FileDialog should be allowed to access. As far as I'm aware, allowing it to access Resources will break it when you try to export, so you can't do that. User data and file system should be fine, so I'd recommend that you use those.

You can add some filters for things like filetypes, if you only want the user to be allowed to select .pngs or something then you can do that super easily.

Similarly, you can opt to show hidden files(though that might be a bit buggy on Windows, weird permission stuff) and you can set the current directory, etc, etc.

None of that is super complicated or unintuitive to use, I'm sure you'll get the hang of it. Likewise, FileDialog implements a few signals- "dir_selected", which passes the path to the directory, "file_selected" and "files_selected" which both pass a String or array of Strings when they're emitted.

Phew, so that's done.

Now we can move onto the next one, PopupDialog. This one is super simple, it's literally just the base Popup node with a panel underneath that corresponds to the size of the Popup. That's genuinely all it is. Easy.

The next one is PopupMenu, which is a little bit more involved. It's basically a context menu, so if you right-click on something and you want the options like copy, paste, select all, etc- that kind of thing, you'd be using the PopupMenu to implement that functionality. The properties are extremely straight-forward, and honestly the signals aren't very complex either- "id_pressed" and "index_pressed" which basically both just exist to point to whichever option was selected here.

There are a bunch of functions here, and a lot of them look pretty confusing at a first glance if you're reading the documentation, but honestly most of these are not complicated or hard to understand. A lot of them are referring to specifics about each entry type, like checkboxes, radio checkboxes(which are the ones where you can only select one option at a time), there's just an item you select and it disappears again, etc. It'd take me way too long for me to step through each function and tell you what it does and you'd probably get bored half way through so I'll leave you to learn what they do on your own. If you have any questions then feel free to ask but I'm confident that you can work it out easily enough.

And lastly, PopupPanel is basically the same as PopupDialog as far as I can tell, so don't stress about that one.

And that is it, I've covered in reasonable detail all of the Popup nodes. You guys asked for it, and I delivered because I'm just that kind. So yeah thanks for watching and stay tuned for more tutorial videos, I guess Part 3 would be on the topic of Buttons- quite a nice topic, I like Buttons, I use them a lot.

Goodbye!

Thursday, 16 August 2018

Gamedev Livestreams - Is It Worth It?

I'm sure a lot of you know that I've opted to start livestreaming regularly over the past few weeks. This has kind of been an experiment into whether this is actually a worthwhile endeavour and for me, I can confidently say that it is.

So, here are the advantages to regular livestreaming.

First, it helps to keep your game on the minds of people who follow you. If they see that you're constantly working on a game and they only click it once every week, that's still effectively an ad-spot that you have on their YouTube homepage for free.

Also, for me personally it helps to seperate "casual computer usage" time with "work computer usage" time. Frequently when I'm working I'll get distracted or fail to concentrate and this has been a problem that I've had for kind of a while. However, when I'm livestreaming and actually broadcasting my computer monitor to anyone who is watching, it stops me from just checking Twitter one more time or browsing reddit for a little bit or playing just one more round of Enter The Gungeon- oh wait, it's past 6pm, I guess I'm done working today!

With livestreaming, my brain can easily recognize that this is not the time to start messing around and I actually need to focus and do some work for my lovely viewers.

Another thing is again- personally to me, but I love seeing numbers go up and I love high scores. This means that when I stream, the time I spend streaming is effectively a score that I want to keep high or to beat each day. I don't know how many other people get this but I know that I certainly do feel the need to keep streaming if only to see the number go up, which ultimately means that I put in more hours working each day.

Also, since I am actually working and concentrating, time tends to go by fairly quickly, which gives me a nice dopamine rush if there's a 45 minute difference between the last two times I looked at the clock.

ANOTHER reason why livestreaming is cool is that it gives me a nice excuse to talk to other game developers. Since my throat and jaw tend to start hurting if I do go for 4 hours narrating everything I do, I tend to talk to other people like Florian Himsl of GameSquid or Collin Esplin... also of GameSquid. Either way, it's fun to talk to people and sometimes it keeps them motivated too.

The last big reason why livestreaming is great for me is because I already have a bank of just under 900 subscribers who are alerted every time I livestream so I'm guaranteed a few viewers each time, and as for the big reason-

YouTube algorithms.

YouTube tends to favour content by channels which 1) upload content on a regular schedule, and 2) upload as much as possible and 3) have high watch time. If I create daily content (in the form of a mix of livestreams and actual videos), YouTube will recommend my channel more and more. So far I've been seeing significant success with this, and it's fairly easy to livestream for a couple of hours even on days when I don't really want to.

If I don't want to or am not able to livestream, then I've got a big bank of video scripts just waiting to be recorded and uploaded on that day instead.

Also, due to the very nature of livestreams if like an average of 5 people are watching a 4 hour livestream, that's 20 hours of watch-time just there. If 200 people see a 3 minute video that I release, that's only about 10 hours. This means that livestreams inherently bring in large quantities of watch time.

So ultimately, livestreaming is hugely advantageous for growing my YouTube channel which for me, happens to be my main marketing platform.

So what are the cons?

Well, if you don't have an established viewerbase then you might only get a small number if any viewers. It sounds super difficult to actually make a viewerbase from livestreaming, since usually I pretty much cap out at 10 concurrent viewers and 50-70 total views on the livestream. The truth is that actually gaining a following in livestreaming is really, really difficult and it's much easier to create a few successful YouTube videos to boost your audience and livestream ALONGSIDE a healthy YouTube channel.

Also, it has the potential to distract people who are easily distractable in such an environment. I'm lucky in that most other people don't tend to distract me very easily and I can keep focused even when they're off talking about Tetris or whatever weird topic they decide to start talking about. However, I know that some people really aren't able to do this at all.

It can also eat up a huge quantity of your time. If you have a full-time job, you're well within your right to just be way too exhausted at the end of the day to livestream for another few hours. It is tiring and you need to have a certain baseline of energy to keep your viewers entertained by constantly having somebody talking at any point in time.

Also, some people just don't enjoy narrating what they do. Some people don't like talking. I wouldn't have started a YouTube channel to begin with if I didn't like talking, so again- this is pretty well suited to me, but I don't speak for everyone and I've seen some people on reddit and Twitter actually express disbelief that anybody could livestream such a thought-intensive task as programming or game design in general.

So that's pretty much it, if you've got any questions then feel free to ask me because I'm sure I've not covered everything in this fairly comprehensive topic, but yeah. Thanks for watching and stay tuned for more livestreams for reasons that you can go rewind and listen to all over again. Goodbye!

Sunday, 12 August 2018

Godot - A Complete Guide To Control Nodes - Part 1

This is potentially my most ambitious video yet, so hear me out. If you've ever been confused about Control nodes, hopefully this will even things out a little. I'm going to explain Control nodes in as much excruciating detail as I possibly can.

Basically, Control nodes are super useful for all things that are to do with GUI, so things like menus, HUDs, etc.

So, let's start with the base node, just named "Control", and let's talk about how it's different from the much more straight-forward Node2D.

Node2Ds have a category called "Transform" which holds all of the data for where the node is positioned, how it's rotated and how it's scaled. Pretty simple stuff.

Controls however have a category called "Rect" which deals with all of this, and it's a little bit more convoluted. They do have a position property, a rotation and a scale property, but they also have size properties, pivot offset and clip content.

That's because whereas a Node2D is effectively a marker for drawing 2D graphics, a Control node is an organizational thing for UI elements, so it's actually a box. A Node2D behaves like a point with some Transform values, whereas a Control node is a little rectangle with stuff in it.

It's also worth mentioning that you can't position Control nodes at fractional positions, they'll automatically snap to the nearest pixel. I don't know why this is, but that's the way it is, so I guess deal with it.

Now for the really scary stuff and the thing that prompted me to even make this video, Anchors and Margins.

Basically, this whole system ensures that no matter the screen size, GUI elements will always be in the correct positions. Anchors do this by "anchoring" a Control node to its parent object. If the Control node is the tree root node, then its parent should be a Viewport.

So basically, under "Anchor" there are four properties - "Left", "Top", "Right", and "Bottom". These each refer to edges of the Control node's Rect, relative to the parent. They all take in values from 0 to 1, which represent what percentage along the parent rect size to put each edge.

This is relative to the top-left corner, so if you wanted your control node to alway stay in the top left, you could put "Left" to 0 and "Top" to 0. This means that the Left and Top edges are both 0% along the screen at all times. If you wanted to make the bottom-right corner extend exactly to the center of the screen, you could make "Right" and "Bottom" both 0.5, which would place the Right and Bottom edges precisely 50% along the screen at all times.

So this is super useful to make UI elements proportional to the screen, other UI elements, etc. So what does Margin do?

Well, Margin is basically offset. If you want to offset your shape by a factor of 100 in the x axis, all you have to do is set the "Left" and "Right" values to 100 and it'll move those edges away from the left-hand side of the screen by that amount. However, a warning: these values are absolute, so that means if you shrink the screen below the offset value your elements will probably disappear off the side. I would hesitate to over-use Margins, since it can undermine the whole purpose of using Anchors in the first place.

You can also use margin to actually change the size of the Control node that you're using. So if you set the Left margin to -100 and the Right margin to 100, it'll move the Left edge 100 pixels closer to the left-hand side and it'll move the Right edge 100 pixels away from the left-hand side. This is probably useful for something.

So that's arguably the scariest bit explained, now onto another fairly scary bit- Grow Directions.

So basically, as the name would suggest this is to do with the direction your Control node is expected to grow. If you set both the Horizontal property to "Begin" - as it is by default - you might notice that when you attempt to adjust the Right Margin, it stops changing in size once the size gets to whatever its minimum size is.

However, if you adjust the Left margin and try to shrink the shape horizontally as much as you can, you'll notice that rather than just deny any new growth it'll start to just move instead.

This is because the Control node is effectively ready to start "growing" from the left-hand side if you set Horizontal to "Begin". Think in terms of a Label that's holding a line of text. If you start typing, it should expand away from the left-hand side.

I'll be honest here I'm not sure I entirely understand this bit but it doesn't seem essential so I guess my advice to you is just leave this to "Begin" because otherwise demons and evil spirits will haunt you until either you die or you stop worrying about Grow Directions.

Now for something which is awesome but not as terrifying as the previous stuff, the Focus section!

This is to do with stuff like if you press the tab key, or you want to use the keyboard or a gamepad to navigate menus, stuff like that. If you don't want to deal with this then Godot does actually automatically figure out some of this stuff, but it's not perfect and it frequently gets a bit buggy and confusing.

This category is designed to allow you to manually set which button or node to focus if Godot's messing up or you want to move to somewhere that Godot can't really predict. It's super easy, basically if you select a Button you'll get some "Neighbour" properties named "Neighbour Left", "Neighbour Top", etc.

You can set these properties to point to a node that you want to focus on when the player presses the associated direction on either a gamepad, arrow keys, etc. The Next and Preivous ones work in a similar way, if you haven't explicitly defined any Neighbours but you just want a one-dimensional list of buttons to cycle through for example when the player presses the Tab key, then you can set Next to whatever you want to come next if the player has got that button focused but wants to focus another node.

It's super simple, but a super intuitive way to setup keyboard controls for menu systems.

As for the mouse bit, this describes how the given Control node handles the mouse cursor interacting with it. Imagine that you have two buttons on top of each other, so that one is completely blocking the other. Normally, these would both have the mouse filter set to "Stop" which means that if it receives a mouse event, it'll "block" any item below it from actually receiving that event.

However, if you set the button on top's mouse filter to "Ignore", it'll completely ignore the mouse and you'll be able to click on the button below. This might be useful if you want to hide a button from being interacted with temporarily and for whatever reason setting visibility isn't suitable at that time.

Also, you can set the "Default Cursor" that appears when the user is hovering over the button. It's super easy to use but basically you get a big list of potential options which the cursor will turn into when the button is moused over.

Now for the Size Flags, which I've only ever used with respect to BoxContainers or GridContainers so I guess I'll carry on that traditionand only even teach it with respect to Containers.

From what I can tell, it's a little bit buggy and unpredictable but the important things to note are that Fill makes it take up as much room as possible, but sometimes you need to enable Expand too and I don't know why. Sometimes when you enable Expand once, then disable it, then disable Fill, then re-enable Fill it'll also Expand the node to fill up as much space as it can, for some reason.

You can also use Shrink Center which will sometimes center the nodes in the BoxContainer or GridContainer and keep them at their minimum size, but only if they're really feeling like it. If they're having an off day, then they won't.

This explanation sucked but just press them randomly until you get what you want, they're not that important to understand I guess. If you have a better understanding of these, then please let me know.

As for Styles, again, if you have a good understanding or usecase of these then be my guest but custom styles seem remarkably pointless and difficult to use compared to making panels, buttons etc manually in a sprite editor.

So I guess I've explained the essential components of Control nodes, now I'll get into some more specific instances of Control Nodes, starting from the top, which would be the Popup nodes. Thanks for watching and stay tuned for that in Part 2 of this series that apparently I'm doing now. Goodbye!

Godot Is PERFECT For The Ludum Dare

So it's Ludum Dare 42 in about six hours at the time of writing and I've decided that I'd write a little script about why I think that the Godot Engine is perfectly designed for game jams like the Ludum Dare.

Mostly, this is because Godot is just perfect for very small iteration cycles. If you have a solid idea in mind, you can spend probably no more than a few hours to actually get a very basic product up and running.

This means that if you really wanted to, you could run through several different ideas over the course of a day to determine which of them you like the most. Not that I'd strictly recommend doing this, since y'know- time constraints are time constraints, but in case your first idea doesn't pan out so well it's nearly trivial to try out another one.

Also, the engine is super light which means that an average game made in the Godot Engine will only use up about 20 to 30 megabytes. This makes it much easier and convenient for people to actually play your game, although I will admit that the web export system is a little bit hit-or-miss. Usually it'll work great, but sometimes you can run into problems that might warrant encouraging the user to run the downloadable version instead.

Also, here's a personal favourite of mine- particle effects. In short, it's *really easy* to make something look a certain base level of good if you just overload it with particle effects. It's similar to reverb in songs- you might not get very far if you don't know what you're doing, but if you're really clueless or just in a hurry then it'll work out great for you.

Godot is great for particle effects, they run super nicely (even if you're trying to render about 10x more than you should) and the actual particles editor is honestly amazing. If you need proof, then you should know that in my game WARP-TEK which is currently being shown on screen, pretty much all the graphics are based in Godot particle effects in some way or another.

In combination with that, light effects. Creating and adding lights are very trivial and again- they look awesome even if you don't really know what you're doing. These can get a little bit expensive if you have too many so just be careful of that, but as long as you're not creating like 25 of them on the same exact location, you should be good to go.

Also, Godot is excellent for keeping things organized- especially with small projects. In a game jam situation, you're probably not going to want to have spend a lot of time trying to work out what this weird variable does, or where you called this function from. With a combination of signals, multiple distributed script files and the occasional recursive egrep, it's pretty hard to go wrong and get too confused.

Now this last point isn't really in the same category as the others, since I would say that it primarily deals with why game jams are perfect for Godot, rather than the other way around. Godot is a fairly small engine in terms of community and publicity. Unity and Unreal are both backed by astronomical marketing budgets, whereas Godot pretty much only has word of mouth and a Patreon page.

If you really like the Godot Engine and want it to see some extra consideration from other developers, then I'd recommend using it for this upcoming Ludum Dare. Hell, even if you've never used it before- a game jam is a perfect time to try out a new engine in a low-stakes environment. It's good for your skillset and it's good for the engine if more people use it.

Thanks for watching, best of luck in Ludum Dare 42, and stay tuned for more videos about some things which video games are sometimes a part of. Goodbye!

Wednesday, 1 August 2018

The Dark Side of Rapid Prototyping

As many of my viewers might be aware, my engine of choice (Godot) is very suited to rapid prototyping.

It's very quick and easy to program most types of game logic and usually, actually prototyping something will take anywhere from 1-4 days of full-time work. This is awesome compared to heavier programs like Unity which are a bit more technical and in-detail even when that's not what you're looking for, but that's a topic for a different video.

However, it's also very easy to prototype WAY too much. I know this because a little while ago I temporarily burned myself out prototyping like mad for a month, and then had to take a month off of YouTube and gamedev.

This was partly because I had a bunch of exams, but forcing myself to continue with that stuff even when I hated thinking about it would have put too much strain on my ability to properly revise and prepare for exams.

For context, I made about ten prototypes of games in about 20 days. Needless to say this was just too much and to not make any real progress or not make anything that I can actually say I'm proud of in that time was pretty instrumental to burning me out. I didn't make really any cool graphics or programming tricks or ANYTHING that was actually cool, it was basically just a new layout of buttons and keybinds every time.

That's kind of the problem. I frequently say to people who are looking to avoid burnout that they should maybe not leave graphics right to the end unless graphics are really intensive to create, at which point they probably shouldn't be making the graphics so intensive to begin with. If you don't have something you can look at and feel good for having made, it's going to take a toll on your brain after a while.

That's why with my current game, WARP-TEK, I basically made all the sprites right as I was implementing the entities and even though I had to basically bleach them and apply some cool colour aesthetic, I was still working through the visual aspect at the same time. This keeps me motivated and excited to keep working on this game. Maybe I'm just a particularly visual person, and some people don't value these things as much as I do but I can say from the bottom of my heart that nothing helps me to avoid burnout like creating tangible assets that I'm proud of alongside programming.

Also, it helps with your early marketing if you've got some flashy graphics or a catchy tune to go along with your game from early on, since most consumers also won't care about "woah look at this crazy level generation algorithm".

But either way, what's the point of this video?

If you're making a prototype, you're trying to determine whether the game is worth pursuing. Remember that you're not just trying to make a really rubbish, stripped-down version of a game, you're trying to think about whether or not it's worth even continuing.

Sometimes it's a good idea to create assets alongside prototyping if it helps you to determine the value of the game idea. That's basically the advice.

I didn't create any assets I really liked when I was stuck in prototype hell, but when I came back I made a prototype with a few assets I kind of liked the look of and it motivated me to make the prototype into a full game, which is now known as WARP-TEK. It's better to make sprites too early and have to re-make them than to put off making sprites until your project dies anyway.

Thanks for watching this poorly scripted mess, but if you actually gleaned some useful information from this then I'm simultaneously glad and impressed. Stay tuned for more tightly-scripted videos, in the future, trust me, I promise. Goodbye!

Tuesday, 31 July 2018

What is and isn't an "Asset Flip"?

Judging by the discussion I've seen on the Internet as of late, I've seen a lot of conflicting definitions of what "asset flips" actually are, and what they are not. Such a seemingly simple and straight-forward concept actually has a lot of nuance and subjectivity built into it.

So first, let's work out where the term "asset flip" comes from. It was coined by Jim Sterling in his Jimquisition video appropriately named, "The Asset Flip". The term is based on the sleazy business practice of "flipping" wares for profit, most commonly houses and cars.

Specifically, flipping, say, a house would involve buying it at a low price from someone who wants to get rid of it, then selling it off again at a higher price almost immediately with little-to-no refurbishment. This kind of practice is actually illegal in some places since it often incorporates some form of fraud, at least from my pretty weak understanding of the situation.

The point is that the concept of "flipping" has existed for kind of a while, and only recently has it been brought into the games industry. When Jim Sterling first used it, Digital Homicide was a prime example, who bought a lot of pre-built assets and "flipped" them with little-to-no changes or thoughtful design to go with it.

However, as with all things there's some grey area. What exactly constitutes "thoughtful design", and what makes a change big or small enough to cross the boundary between "asset flip" and "genuine video game"?

Some people have even gone so far as to declare that Player Unknown's Battlegrounds is an asset flip, since it uses a lot of assets from the Unreal Engine asset store.

I'm not here to set the record straight or anything since I don't really think I'm even slightly influential enough to do that, but I will offer my interpretation of an asset flip. I believe that a game becomes an asset flip when there's reasonable cause to believe that the developer did not put genuine work or effort into the project and rather is attempting to sit on the merits of assets that somebody else made.

This means that I don't consider PUBG an asset flip. While PUBG does use a lot of pre-built assets, I think that the developer has clearly put in effort to make the assets they did use coherent, well-assembled and overall it comes together in a cohesive gameplay experience that a hell of a lot of people enjoy.

Digital Homicide's infamous title The Slaughtering Grounds is something that I would consider an asset flip, since the gameplay experience is far from cohesive, feels cheap and I get the impression that the assets are the only thing the game has going for it and Digital Homicide know it. They're attempting to score a few bucks from people who take a quick look at the competently built assets and decide that they'd buy it.

However, that's not the end of the story for the term "asset flip". There's an effort in some strange part of Twitter to actually re-brand "asset flip" as a neutral or even positive term to describe basically any game that uses pre-built assets. In so far as that goes, I think that's the wrong way to approach things. The fact that "flipping" already exists as its own derogatory term in the real world makes it a thousand times harder to re-brand asset flipping in consumer's eyes.

Also, defining "asset flips" as any game that uses a pre-built asset is kind of crazy and not only de-values the term, it actually shuts out smaller indies who might not be able to afford or otherwise accomodate a full-time artist and opt instead to purchase assets that they like from the Internet. If consumers think that using any pre-built asset is bad(which they pretty much do at this point), then I can't see that ending up as good for really anyone.

So in closing, I've got one more thing to say. I opt to not even say "asset flip" very often since there's a lot of controversy and confusion about what the term even means. I think a more useful and accurate term in most discussions(such as the whole Steam clutter problem thing) is to just say "bad game". Not all bad games are asset flips- in fact a lot of them aren't. Asset flips suck, but they're a subset of the larger issue which is low-effort and dishonest titles getting onto Steam and making things harder for everybody.

Anyway, thanks for watching and stay tuned for more videos that will probably make people mad at me in the comments section because this is a properly controversial topic.

Monday, 23 July 2018

Why Godot 3.1 Is Something To Be Excited About

So we got Godot 3.0 a few months back and this has proven to be a massive upgrade to the engine, I mean jeez Godot 2.1 feels awful, clunky and awkward in comparison.

However, we're about to get a new version of Godot 3.0, which as you might have guessed is named "Godot 3.1". This version is, in my opinion, at a similar hype-level to Godot 3.0, when that was just about to be released.

One of - if not THE - biggest reason why I think Godot 3.1 is gonna change things is the AnimationPlayer node. Currently, the AnimationPlayer involves putting keyframable properties into a timeline, each represented by little dots. These can be interpolated continuously, linearly, cubicly or not interpolated at all, and just represent discrete state changes.

This works pretty well and I love the AnimationPlayer node as it is, since it's a really intuitive way to change properties over time. However, it's about to get a hell of a lot better.

Firstly, you can put Bezier curves directly into the animation. This is awesome since it means that you no longer have to rely on messing around with cubic functions, you can directly control the Bezier curve for pretty much any numerical value. As it should do, this makes animations a LOT easier.

Additionally, you can now use AnimationPlayers to set frames of Sprites. This is also pretty cool since it even gives you a lovely preview of the frame you're placing at that specific point in time. This means that you can much more intuitively create sprite animations with potentially varying framerates for each frame, if for instance you just wanted to place the keyframes down and work out the interpolation frames at a later date for the sake of prototyping.

Also, the AnimationPlayer will feature DAW-like audio processing(with preview waveforms and everything), capture mode, track copying/pasting, visual method selection for callback tracks, and probably more stuff but I can't dedicate this entire video to the new AnimationPlayer node.

So what else is there in 3.1? Changes to KinematicBody nodes, which are going to be awesome. The first of which is "snapping", which involves sticking a character to the ground as they move along slopes and things, so that momentum won't launch them off as they get to the top.

Also, some changes to how RayCasts work with KinematicBodys, which allows for some tricks to make the player movement speed constant when moving up and down slopes.

Also, something which is fairly relevant to mobile developers and people with terrible computers is the advent of a new GLES 2.0 back-end. This means that people using computers that do not yet support GLES 3.0 will be able to use the engine again, and also more mobile phones will be compatible with the engine.

The engine will also support exporting with Mono and C# and all that jazz better, but another big one that I'm looking forward to is the optional GDScript typing. This means that finally we can cast a function or a variable to a certain datatype without being FORCED to do so. This makes things clearer for those of us who are fans of static typing, but doesn't upset anybody who prefers dynamic typing. Everyone wins!

There's also the visual shader editor, which took a brief vacation in Godot 3.0 and is now back and better than ever. It's more intuitive, things that can be done automatically now ARE done automatically, and it's a very nice way to interface with shaders.

Also, something which I don't quite understand is the new AnimationTree node and state machines that go along with it. I don't QUITE understand how to set this up but from what I can understand, this looks really useful- especially for things like AI or player controls, and the blend spaces look awesome for inverse kinematics, colour shifting and probably a hell of a lot more.

There are probably a lot more relatively small things that I'm missing out here, but that's the jist of it. I'm seriously looking forward to Godot 3.1 and I think it'll change my workflow for the better.

Thanks for watching, and stay tuned for more videos about the Godot Engine!

Wednesday, 18 July 2018

Give Me The Rights To Snail Mail Or Else

[silence]

Well, here we are. Two videos and all I've got is radio silence from the now-defunct Sandlot Games.

Daniel Bernstein, I think you should make very sure that this message is not lost on you.

If you do not give me the rights to Snail Mail, people will. get. hurt. I can't say how and I can't say who, but this is the last straw, Sandlot Games. I've tried and tried to get into contact with you, e-mailing whoever I could possibly find to give me the rights and nothing. seems. to work.

I suggest you just bite the bullet and give me Snail Mail before bad things start happening. I've written a nice little list of the potential weapons I could use and since this is already a really short video, let me pad it out a bit.

I'll use knives. Guns. Swords. Katanas, specifically. Explosives, like C4, dynamite, TNT, C5, AK-47s, kitchen knives, butter knives, butcher knives, Ashton Kutcher's knives, large blades without handles, small blades that are only handles.

High-velocity chewing gum. Balls of thumb-tacks. Balls of drawing pins. Balls of hedgehog needles. Balls of porcupine needles. Balls of forks you find, weevils. I'll attack you with wildlife. Squirrels. Chipmunks. Rats. Mice. Rice.

[start to fade out]

Sugar, spice and everything nice. Sawblades. Sore spades. More maids. Four plays. Drawer maize. A gun. I'll throw the clip at you. I'll throw the bullet at you. I'll throw the barrel, or travel to put a mullet on you.

I'll plant a tree in your name. I'll brand a bee with propane. I'll cover your face in glue.

Brace your Gru. Grace your you. Shoot your gig. Boot your pig. Loot your brig. Tend your house. End a mouse. Defend a mouse. Pretend to douse.

E-mail me, Daniel.

Tuesday, 10 July 2018

I Demand The Rights To Snail Mail

So needless to say, I didn't really get a response on my last video about the rights to Snail Mail. I'm not entirely sure why, I thought I made a fairly reasonable proposition, I laid out my case pretty clearly and I thought I kind of logically stepped you through why I deserve the rights to Snail Mail.

In a nutshell, that was seemingly the wrong approach to take, so I'll try a new one.

I demand the rights to Snail Mail. I've laid out very clearly why and how I deserve them, and now I believe that I need to take them. I will not be offering any form of compensation, since I genuinely think that the rights to Snail Mail should be mine, and the current state of affairs is actually unfair to me. I think you recognize this, Sandlot Games. I think you're trying to twist my arm into making me... pay you? Let me tell you that's not going to happen.

Again, I'm reasonable. I'm a reasonable person, I think I'm mature enough to handle the rights to Snail Mail. I won't reiterate too much since I don't want to waste your time, just like you're wasting mine by refusing to even answer my proposition.

So here's what's going to happen. I'm going to write, record and upload this video to my YouTube channel. The former CEO of Sandlot Games, Daniel Bernstein, is going to e-mail me, telling me that he'll give me the rights to Snail Mail FOR FREE, and he'll expect nothing else from me. Daniel Bernstein will also be expected to hire a lawyer to draft a contract so that he cannot go back on his promise.

We'll agree to the terms in the contract, and I'll own the IP to Snail Mail. I'm not asking, Daniel, I'm telling you what's about to happen, and I hope you're listening. If you're not the one in charge of the Snail Mail IP, I suppose I'll have to take the same steps with the appropriate person but I will expect you to tell me who I have to talk to.

I'm believe I'm being as reasonable as I can be given the circumstances. I think that yeah, this is unfair to me and really at this point I'm still being too kind. If I was an angrier person, maybe I'd make you pay me just to TAKE the rights to Snail Mail. But I'm not. I'm making a simple offer.

Let's not let this go on any further. E-mail me, Daniel.

Sunday, 8 July 2018

MULTI-TECH - Let's Talk About My New Project



In a sentence, MULTI-TECH is a rogue-like bullet hell vidja game where you play as a dude on a scrappy, self-built spacecraft that you have to fix, upgrade and build yourself.

In my mind, it's kind of a fusion between FTL and Enter The Gungeon, even though I'm taking some fairly large design liberties with each of them. I'm basically using Enter The Gungeon as a reference point for game juice and FTL because you can upgrade your ship. Kind of a loose comparison in retrospect but I'll have these games in mind during development so I might as well put it out there.

As I'm sure you can see judging by the B-roll that I've got playing here, not a lot's really happening on-screen. That's because I only started working on this game at all on Tuesday, and I've put the majority of work into the pixel art for the time being which is miraculously turning out pretty decently so far.

With regard to the player character's ship that you can see at some point in the video footage, I'm not sure if that's gonna stay the same and I highly suspect that it won't. I'll maybe experiment with some player-generated ship design stuff, but that could get complicated kind of fast so I'm not making any promises.

More likely, I'm going to re-make it at some point. I don't want it to look like that for the whole game, at the time of script-writing I've not even done the animations for shooting those bullets yet so it looks kind of boring and flat, but I am kind of aiming for the look that this spaceship was literally built from a rusty barrel and had a few peripherals slapped on like a thruster and a gun.

The idea is that the player will salvage broken tech components, fix them up by combining them or some other system that I've yet to come up with and apply them to the ship. The ship will have 4 "power cores", each of which is able to supply power to one of these tech components, so it could be like a gun upgrade, a shield, something like that.

I should have mentioned before this point that there will hopefully be bosses in this game as long as I can actually make the pixel art for them without it looking weird and bad. When the player has all but won a boss fight, the boss will remain at critically low HP. The camera would zoom in on the ship itself, showing the human player character and prompt them to run between all 4 cores to engage a big ol super-laser-beam to finish off the boss.

This is kind of just a fun way to finish off a battle, but also it helps to reinforce that the player is running a ship all by himself, where most pilots would have a crew of a few people to help him out.

The only real worry I have about this project thus far is that I'm not sure if it's focused on one central element enough. In my mind, the focus is definitely the "combine tech and upgrade your ship" thing, but I'm not sure if that's actually interesting enough, let alone whether it gets overshadowed by other systems and aspects of gameplay.

I should also note that this isn't gonna be small project like Mushroom: The Ruckus, I'm expecting it to be a bit larger than Mass O' Kyzt. Hopefully it won't take longer than 9 months, but if it does then that's fine, since I wasted a lot of time in the dev cycle for Mass O' Kyzt that I feel I've learned to avoid doing. At least after that project, I feel confident that the time I spend working on MULTI-TECH isn't going to be running around in a circle aimlessly.

I've got a much clearer image of what the design is, plus I don't have school now so I'll be working essentially twice as fast as I did on Mass O' Kyzt, possibly even faster than that since school saps a lot of time and energy.

Anyway, I'm super excited about this project and I genuinely think it'll be really good. Thanks for watching and stay tuned for more videos about MULTI-TECH, the next game in the AlexHoratio saga.

Thursday, 5 July 2018

Why I Deserve The Rights To Snail Mail

For those of you who don't know, Snail Mail is a casual game developed by the now-defunct Sandlot Games in 2004. When I was a wee lad I used to play that game kind of a lot since it was fun and funny at the same time.

Now I'm not going to get too far into the merits of Snail Mail, and I'll keep the summary brief. Basically, you play as Turbo the Snail and your job is to deliver intergalactic mail while trying to avoid falling into the cosmic abyss or running face-first into enemy slugs.

The game plays nicely, the jokes are pleasant and it's a nice way to unwind if your brain is too melted or worn down to play something more taxing.

So let's get to the title of this video, why do i deserve the rights to Snail Mail? First, let me make it clear that I don't want to get anything from the original Snail Mail, the profits from that will still go to whatever legal entity is collecting revenue from Sandlot Games these days.

All I want is to legally and contractually own the intellectual property and associated trademarks of Snail Mail, so that theoretically I could choose to make a sequel, I could choose to write a book in the expanded universe or I could even just use Turbo the Snail as a character as I see fit. I want that freedom. I want the option.

I might not even end up using the IP, which is part of why this is such an appealing idea for either Sandlot Games, the also defunct Digital Chocolate, this company called RockYou, or the lead guy who worked on Snail Mail who I think works at Ubisoft now or something.

The point is that someone more eager to use the IP might not be thinking clearly. The excitement of owning such a property might actually end up clouding their ability to set an appropriate goal. If someone comes to you saying that they'll create an 800-episode webseries based on your IP, you tell them to get lost since that's not likely to happen, and even if it does happen it won't be good.

I'm saying: "Hey. I want the rights to Snail Mail. Maybe I'll use them, maybe I won't. I'm waiting for a good opportunity to use it."

It's the side of reason and it's a sensible deal to make. Who knows, maybe I'll use it in such a way that actually nets whoever some publicity, money or whatever else. It's not like they're ever gonna make Snail Mail 2 or use any Snail Mail related imagery in anything ever. It's basically a dead-end for them unless they give it to me- a reasonable, well-adjusted 18 year old who genuinely deserves the rights to Snail Mail.

Thursday, 28 June 2018

A Long-Awaited Return (For Good!)

Wow, I'm back! Oh god, finally, yikes. I've been gone for like a month, I mean what th-

[cut]

So you loyal viewers are probably either wondering where I've been, or you've been wondering who I am because you forgot about me in the time I've been gone. For the latter camp, I'm Alex and I make video games and sometimes YouTube videos about video games which can be informative, educational or just telling you how my own games are going.

For the people who are just wondering where I've been, in short I've been busy with exams. However, on Monday the 26th I had my final exam and now I am free... forever! That's the last round of exams that I've got so now I guess it's time to venture on into the brave new world of full-time game development.

Of course, that's assuming that my parents don't tell to get a part-time job so I stop wasting my life chasing a rainbow, but I guess I'll cross that bridge when I get to it.

So what does this mean in terms that you care about? Well for one, YouTube videos will become a lot more regular since I won't really have much else on my mind. Also, I'll be able to commit a LOT more time towards game development since again- nothing else to really have to do right now.

So basically, this means more content for you and less negative stress for me. Let's face it, the overall amount of stress is probably gonna stay pretty constant since game development is HARD, but at least this is stress that 1) I brought on myself and 2) I'll probably quite enjoy because I enjoy game development.

Now what else has been going on? I wouldn't ask that question if I didn't have a good answer for it so I guess this is as good a time as any to announce...

Mass O' Kyzt+! Or whatever name we decide to give it in the end. So there are a few things to address here, the first of which is yes- this is a remaster of Mass O' Kyzt, that game that I finished like 6 or so months ago. Since that game had a lot of issues and things which I really should have ironed out before release, a friend of mine has decided to pick up the slack and re-make Mass O' Kyzt in the Unity engine with a few adjustments.

The friend of mine doing all this is of course the talented Alex Carpenter, who created "Squirm", that game that Jim Sterling liked, and has been working on his next game "Float" for the past 6 decades. I should note at this point that Alex Carpenter is indeed in his 70s, so it's really nice of him to work through a bingo night or two to get this done.

For real though, Alex Carpenter is cool. He's doing this re-make primarily to practice his multiplayer programming skills, so that he can later apply those skills to his main big project, Float. That means that Mass O' Kyzt+ will indeed have some kind of multiplayer, 2 new worlds, more achievements(and less nonsense ones) and a bunch of quality-of-life changes.

I'm really looking forward to this, and since it's my intellectual property and this YouTube channel is basically thinly-veiled commercials you all should be looking forward to it too.

However, Mass O' Kyzt+ is not intended to really keep me busy at all since I don't really know how Unity works and this is first and foremost a practice project for Alex to get to grips with some stuff he needs for Float. That means that I'll be working on my next game concurrently with Mass O' Kyzt+ but well.. I think that's territory best left to another video. Winking emoticon.

So thanks for watching and stay tuned for more YouTube videos at a reasonable pace, and also then a remake of a game I did, and then also a new game entirely which I've yet to even come up with yet but I guess I have like three days to do it because this is how my upload schedule works. Oh dear.

Tuesday, 15 May 2018

Sporadic Godot Tutorials - Tile Sets and Autotiling

Well, because I need to get popular somehow and I'd rather not start up some kind of horrible controversy involving throwing eggs at people in a public space while screaming my YouTube URL, my only other option seems to be to make more tutorials. This isn't the classic "Gitting Gud At Godot" stuff because that was kind of dense and I feel as though there was a kind of progression from simpler material to more complex tutorial.

This "Sporadic Godot Tutorials" thing that I'm doing right now is gonna be a bit all over the place compared to that, and I'll probably opt to explain more specific things. Hell, I don't even know if I'll ever do another one of these so I don't know why I'm framing this as a series but if you have anything that you desperately need explained, then send me a message or a comment and I'll see what I can do!

So let's get down to business. I assume that most people reading this know what a tile set is, but for the purposes of completeness I'll give a brief explanation here.

In Godot, there are two components to a tile system. One of which is the tile set, and one of which is the tile map. The tile set is kind of like a bunch of generic ingredients (flour, sugar, water) whereas the tile map is what you actually do with them, or specifically, a literal grid of the tiles which are defined in a tile set.

Here's an example of a tile set sprite from a game I made, Mushroom: The Ruckus:


 (sorry about the trailing whitespace!)
As you can see, there's a bunch of tiles here, each of which is a 16x16 tile. This is just saved as a .png file and placed into some folder in the project. However, we haven't finished creating a proper tile set as far as Godot is concerned, so let's get into the engine.

Create a new scene and save it as something like "tileset.tscn". This is something you should keep around- that is to say you shouldn't discard this as soon as the tile set data is generated!

Create a tree root node of type Node and then add some sprites. Each sprite you create will equate to one tile in the editor, with some exceptions that I'll get onto in a moment. However, at the moment we're at a cross-road. If you want to figure out how to do autotiling, you're gonna have to skip ahead of this bit. If you don't know how to do even normal tiling yet, then I'm about to explain that bit so stick around for a moment.

So for a standard tileset, add some Sprite objects and name it something unique. The name you give each Sprite will correspond to the name it is given in the tile set itself, so make sure that it's informative and clear.

Also, if all your tiles are stuck together in one big .png like mine are above, you're going to have to load that .png into each Sprite and set the region. You can do this by selecting the Sprite, scrolling down to "Region" and make sure it's enabled then set the Rect. This value is basically just a value that corresponds to a rectangle of the Sprite that is going to be displayed, so the X and Y parts are the position of the top left corner of the rectangle and the W and H parts are how wide and tall it is, respectively. It should look something like this:



One more thing to note is that in order to create tiles that have collision, you'll need to add a StaticBody2D node as a child of the Sprite. Also, you'll need to add a CollisionShape2D with the appropriate shape in order to map what the collider should be and then you're good to go.

So yay, you've done it! You've created a tile set- well, nearly. All you need to do now is to generate the .tres file(which stands for text resource, I think) which can be loaded by a TileMap node in another part of your project.

This is super easy, you just have to go to "Scene" in the top left, move down to "Convert To..." and click "TileSet". Save your new tileset resource as something memorable like "tileset.tres", create a TileMap somewhere else, load "tileset.tres" into your TileMap and you're good to start placing some tiles!

Now, onto AutoTiling!

So at this point and regardless of whether you want to, you're gonna have to put all the tiles that you want involved in this autotiling stuff into the same .png file.

Also, you're going to have to open your "tileset.tscn" scene file and create a new Sprite that loads that entire .png into it. This is important: Don't set the region like you might done previously! From my experience that'll mess things up for you. Just convert this scene to a tileset resource as described above and load it into a TileMap. You're definitely not done yet, though.You've yet to even begin the real AutoTiling work!


So you've created a TileMap that has the Tile Set property set to your lovely tile set resource. Click on that resource to open it in the inspector, scroll down to the tile that's holding the whole tileset and tick the "Is Autotile" box, as shown to the left- I've named my tile "AllTiles", since it holds all the tiles.

Next, you'll notice that a button that says "Autotiles" has appeared at the bottom, next to the "Output", "Debugger", "Audio", "Animation" or whatever other buttons you might have down there. Click that, and it'll open the AutoTiler menu.

Before we do anything here, go to the left hand column (where it would normally list your tiles) and find the "Properties" menu just below it. Set "Bitmask Mode" to 3x3 and Tile Size to whatever size your tiles are. Mine's 64x64, for instance.

Now that you've done that, let's get into what all this crazy stuff in the AutoTiling menu means. The first menu is "Icon", and that one's pretty easy. It's basically the default tile to show if the autotiler can't work out which tile to place. Just pick whichever one happens to work for you, but I picked this one by left clicking it:


Now for arguably the most important menu, the bitmask menu. This one is the one that decides how your tiles are automatically selected while they're being placed. Each time you click, you'll notice that it creates a little red box.

Each tile has 9 potential spaces (with a 3x3 bitmask, if it's 2x2 then it's only 4) to place a red box. Each red box basically means "put me here if there's a tile in this position relative to me". This is a bit confusing to get your head around at first, but just carry on.

Pretty much any tile that you want to show up needs a red box in the center, because that center red box represents the tile itself. Here's what my bitmask screen looks like:


Let's take the line of tiles in the middle first. The tile at the very top will only show up if the tile directly below it is also filled in, so I placed one red box in the center and one in the center bottom position. Similarly the one at the very bottom will only show up if the tile directly above it is filled in, so I placed a box in the center and a box in the center top position.

Let's take the top left corner of that blob to the left-hand side. That corner will only show up if 1. the tile to the right of it is placed, 2. the tile below it is placed and 3. if the tile to the bottom-right is placed. Therefore, I put a red box in the 1. center-right position, 2. center-bottom position and 3. bottom-right position.

I'm not sure if I've made this very clear, but just mess around with these things in mind- you'll get the hang of it soon enough.

For these tiles, I didn't set any collision because they are meant to be walked all over by everybody else. However, if you did want to set collision you'd have added a StaticBody2D with a BLANK CollisionShape2D node to the Sprite back in "tileset.tscn", and then you'd go to the Collision menu and drawn in collision shapes for each tile. That bit's pretty easy but also hellishly buggy as of Godot 3.0.2, so good luck. Changing settings randomly, node hierarchy, saving resources and loading them again- it's a bit of a mess and I'm pretty sure it's gonna be fixed in 3.1, but for now it's really a "fuck with it until it works then never touch it again" type thing.

I don't even know what the Occlusion menu does but I'm pretty sure it's to do with lighting/shadows so I haven't and will not touch it. Sorry!

Navigation is similar to Collision in that you can draw polygons onto each tile to map out a nice NavigationPolygonInstance that you don't have to draw manually after placing the tileset. It isn't always useful, since all of the tiles above are places that I don't necessarily want enemies to automatically pathfind through- for instance, if there's a solid house on grass, I'd rather the enemies look to get around the house rather than straight through it.

The Priority tab is actually quite cool. Basically,if you've mapped multiple tiles with all the same bitmask rules then it'll randomly select one of those tiles to place when the conditions are met. However, the chance of one tile being chosen over another is actually perfectly random unless you modify the chances of it being chosen in the Priority tab.

When selecting a Tile, it'll highlight the other tiles with the same placement rules and it'll give you a fraction of how likely it is to be placed compared to the other tiles. You can select a tile you want and use the up or down arrows next to the text field to modify the chances, so instead of a 1/16 chance for a tile to be placed, you can make it a 3/18 chance, as below:



And that should pretty much do it for all your tile set needs. You can return to your tilemap, select the "AllTiles" tile and start placing and it should start AutoTiling for you. If you want to know anything else about TileSets/AutoTiling/etc then let me know, if you want a tutorial on another specific engine feature then also let me know then. 

Thanks for reading, and good luck with the autotiling!

Friday, 11 May 2018

Mushroom: The Ruckus - A Post-Mortem

Oh lord, what a mistake I have made.

I'm not referring to Mushroom: The Ruckus just yet, I'm still stuck on the fact that I apparently can't keep a steady upload schedule to save my life. I'll give some explanation as to why at the end of the video, but it's not very interesting so I don't want to scare away all the people who legit just wanna know how my game did.

So, for those of you who don't know (and I wouldn't blame you for not knowing) Mushroom: The Ruckus is a top-down hack'n'slash thingy where you play as a mushroom and you kill all the other mushrooms. It costs $2 or £1.69 so it's not expensive but there's not a lot of content going on there. The reason for this was because I decided that I'd seriously cut down on how much time I would spend on this one.

My last project, Mass O' Kyzt, took me about 9 months from start to end. It still didn't have a lot of content because a lot of that time was just me removing the content and making it again but better. This meant that I effectively wasted a lot of time to create a pretty sub-par project.

This time, I decided that I'd seriously speed up the dev cycle and just get it done before I could even have time to start hating it. Trust me, I still got to that stage in the last week of development or so but I managed to pump out most of the game before I got there. Mushroom: The Ruckus only actually took me a little over one month to create. I started the main character design at about 1AM on March 23rd while talking to a friend and I released the whole game on May 1st.

I think overall, yeah this is way preferable to spending 9 months on something that's not even fun to play by most metrics. However, I think I cut the dev time a little bit short when I could maybe have used a bit more time. I don't know if more time would have even helped because quite frankly I'm not that good at a lot of the things this game focuses on- things like story, graphics and whatnot.

However, I did find myself working 8 hours a day plus school plus social responsibilities for about a month and feeling absolutely destroyed by the end of it. In fact, I still feel mostly destroyed, just a little less so than I have done. And yeah, that's pretty much why I haven't uploaded a video in ages. I'm not exactly presenting this as an excuse because that was a horrible decision.

For the purposes of disclosure, since May 1st and as of May 11th my game has sold 50 copies. This is WAY less than Mass O' Kyzt which sold a lot more, even despite its initially greater price tag and (in my opinion) less appealing visuals. Now you might be thinking "well, 50 copies at $2 a copy isn't bad, that basically makes you back the Steam Direct fee" but unfortunately that is not actually the case. You see, I put the game at a 40% launch discount - another mistake - which meant that about 40 of those 50 copies are only worth barely over one dollar each.

So for the time being, I'm at a net loss. That sucks, but I've only myself to blame in this case. I'm not super upset about it(well, anymore) because I have definitely learned some lessons from the experience and I'm sure as hell not gonna do most of the things I've done again.

So why did Mushroom: The Ruckus only sell 50 copies? There are a lot of reasons and I'm pretty sure all of them are because my marketing SERIOUSLY sucked. Pretty much all the marketing I did was a half-hearted YouTube video and a bad trailer, and I send some copies to some Steam curators. If I was smart, I would have taken an extra month, worked on the game more slowly and actually marketed it properly as I was working on it.

In my defense I did show some gifs on Twitter which netted me about 15-20 followers over the course of two weeks, but unfortunately those were not the weeks leading up to release day, those were like April 1st to April 14th. Even my real life friends who are generally pretty clued into what I do legitimately did not know that my game was being released on May 1st, because up until literally the day before release it was only ever an internal release date.

On April 30th I tweeted something like "oh yeah, by the way, game's coming out tomorrow" which is by far the worst way to build hype since I only have a little under 200 followers and I'm pretty sure a lot of them are bots. 

Also, I should have made proper YouTube videos that document the process a little bit more. This isn't just for motivational purposes, this is because I have a free bank of 800 people who signed up for regular notifications about my content and for some reason, I'm not utilizing that!

One more thing I might add is the price point. Yeah, maybe my game wasn't worth any more than $2 and that's not really the point I'm making but people will believe that your game has more value if it is priced higher. Regardless of the actual "value for money", people generally don't pay attention to a smaller product for smaller money because they perceive it as being disposable or worth less.

I think that the solution to this is to just make slightly bigger games. Nothing too big, but games that would maybe fit a $5 price tag. Also, I have to learn to think in terms of dollars which is great because I don't use that damned currency in my country.

Lastly, lemme talk about how this is the first large game I've made with Godot 3. 

The transition to Godot 3 from Godot 2.1 is one of the smoothest things I've ever done. It is honestly so much nicer to use a nice, slick UI and the audio bus system than it is to have a slightly less nice and less slick UI with whatever the fuck audio system Godot 2.1 uses.

Not only that, but Godot 3 has native support for autotiling. It's not very well documented at the moment so I had to spend a while figuring out how to use it but it's really convenient, albeit a bit buggy with saving collision shapes.

Speaking of bugs, the trail effect after the player dashes.

Now when I was implementing the dash effect, I thought "hey, let's add a lovely trail effect". So after a little while of googling some neat implementations of something like that I found a kind of tutorial that uses a Line2D. I know what you're thinking, "Hey, Alex! You should use the particle system which is like a thousand times better for trail effects!" and yes, you are absolutely right. However, I didn't realize this at the time for some reason.

So I created a Line2D and made it sync up nicely and everything, but in a pixel art-style game I should really try and make the Line2D node actually display in a pixelly way. So I applied a simple pixelization shader to the Line2D.

Well, that didn't work. For whatever reason, we live to suffer and it just turned the Line2D white. I tried applying the shader to a normal sprite and it worked perfectly, pixelated the sprite and everything was in order. Back to the Line2D - not pixelated, just white.

I must have spent like an hour just trying to deal with that and figuring out why even modulating it didn't make it any less white but after a small breakdown I came up with the idea to create a slightly larger Line2D object that is given the exact same data as the other one but uses a screen-space shader to pixelize(pixelate?) anything that is underneath it.

Sadly, this worked. It's really hacky and if you look carefully you can actually see that it slightly messes with the ground in an area around the trail effect, but yeah. It works.

Also, it seems that Godot 3.0.2 actually has some problematic bugs on Ubuntu. I talked about it a bit in a forum post that was made in the community hub but I cannot figure out what the problem is, just that it only seems to occur with the Unity desktop manager, and segfaults when "New Game" is selected in the main menu.

I have seen some bug reports on Github for similar issues, so I didn't make a proper bug report. I suppose the point of this section is just to beware. Hopefully a lot of these growing pains will be fixed in Godot 3.1 or 3.0.3, but yeah- for the moment they're a little problematic.

With all the complaining I've done about the engine I just wanna reiterate that yeah, this engine is awesome and I could hardly love it more. I've made a few successful contributions to the repo too, so I'm slowly climbing my way up to being listed as a developer(which requires 10 commits). 

Anyway thanks for watching(or reading, if you're reading this) and stay tuned for a video regarding my next project. Yikes. I have exams, you know, I can't be doing this to myself.