Category: Tutorials & Practice

Not a whole lot to report today — mostly spent today going through documentation, getting set up again, and trying to pseudocode my way through the effect I wanted to write out. Turns out the windup tutorial actually happens in three stages: one stage for consumables, one for equippable items, and one for equippable tools.

In the end the thing that turned out to help me most was a combination of pseudocode and working backwards: writing out the objectives I had for the program, then taking tiny steps like “Okay, this needs to return a boolean; it’s consumable, so it returns false” and “Once all of the parameters are set up (even though they aren’t yet), I’ll pass them in here, which will perform the main point of this code)”.

Working backwards was also an interesting way to diagnose problems, because I’ll find out later whether I’ve made a huge mistake about conceptualizing things, but in the meantime I can isolate all of the syntax issues that are happening while I try and set up my parameters, as a result of not knowing C# very well.

Really, for real, almost nothing to report from today. I fixed the problem in my code, tested it (it worked, because I’m amazing), and finished the last official remaining unit in the project. The unit was to make your own script from scratch, but it was still pretty simple — writing one function which contained one line of code, and then applying it in the Unity editor.

The main question, as always, is what’s happening next. I think I’m going to work through the last couple units of the game — there are a couple where the time-to-complete is listed as zero, presumably because they’re both optional and pretty free-form. There’s one to customize your game some more, and then a couple which look like they’re about sharing and submitting your mods, which should be quite quick.

They have two recommended tutorials after this, one for 3D work and one for 2D work, both of which will presumably involve more coding in C#. I’m deciding whether to do them or take a whack at the beginning VR tutorial I found, because one thing this tutorial showed me is that when they say beginner, they really mean it. You didn’t need to have prior coding knowledge or experience to make this tutorial work. Which has left me a little less scared of the VR tutorials, at least the ones that’ll be holding my hand.

I can’t remember whether I ever linked the Beginner Code tutorial, but here it is. And here’s the Unity documentation/Scripting API.

Today I went through another big chunk of the Creator Kit: Beginner Code tutorial. Yesterday was an introduction to (a review of) variables and functions, plus some syntax for C#. Today was all about classes, and I was both bored and boggled by turns.

Bored

It is TBQH not the tutorial’s fault that I already know a lot of the concepts they’re introducing, and that I’m mostly in it for the syntax, but still. I ended up critiquing the lesson structure in my notes halfway through, which isn’t the worst use of my time (learning how to teach is definitely not nothing), but still wasn’t… great.

The lesson that got me was the unit about writing your own spawner class, which per my notes was structured something like this:

