(very) Minigame Monday: 21

 21:

  • The concept:

Seeing as I wanted to spend time on the game jam this Monday, I decided to do something very simple. My task was to create the card game 21; nothing unique, but a good chance to practice efficient programming. To give a quick summary of the game, you are dealt two cards, and can draw additional cards. The aim is to get as close to 21 as possible without going over. There are a couple of rules that added a bit of depth to the programming (for example aces can be either 1 or 11), but on the whole a pretty simple task.

  • The challenge:

I did want to handle the deck in the most effecient way possible and avoid making the shuffling more complex than it needed to be. I decided to use a list to store the deck, because lists, unlike other storage containers, are able to efficiently add elements at a given point with constant complexity. This allowed me to shuffle the deck in a single for loop without the added linear complexity of adding the elements that using vectors would require. However, lists don't have a random access operator, so getting to the right position to add an element was still linear in complexity. I suspect both vectors and lists perform similar with my method. My code to produce a shuffled deck is as follows:

list<int> ShuffleDeck()
{
    /* initialize random seed: */
    srand(time(NULL));

    list<int> deck;
    deck.clear();
    for (int i = 0; i < 52; i++)
    {
        list<int>::iterator pos = deck.begin();
        int addSpot = (floor(rand() % (deck.size() + 1)));
        for (int j = 0; j < addSpot; j++)
            pos++;
        deck.emplace(pos, i);
    }
    return deck;
}

After looking into it now, after the fact, it looks like the most efficent way of shuffling an array is by swapping elements, which can be done in linear time. I think I was pretty unlikely to find this solution however, as it's not obvious that the result is always shuffled with equal probablity. 

  • The result:


 It's a game of 21! It's pretty basic, but it follows all of the rules. You can play it for yourself and look at the full code on my github: https://github.com/RedDragonMakesGames/21/tree/main/21%20project.

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

Imperfect Control: Gameplay

Image
 As promised, in this post I'll be talking about the gameplay in Imperfect Control. As the name suggests, I wanted to do something different with this game rather than creating a typical roguelike where the player moves around the rooms. Instead, I had the idea of having the player move the enemies. Each room then becomes trying to perform the correct movements to destoy the enemies (by moving them into hazards), while at the same time making sure the player wasn't hit by any of the enemies.  Spawning: I wanted each room to have a separate parameter (which I called hazard level), detailing how difficult each room would be. Each room could then be generated with a seperate value as part of the map (Part of the reason for this was that one of the powerups I was hoping to add would reveal the hazard level of nearby rooms, unfortunatly I didn't manage to implement this). To control the spawning of each room therefore, I assigned this hazard level, and therefore the spawning, to
Read more

Hair of the Wolf (GameOff 2022)

Image
  Hair of the Wolf First level gameplay Hair of the Wolf is a randomly generated 2D platformer made in Unity. As part of the team, my role was enemy and boss design and implementation, random generation and paralax and camera control as well as many smaller programming tasks such as character interaction and damage hit/hurtboxes. The assets and code for the project can be found at https://github.com/RedDragonMakesGames/Gamejam2022 . Gameplay clips:
Read more