Minigame Monday: Delegating

 Delegating:

  • The concept:

There's a system in C# called delegates, allowing you to define a variable that can be called as a function, which can call a range of methods that are assigned to it. I hadn't used delegates in any Unity projects before, so I figured I'd make a minigame to demonstrate the system. As it happened, I took it far too literally. I figured I'd set the player a series of tasks, which they could either attempt themselves, or delegate to an AI, which would handle the tasks using (you guessed it) a delegate. 

This meant that my minigame for this week wasn't exactly one minigame, but instead six simple minigames. This meant a bit more coding and set up than I expected; in the end I wrote eleven separate scripts for this project over two scenes, and suprisingly little of it involved delegates!

  • The challenge:

Despite my intentions, the biggest challenge here wasn't using delegates, but instead creating six separate minigames to use them on. I decided to go with games that the player could play with one button, and in the end settled on the following games: Press when the random numbers match, mash to inflate, press to keep draining water (really just a cuboid) at the right level, press when the blocks are level, press to make the sum correct and press to defuse the bomb when it's about to blow up. Most of these games weren't too complex to program once I'd worked out what I wanted. A little more complicated than that was creating the menu system to choose which games should be delegated or not. This involved a bit of scene management to make sure the correct values from the menu were transfered to the gameplay scene, but again (after making sure there was no case that duplicated my persistant gameobject).

On to the delegate. Once the flags to show which games should be played by the AI, I added functions to the delegate in the following manner:

delegate void ToDo();
ToDo todo;

void Start()
{
    random = FindObjectOfType<RandomNumberController>();
    inflate = FindObjectOfType<Inflate>();
    delegating = FindObjectOfType<ButtonManager>().delegating;
    if (delegating[0] == true)
    {
        todo += DoRandom;
        random.pointsForWin = random.pointsForWin / 2;
    }
    if (delegating[1] == true)
    {
        todo += DoInflate;
        inflate.pointsForWin = inflate.pointsForWin / 2;
    }
}

private void FixedUpdate()
{
    if (todo != null)
        todo();
}
 
void DoRandom()
{
    random.AI();
}
void DoInflate()
{
    inflate.AI();
}
 

This is a cut down snip of the setup class, but it shows how the delegate works. The functions to control the AI are added to the delegate (called todo) if they are needed. Importantly, the delegate is checked to see if it is empty before it is called. This is important, as calling an undefined delegate will cause an error, and if the player wanted to do everything that situation could occur.

  • The result:


 Although as this game is a minigame it's not the prettiest, I'm happy with how the idea worked out. It's not really possible to beat all of the six tasks yourself, so you do have to prioritize and delegate which is what I was hoping for when designing it. If you want to give it a go yourself, you can play it at https://reddragonmakesgames.itch.io/delegation, and the code is available on my github.

Comments

Post a Comment

Popular posts from this blog

Armageddump (Boss Rush Jam 2023)

Image
  Armageddump   First boss gameplay Armageddump is a 3D first person boss rush, developed in Unity. As part of the team working on it, I took the original concept and designed the bosses, gameplay and story and fully programmed the second two bosses. The programming included boss AI and management, developing the arenas and props and adding models, animations and sounds. The assets and code for this game can be found at https://github.com/RedDragonMakesGames/Boss-Rush-Jam . Game walkthrough: Blog posts about Armageddump: Game Design
Read more

Introducing: Minigame Monday! (3D Minesweeper)

Image
Minigame Monday:      To make sure I keep producing code, games and therefore blog posts, I'm aiming to create a small game every week on Monday (although it might not make it on to the blog the same day). These games will obviously be pretty simple; so far I'm thinking of making some twists on classic games, but that will probably vary. With regards to engine/language, I imagine many of them will be made using Python and pygame ( https://www.pygame.org/ ) due to its simplicity; it makes it quick to get something running on the screen. I'll release the game on itch.io and the code on github (see the links on the sidebar) with each blog post, so you're welcome to try the games yourself and look at how they were put together. Don't expect amazing graphics or intricate detail, but each game should be perfectly playable and hopefully pretty fun! This week: 3D Minesweeper The concept:      The idea is pretty simple: In a normal game of minesweeper, the numb...
Read more

Minigame Monday: Covert Behaviour

Image
  Covert behaviour: The concept: I've been doing some studies into behaviour trees in Unity for one of my personal projects, so I figured I'd experiment with the framework I'd created (using this tutorial as a guide (I did notice that the GetData and ClearData functions seem to doing unneeded work - they call the parent function, which then calls its parent function and so on recursivly, however they also loop upwards individually in the original function, so it seems like the functions might be being called multiple times on nodes close to the root. I rewrote the functions for now, and I'll look into it more as I use data in the BT. (P.S sorry for the nested brackets, but I guess I am an programmer :P))). I decided to make a stealth game, where enemy behaviour was controlled by a behaviour tree. Enemies would patrol, and charge at the player if the player crossed their line of sight. On top of that, I added a panic mechanic; if the player reached certain spots, all th...
Read more