1. Here’s how to write the syntax for declaring a class (always a good place to start)
2. Declare your global variables (a good next step, though they didn’t actually call them global variables or explain what the difference would be, which seems important)
3. Write the most important function, the one you absolutely need your class to be able to perform (a constructor, you say? no, no. just the function which is the primary point of the class. which… i get, but seems backwards)
   1. In writing the most important function, use a class and function which we have written for you elsewhere. This function should be relatively simple to write on your own, even if it would provide redundancy (I assume the function is also needed other places, which means they can’t wait for you to write it in the tutorial. But you won’t write it. We won’t tell you how it works.
   2. Here’s a hint: it’s almost definitely just a modulo operator. That’s it.
4. Now you get to write the constructor function.
5. But because we didn’t tell you about what public variables are, your code doesn’t work, and you now have five errors.
6. That’s it, that’s the end of the unit. See you next time.

I bet it shows how impressed I was.

But it was actually good practice for writing code, and I found myself remembering syntax pretty intuitively, which was helpful.

Boggled

In order to treat myself and prove what a smart and special programmer I am, I decided to add in a for-loop, using a public int which one could set in Unity. The size of the int would determine how many health potions/how much money spawned at the start of the game.

Ladies, gentleman, and those of us who know better: I broke everything.

That’s perhaps a little overdramatic, but essentially, I crashed the Unity editor like six times. You could not change the variable and then run the game without immediately causing the Unity editor to freeze, which in turn forced me to kill the program from the Task Manager.

If you didn’t change the variable (which by default was 0), everything was fine, by which I mean the game would run without the Unity editor crashing. Everything was not fine, in that zero potions would spawn, with no way to change that.

Eventually I decided to put my for-loop inside a conditional clause: if the number of potions is less than or equal to zero, don’t bother. If it’s not, try the for-loop.

This worked, in that the game no longer crashed if you changed the variable. It still left me with absolutely no potions, because the game just did not care what you changed the variable to.

I gotta figure out how to write to the console in order to speed up my debugging. In the meantime, have a screenshot of my terrible for-loop (with the section it was supposed to replace commented out). That’s all, folks!

UPDATE: I FOUND IT. RIGHT AWAY. ABSOLUTELY CLASSIC.

(Hint: I asked i to be equal to zero, and also greater than whatever number of objects I wanted to spawn. Oops.)

So, following up from yesterday – today was about the Beginner Code tutorial on Unity. It was, as the name says, very beginner — it did a lot of introducing the concepts of variables and functions, which meant that I skimmed those sections.

The tutorial started out pretty simple, with a general rundown of how computers, compilers and code all work together, as well as exploring the game to see how different parts of the world work. Then it went into examining scripts, and how to read through C# when written out.

One thing I really appreciated was that the tutorial made a point of introducing a term that would make no sense without explanation, then immediately linking the documentation and walking you through how to use it. Beginning programmers, like the sort this tutorial is aimed at, may not know what documentation is, or where to find it, or even how to use it; this setup specifically showed how to find it, and then how to interpret what the answers were. This was also nice because Unity uses some specialized terms that are not necessarily present in C# broadly, so when I went to look them up in C#’s documentation, I had a lot of trouble.

The tutorial walked you first through variables and then through functions by having you edit a script which spawns health potions at the start of the game. The variable you change affects the distance from a central point the potions spawn; the function you change refactors the code to prevent the same function being rewritten four times.

It has been a while since I wrote code, because I made a pretty silly mistake: I didn’t type my variables when I instantiated them in my function, which led to the same error eight times over, and couldn’t figure out what I’d done wrong. Hopefully I’ll take that lesson forward. It’s been a while since I’ve worked in a strictly typed language.

I actually worked a little bit ahead, since skimming through the explanations of variables and functions left me with extra time, and managed to get through tomorrow’s agenda and even a little bit of Thursday’s. I’ll be moving things up to compensate.

Today we’re getting started on the 2D Game Kit! The last tutorial was entirely a 3D environment, which was good on the theme of working towards VR, but I’m hoping the 2D Game Kit will give a bit more variety of skills and practice with what I already have.

Getting quite honestly kind of annoyed with the number of updates Unity puts out. Can’t tell if they’re treating every version as distinct or if each thing is just a few small patches, but it feels like every version is a new and distinct one and they push a new one every two or three weeks. Might just be me though.

The 2D game tutorial is so far a lot more approachable than any of the 3D tutorials (though that may be the fact that I now have some idea what I’m doing). We’ve covered adding prefab assets, as before — this time, tile painting in order to generate platforms, and the ability to add a prefabricated moving platform. The tutorial shows how to get it to move in a square loop, but I decided to set mine up to move in a triangle.

The tutorial was actually so straightforward that after my initial notes above, I didn’t end up noting down anything in particular I was having trouble with. Very clear drag-and-drop across the board. It was actually so clear that I’m curious what the walkthrough video will consist of, since the whole thing is another 45 minutes long.

The 2D Game Kit tutorial I worked through today can be found here: https://learn.unity.com/project/2d-game-kit. I got through parts 1 and 2, though I didn’t finish the last bit (teleporting the player to a new level).

One thing I ran into which I’ll need to look up a bit more: occasionally I would put a piece of environmental background art (extra backdrop, usually, as I ran out of room on the level) and then be unable to put any ground tiles on top of it. Tomorrow: putting the final touches on teleportation, and seeing what may come from the walkthrough video! (And possibly more…?)

Today’s technically day 4, but I got very little done on Friday, and day 3 started by finishing up what I started then. Which was… drumroll… machine learning! Not programming machine learning, but learning how to add a second AI-controlled kart to my karting game, then set up checkpoints for the AI to follow so it could see how to go around the track. I need to neaten up my checkpoints a little – at present my AI gets frightened of a big jump halfway through and turns around to go back to the starting line, where it gets confused and has to stop.

Setting up the AI kart controls involved making a prefab object for the AI to use as a checkpoint, distributing it around the track so the AI could always locate the next one, setting all the checkpoints as a trigger event, and placing them on the ‘Training Checkpoint’ layer. And also making them invisible, so that I could see the rest of the track (turn off the Mesh Render for this bit).

Next we moved on to a bit more decoration, aka using billboards – you can set images as an object’s texture using the albedo! Still haven’t answered my question from day 2 vis-a-vis what got my colors stuck, but cool nonetheless.

Learned how to add new cameras, position them and make them follow the player – you can add them through the main scene editor, position them by aligning with the view (or moving them as you’d move anything else) and attach them to the player by putting them somewhere inside the player’s hierarchy and positioning them accordingly.

I got to learn how to make new scripts! You can write a new script by creating it as a component, then opening it with your text editor, and proceeding from there. I’m having some issues with mine, however. I copied the code directly from what they were doing, but it looks as though variables that are instantiated but not initialized are meant to be able to be set in Unity. In the tutorial, they have blanks which can be filled by other game objects, but my Unity workspace isn’t displaying them.

Update: found the issue. I had a double in my code that was meant to be a float. (Can you tell I’m writing these notes as I work through the exercises?) Running into some new issues bugtesting, though – namely, I’m very bad at driving the kart.

Animation notes: have to create an animation as an asset (apply through Window > Animation > Animation when you have something selected, then hit ‘create’). Created through keyframes – position it where you want it at a keyframe!

Also some interesting experiences with bugfixing and post processing. The first rule for bugfixing: don’t write code you don’t understand. I ran into an issue that wasn’t even a bug (on Unity’s part). I had an error that didn’t affect compiling, only a piece I had deactivated, so I was fine running the game with it, except I had Error Pause turned on, which meant any error would prevent me from playing the game. One fun bonus of following a tutorial livestream is watching people with more knowledge than me hit the same bugs I’m running into.

I actually got through the entire rest of the tutorial today, which was honestly pretty incredible. The streamers’ process started to unravel a bit towards the end, when they ran into bugs which they didn’t have time to address and started taking requests from their chat which was overambitious for their time limits, but honestly, that was pretty bolstering. It’s a good reminder not to be intimidated by people who do this professionally — everyone starts somewhere, as they reminded everyone at the end of the stream!

I’m not going to move onto making my own projects yet; I want to practice with some more tutorials and pick up more skills (especially problemsolving skills) first. I may also look for some C# tutorials so I can understand what it is I’m trying to write when I code.

As I mentioned before, this stream was located here: https://www.youtube.com/watch?v=Dweo04X7mJU

It was part of this tutorial: https://learn.unity.com/tutorial/join-your-first-game-jam-1

Give it a try — it’s much less intimidating than you’d think! And if you’d like to play my game, it’s available here: https://connect.unity.com/p/the-zoomies/ (You have to knock down the donuts; for some reason my change to ‘pins’ in the instructions didn’t take.)

Still working through the livestream tutorial, as yesterday. I didn’t get a whole lot done today — my Unity files had gotten out of date, so I had to update a lot of packages before I could get started with the build. Only got through about half of what I had planned, but it was an important chunk nonetheless: how to add assets, add collision physics, and set up events to trigger!

Clicking and dragging an asset onto the scene adds it to the dropdown menu on the side (technically, we also did this yesterday, but I count it towards today because we did more editing of the asset today). From there you can click into the asset’s menu and add components. Adding a BoxCollider makes the object solid, so you can’t move through it the way you might be able to for other objects. If the object has a script for it, you can also add particular events to trigger when you interact with it, like making a certain sound effect play. I did run into a weird issue where I couldn’t change the color of certain prefab assets, which is something I did a fair bit of yesterday. Haven’t resolved it yet.

Questions for the future:

• How do you add events to objects that don’t have scripts for it?
• What about certain objects (or certain Unity configurations?) allow/prevent changing colors?