Category: GameDesign

Doppler Effect in Mario Kart – Game Audio – by Scruffy

digm520admin / / Audio, GameDesign, GameDev
July 1, 2021

Doppler Effect and Audio Controller

Game Audio

Title:
Mario Kart and the Doppler Effect

By:
Scruffy


Youtube – Information

Description:
Explanation of how Mario Kart creates the doppler effect and efficiently distributes audio to multiple players.

Overview

This video covers how Mario Kart Wii specifically uses the doppler effect, as well as just how some of their audio systems work in general. It is decent coverage of how to implement a basic doppler effect system into a game in general.

Fig. 1: Image from “Mario Kart and the Doppler Effect” Video Above by Scruffy

Setup of Doppler Effect System

The key is the relationship between sound frequency and relative velocity of objects. Their approach to measure this is just by measuring the distance from the audio source to the audio listener each frame, and if there is a difference, that is used for a relative velocity term. This relative velocity term is bound to some negative and positive scale (one direction meaning higher frequency and the other being lower frequency). The way this relative velocity maps to a difference in sound frequency can use any mathematical relationship to fit whatever feels best (i.e. linear, logarithmic, etc.).

They break this core down into three basic steps:

  1. Get distance between source and listener each frame
  2. Subtract from previous for rate of change
  3. Map rate of change to determine sound playback speed (to taste)

Expansion of the System and Efficiency

This explanation shows the direct relationship between an audio source and an audio listener, but games tend to have many audio sources. They show how immediatley this can at least be simplified by having some audio distance so the calculations only need to be performed on objects within a certain distance of the listener. The other big part of simplifying the system is just limiting which sources implement the doppler effect. Not every sound needs to use this, so it can be removed from many standard sources (i.e. the crowd in Mario Kart).

Split Screen Solution

This is fairly niche, but still interesting. With split screen, the audio of multiple listeners needs to come through a single audio output. Since they may experience different levels of the doppler effect for the same audio sources, they needed a solution to provide an experience that does not sound like a mess. Their approach was that each player only makes sound in their own camera (so one player is not listening to the other on the same screen), and when dealing with outside sources, only the player closest to the audio source is taken into account. The other player’s audio for that source is simply negated. This is a nice solution as the system already takes the distance between sources and listeners into account anyway.

via Blogger http://stevelilleyschool.blogspot.com/2021/07/doppler-effect-in-mario-kart-game-audio.html

Game Project: Flying Game: Sonic Boost – Part 4 – Projectile and Environment Interaction

digm520admin / / Environment, Game Feel, GameDesign, GameJam, GameMechanic, Unity
June 2, 2021

Flying Game

Projectile

Overview

I was trying to think of ideas on how to add an extra mechanic to the flying controller that ties in with a fast and agile moving controller, and thought of tying in some type of sonic boom effect. With this, I thought creating an expanding projectile from the player after boosting could be an interesting way to generate these projectiles. I then explored a few ways to have the projectile interact with the environment and came across a relatively simple one that provides some fun feedback.

Sonic Boom Projectile

Everything about the projectile is rather simple. The projectile is generated when the player performs a fully charged boost. It then expands at some growth rate (dictated by the projectile controller on the player) up until some maximum size (dictated in the same location). As it encounters objects with an IDestructible interface, it will cause them to perform their Destroyed() method.

This gives a pretty cool effect that at least has a minimal basis in real world physics. It also makes tight turns and effective direction changes tied to a boost more satisfying when performed properly. It does have a major flaw currently however in that a majority of the action is normally happening behind the player, so they do not get to witness it most of the time. This is a pretty severe drawback that I will need to investigate some solutions to.

Voxelized Environment Obstacles

I initially liked the idea of creating targets or obstacles that could be destroyed by this growing sonic boom that would deteriorate as the sonic boom moved into it, as opposed to a more general game approach where contact would just do damage and destroys the entire object as a whole. This led me to making a bit more voxelized targets, which were made up of several chunks instead of just being a single large mesh.

To begin, I created a Voxel Obstacle script which is the overall container of a full obstacle made of several voxelized elements. This script just holds 3 dimensional values and builds out a solid cube/rectangular solid based on those dimensions.

The elements that make up the full obstacles are just simple prefab cubes for now, with a VoxelObstacleElement script. That script implements the IDestructible interface just so they have a Destroyed() method for the projectile to interact with.

Initially I had these elements have their gameobjects destroyed on impact with the projectile just to test the interactions. This was an ok approach, and gave the deteriorating effect I wanted that was at least more fun than the whole area exploding immdeiately on impact. However, I explored a more physics-based approach that looked a lot more satisfying. I simply turned the elements’ rigid body component from kinematic to non-kinematic to effectively enabled their physics. This gave a fun tumbling and physics-y effect for the individual blocks as they interacted with the projectile.

This is a decent spot for most of the elements of this small game project, and I think the next step is just building out a better level to test the individual mechanics in. I would also like to add a bit more to the projectile/environment interaction just to make it a bit more impactful. I would also like to remove the strange interaction of hitting the blocks from above, as without any additional force, they don’t really move since they really start by moving downward with gravity being the only force acting on them.

Sonic Boost – Projectile Tests and Environment Voxel Interactions from Steve Lilley on Vimeo.


Video: Sonic Boom Projectile and Obstacle Destruction Showcase (1st and 2nd Iteration)

via Blogger http://stevelilleyschool.blogspot.com/2021/06/game-project-flying-game-sonic-boost.html

Game Project: Flying Game – Part 1 – Introductory Movement and Camera Controller

digm520admin / / Camera, CharacterController, GameDesign, GameJam, Programming, Unity
April 30, 2021

Flying Game

Game Project

Overview

I wanted to do some work on a small, simple 3D game in Unity I could make within a week or so. My original focus is on player movement, and from there I decided to hone in on a flying game of some kind. I have been watching Thabeast721 on Twitch and he recently played Super Man 64 which I have also seen at Games Done Quick (GDQ) events and thought building off of and improving their flying controller could be a fun project.

Player Controllers

Controller #1 – Rotate Forward Axis

My initial thoughts on a basic flying player controller was to have left/right rotate the player on the y-axis, up/down rotate the player on the x-axis, and a separate button to propel the player in their current forward direction.

As a controller standard, I also tend to have the player’s input be received in the Update method to receive as often as possible, but then output these inputs as movement in FixedUpdate to keep it consistent on machines with different frame rates. 

	private void Update()
    {
        horizontalInput = Input.GetAxisRaw("Horizontal");
        verticalInput = Input.GetAxisRaw("Vertical");

        if (Input.GetButton("Jump"))
        {
            isMoving = true;
        }
        else
        {
            isMoving = false;
        }
    }

    private void FixedUpdate()
    {
        // Inputs in reverse position for direction vector because that influences which axis that input rotates AROUND
        Vector3 direction = Vector3.Normalize(new Vector3(verticalInput * inversion, horizontalInput, 0.0f));
        Flying(direction);
    }

    private void Flying(Vector3 dir)
    {
        RotatePlayer(dir);
        MovePlayer(dir);
    }

    private void RotatePlayer(Vector3 dir)
    {
		transform.Rotate(dir * rotationSpeed * Time.deltaTime);
    }

    private void MovePlayer(Vector3 dir)
    {
		if (isMoving)
		{
			transform.position += transform.forward * movementSpeed * Time.deltaTime;
		}
    }

Controller #2 – Rotate on Y-Axis but Translate Directly Vertically

With my second approach I wanted to try and emulate the flying controller from Super Man 64 just to see how it felt. It seems like a more acarde-y style of flying with easier controls, so I thought it would be a good option to investigate. For this horizontal rotation (rotation on the y-axis) remained the same, as this is pretty standard with grounded player controllers as well.

The up and down rotation (rotation on the x-axis) however, was completely removed. The up/down inputs from the player simply influence the movement vector of the player, adding some amount of up or down movement to the player. This makes it much easier to keep the player’s forward vector relatively parallel to the ground and is much less disorienting than free-form rotational movement in the air. 

	private void Start()
    {
        if (isInvertedControls)
        {
            inversion = -1.0f;
        }
    }

    private void Update()
    {
        horizontalInput = Input.GetAxisRaw("Horizontal");
        verticalInput = Input.GetAxisRaw("Vertical");

        if (Input.GetButton("Jump"))
        {
            isMoving = true;
        }
        else
        {
            isMoving = false;
        }
    }

    private void FixedUpdate()
    {
        // Inputs in reverse position for direction vector because that influences which axis that input rotates AROUND
        Vector3 direction = Vector3.Normalize(new Vector3(verticalInput * inversion, horizontalInput, 0.0f));
        Flying(direction);
    }

    private void Flying(Vector3 dir)
    {
        RotatePlayer(dir);
        MovePlayer(dir);
    }

    private void RotatePlayer(Vector3 dir)
    {
		transform.Rotate(dir.y * Vector3.up * rotationSpeed * Time.deltaTime);     
    }

    private void MovePlayer(Vector3 dir)
    {      
		if (isMoving)
		{
			Vector3 movementDirection = Vector3.Normalize(transform.forward + dir.x * Vector3.up);
			transform.position += movementDirection * movementSpeed * Time.deltaTime;
		}     
    }

Camera Controller

Follow Position

To follow the player’s position, I am using a really simple case where it just follows them at some fixed offset. The offset is originally determined by the initial position of the camera relative to the player, and then for the rest of its run its position is just that of the player summed with the offset.

Where transform.position is the position of the camera object:



offset = transform.position – player.transform.position;



transform.position = player.transform.position + offset;

Rotate to Follow

My first test just to initialize the camera follow was to child it to the player to see how it looked that way. This worked ok for following position, but having multiple rotation influences made this impossible to use quickly at first. As I changed the player controller to a more general, arcade-style, it worked better but was still poor for rotation.

To fix this I put the camera as a child onto a separate empty gameobject. This gameobject could then follow the player and rotate to rotate the camera around the player while keeping it at a fixed offset distance. This also made determining the rotation angle/looking vector from the camera to the player much simpler. Since the camera is rotate downward some, its forward vector is not in-line with the world z-axis anymore. This camera container however could keep its axes algined with the world’s axes. This meant I could just make sure to align this container’s forward vector with the player’s forward facing vector on the xz-plane. To do so it just required the following: 

private void RotateView()
{
	Vector3 lookDirection = new Vector3(player.transform.forward.x, 0.0f, player.transform.forward.z);

	transform.rotation = Quaternion.LookRotation(lookDirection, Vector3.up);
}

Unity’s Quaternion.LookRotation method allows me to set the rotation of the object based on the direction of a forward facing vector (lookDirection in this case), with a perpendicular upward vector to make sure I keep the rotation solely around the y-axis.

The following is a quick look at how the final player controller and camera controller interact from this initial prototype approach:

Flying Game Project: Initial Player Controller and Camera Controller Prototypes from Steve Lilley on Vimeo.

Summary

via Blogger http://stevelilleyschool.blogspot.com/2021/04/game-project-flying-game-part-1.html

Planning and Designing 2D Character Controllers: Using Lucid Chart

digm520admin / / 2D, DesignResources, GameDesign, Platformer
January 28, 2021

Planning

2D Platformer Design


Lucidchart

Description:
Visualization tool for diagramming and flowcharting.

Overview

I want to begin designing the 2D platformer character controller creation tool, so I looked for diagramming and flowcharting tools and turned to Lucidchart. I have used it a couple times in the past, and thought it would be a good source to go to again for this. It covers both the helpful programming diagramming as well as just general note and design organization is a clean and visual way.

Design Start: Inspirations and Controller Component Breakdown

Since I want to make a strong character controller creating tool, I want to gather good resources to draw from to see what different components I want to include in the tool. To start this, I began laying out all the basic components that I think can make up a 2D platforming character in a game that I am interested in covering. To support this, I have also began listing games with strong or unique 2D platforming character controllers that I want to draw options and information from. This are shown below in the images created with Ludicchart (these are just the beginnings to start getting the information down and figure out how to start organization).

2D Platformer Character Controller Components: Start


Games to Research and Draw Inspiration

As I started to fill in the games, I noticed that some of them are distinctly different in what I consider pacing so I decided to separate those out for now. Recent Yoshi games and most Kirby games tend to be a bit easier on the difficulty side, especially compared to a lot of games on my list, which I think in turn makes them feel a bit lower paced. This may not be the most accurate term, as there are times a game such as Hollow Knight can be a bit slower paced, but I do not think it has anywhere near the feel that Yoshi and Kirby games has I am trying to convey.

Summary

So far Lucidchart has been fantastic just for visually organizing my thoughts and notes so far. The components are very cleanly organized because I can lay out the major component names, while attaching notes to those individual components to give a longer description as well as some game examples to explain them better.

via Blogger http://stevelilleyschool.blogspot.com/2021/01/planning-and-designing-2d-character.html

Personal Game Jam 1 – Getting Started

digm520admin / / GameDesign, GameJam
April 24, 2020

Personal Game Jam

Getting Started

Finalizing Concept Selection

I had reduced the number of concepts from 6 to 3 after creating the initial concept lists by removing all the options from pair B. I really liked most of these concepts, but they were a bit more involved than I was looking for for such a short term project. The main issue with the first two for me was that they involved drawing objects into existence with the mouse, which is a type of input I am completely unfamiliar with. This would have made them a perfect candidate for an experimental game project with 2 weeks of effort, but since I wanted to make significant progress in just two days, this would have set me behind too much. The last concept was more puzzle related, which is difficult to make effectively in this amount of time since they are so level design focused.

To help me decide between the 3 remaining concepts from my pair, pair A, I made really simple concept sketches to get an idea of how they would look. Here are those sketches:

Concept 1: Water and Space Pressure for Expanding and Compressing

Concept 2: Flying Tree Spirit Fueled by Water

Concept 3: Gather Minerals as Polyp to Feed Coral Monster (Phase 1)

Concept 3: Gather Minerals as Polyp to Feed Coral Monster (Phase 2)

Concept 1: Water and Space Pressure for Expanding and Compressing

This concept focused on the difference between the high pressure environment of water and no pressure environment of space. The player would expand over time in space areas, and compress over time in water. Each size has its own pros and cons and the player navigates through an area.

I eventually discarded this concept since it ended up being too puzzle related most of the time, which as I stated before, are a bit too much work to create in a small time period.

Concept 2: Flying Tree Spirit Fueled by Water

The player is a tree entity that uses water as fuel to propel itself through space to find minerals and resources to mine. Water and minerals can be used to grow and upgrade the player.

This rather simple concept was a nice mix of simplicity and room for expansion and growth, so this seemed like a promising candidate to move forward with.

Concept 3: Gather Minerals as Polyp to Feed Coral Monster

This game is played in two main phases: a small space polyp phase and a large coral monster phase. The player starts in the polyp phase, and can move between a space environment and an aquatic environment. They search for space coral hearts in the space environment to bring to the water environment so they can plant them and grow them.

The player then feeds these coral hearts to influence and accelerate their growth. They do this in two major ways: finding minerals to bring back to the heart and defeating enemies above the hearts so that they fall onto them. Once the coral heart receives enough resources, it grows into a coral monster which the player takes control of moving into the next phase.

The coral monster created by the player has its parameters altered by the various types of minerals and enemies fed to it during growth. For example, a certain mineral may increase the speed of the coral monster, while certain enemies may have increased the coral monster’s melee attacks. These effects are amplified by having more of a single type of resource being fed to the monster.

I put a lot of thought into this one, but ultimately was unable to come up with a satisfying second phase that made sense with the flow of gameplay. I think this idea has a lot of potential, but needs more time to commit to it to reach a good point.

Concept Selected: Concept 2: Flying Tree Spirit Fueled by Water

Ultimately I chose concept 2 to move forward with. It still needed work to get to an interesting point, but I think it fit the best balance of simplistic foundation with a lot of room for growth depending on how much time and effort I wanted to put into it.

Summary

Again, I was just underestimating the time necessary to put into initial concept selection and creation so that used a lot of my starting time with this project. I need to get better at determining when to let an idea go earlier and focus on the others.

Sketching concepts out is generally helpful for me, but being unskilled with Photoshop was slowing my process down a bit. I normally sketch with pencil and paper and that works well for me, but I want to get better at using Photoshop for this purpose since I think it will bode well for me in the future.

Personal Game Jam 1 – Concept Creation

digm520admin / / GameDesign, GameJam
April 23, 2020

Personal Game Jam

Concept Creation Meetup

Game Jame Idea

I wanted to work on a smaller scale project personally to practice some programming techniques and systems I have picked up recently in a more practical sense, as well as focusing less on long term and large scale scaling of projects. This way I could focus more on trying to find solutions that work as opposed to the best solution, so I could continually progress and try out some new skills I have learned.

This led to this idea of creating a personal game jam for myself following similar rules that I used in an experimental games class to create projects. The game jam approach makes sure I don’t spend too many days on it. I am planning on spending about 5 – 6 hours on it for 2 days and seeing where I get with it.

Initial Concept Generation

The approach we used to come up with inspiration for a small scale project in experimental games was as follows in pairs of 2:

  • Start with a single key word: I chose Earth in honor of Earth Day
  • From that word, choose several words (usually 3) that first come to mind (alternating with partner) to create your tier 1 words
  • Repeat this process with all your tier 1 words to create tier 2 (so usually ~9 words)
  • Repeat until you have 3 or 4 tiers of words (can reduce number of words per word later so you don’t have a ton of words)
  • As a pair, agree on one word from each tier that you like the most (you must include the starting key word as your tier 0 word)
  • Use this group of words as inspiration for several game concepts as individuals
  • Bring them together to narrow it down to your favorites and see what collaborative ideas you can make
  • Flesh these ideas out and finally choose your project topic

We did this process in experimental games with a single partner, but I organized a group with three of my friends, Marino, Nick, and Justin, to do this process online. Since I am the only one actually creating a project, we needed to make some modifications for this process to work with effectively a group of 4.

When choosing our words, I decided to expand it to 4 words per word so each person got to contribute a single word for each word as we expanded tiers (until we got to tier 2, where I just had us do 2 words per word and broke it in half for two separate tiers, 3 and 4).

Here is the list of words we generated:

Generated Word List

Word Selection

I find having to agree on the best words from each tier with someone else to be a useful process, but thought that agreeing on a single word with 4 people would be a bit much. To get around this, I split us into 2 pairs that did the process separately with the same group of words. Here are those lists we generated:

Pair A Words – Justin and I

Pair B Words – Marino and Nick

Initial Concept Building

We stayed separated in our two different pairs here to come up with basic game concepts over the course of 30 minutes. We decided to come up with 3 concepts each as a pair and come together to go over them.

Pair A (Justin and I) Concepts:

  1. You are a large crystalline space coral monster that consumes resources to grow and produce more coral monsters.
  2. Tree person that sucks up water in their roots to fuel a water cannon which propels them into space to mine resources. They can grow and upgrade to hold more water.
  3. Focus on the differences between water and space and the interesting physics each presents, as well transitioning between the two to create interesting game mechanics.

Pair B (Marino and Nick) Concepts:

  1. “Platformer where you can build things out of…WHIPPED CREAM (foamy substance) and you can apply PAINT to give the WHIPPED CREAM different properties. Different amounts of WHIPPED CREAM and PAIN(t) per level. He’s actually just drawing with whipped cream in a big ole’ cup of coffee.”
  2. “Multiplayer??? game where players are shown a beautiful PAINTing to recreate using WHIPPED CREAM. One player is the judge, the rest PAINT. Weird mechanics for the WHIPPED CREAM: gets more liquid-y over time, slides down the page the longer it sits. “
  3. Puzzle platformer where you can paint trees in the environment to match one of the four seasons to give various platforming effects to get through areas.

Final Concept Steps

With these 6 concepts together, I personally took them to build off of them and flesh them out (if possible) to decide on the one to move forward with the next day. I thought Pair B’s concepts were already decently formed so I did not need to spend much time with them, so I mostly needed to focus on building up Pair A’s concepts.

Summary

Overall I think it went pretty well. I underestimated the time needed to come up with concepts and flesh them out, so I will look to give that more time moving forward. I forget from my experimental games class we normally took our words home with us to think of concepts for one or two full days before reconvening to go over what we came up with as a pair, so something like that may be better in the future. I do have to say I was pretty pleased what we were able to put together in just 30 minutes though.

As the organizer of this tiny event, I was the only one sharing my screen for the majority of it to help facilitate the process. I would like to look into something where everyone could possibly draw on the same area (or share their screens to draw on) to help illustrate ideas with simple sketches, since I find that very helpful in this phase.

This was all done in preparation for my personal game jam, so I did not particularly include it in the general game jam time window. This doesn’t really matter since the timing is fairly arbitrary, but I did like having it as its own separate event leading up to my work time instead of also including in the game jam work time like a general game jam would function.

GDC 2020 Talk – Cursed Problems in Game Design

digm520admin / / GameDesign, GDC, GDC2020, Talks
February 6, 2020

Cursed Problems in Game Design

GDC 2020 Talk

GDC 2020: Cursed Problems in Game Design

Video – Link

By: GDC – Alex Jaffe (Riot Games)


Notes

Cursed Problem: an unsolvable design problem, rooted in a conflict between core player promises

Politics: competition through social negotiation, alliances, and manipulation

The main skill here is identifying cursed problems so you know to avoid them or navigate them so you do not waste time on “solving” them.

Examples from Talk: Hard or Cursed?

No Man’s Sky: Exploration game with millions of worlds
Hard: This was evidenced by the game becoming successful after significant time updating the game, but it easy to see this was just a hard problem and not an impossible one.

Diablo: Loot games with efficient trading
Cursed: Many loot experiences are just incompatible with efficient marketplace trading systems because the loot experience relies on the random drops themselves feeling unique or special to the player, but having a market to deal this loot for other loot just makes every type of loot “gold”, or currency, and the specialness of all drops is significantly hampered.
Commodified Reward Problem supports this idea.

Pokemon GO: always-on location-based games
Cursed: These games look to provide an augmented reality layer to real life for rewards, but the counteracting topic is just the general need for personal safety and convenience. The main core of it being cursed is that one is “play anywhere/any time” and the other to make them safe is to “only play when appropriate”.

4 Core Solution Techniques for Cursed Problems

The 4 techniques are: Barriers, Gates, Carrots, S’mores

Barriers

Cut affordances that break promises

This technique focuses on just preventing the player from performing actions that would break the design promise.

Exapmle: Free-For-All Politics (Fortnite, or any large battle royale game)
Approach: Limit player’s agency over one another
Sacrifce: Some of the PvP fantasy of control
The game is so large scale with so many players, high amount of missing information, and high lethality so the political game is not very feasible to develop. It is hard to create an alliance or single out a specific targeted player with all of these variables. This however removes the feeling of “I have outplayed you specifically” or the personal level of domination since the game is so large scale.

Gates

Hide bad states behind challenge

This technique aims to make it harder to find bad ways to play the game so that players will hopefully focus on the good ways intended.

Example: Free-For-All Politics (Playstation All Stars: Battle Royale (4 Player Brawler))
Approach: Limit visibility of players’ success
Sacrifce: Some of the tension of buzzer beaters
They hid the score of each player, and made the scoring system a bit convoluted (2 * kills – deaths) so it was harder to reason out in the middle of the high paced game. This was done to encourage every player playing their best with less fear of being targeted for being in the lead and reduce politics factors. Not being sure of the score however can reduce high tension moments near the end of the game sine no one is really sure who is in the lead and you do not even know who won until they game tells you.

Carrots

Incentivize avoiding the bad states

Provide incentives for players that do not go into the bad game states.

Example: Free-For-All Politics (Catan tournament)
Approach: Add meta-game effects
Sacrifice: Magic circle of an individual game
In a Catan tournament, players play many games and their standings are used to add to their total score for placement. This makes getting first less of a “be all, end all” scenario and incentivizes each player to just do as well as they can. They suggest this ends up reducing overall politics in the game since players are continually incentivized to do their individual best. The con however is that it just makes each individual game feel less special or “magical” to play.

S’mores

Make it fun

This technique leans into the bad states of the game and just make them fun to play as well.

Example: Free-For-All Politics (Diplomacy)
Approach: Give players tools for deep political play (e.g. secrecy)
Sacrifce: Emphasis on moment-to-moment action
The game of Diplomacy goes hard into the politics with secrets and deception along with the gameplay, which can make the political aspects more fun and interesting. This however generally makes the game itself feel like it is taking a backseat (in this case your plays with your units) and leaving players mostly focusing on the relationships they make or break along the way.

Summary

Do not think of these as solutions, but as a small design framework. These techniques were identified to help you approach difficult problems you find in the design process for making a game to help you navigate them more efficiently. It can also just be beneficial to understand some problems are not “solvable” and you will have to make sacrifices to accomplish some goals or mitigate some negative aspects.

Challenges

These were some challenges given as examples of problems so cursed that they really have not been approached very much.

These are the challenges:

  • Balanced player-generated content in multiplayer games
  • PvP games in which all players feel there was a just outcome
  • Mystery and discovery in the age of the internet

The last challenge really resonated with me as something I have investigated, specifically through the concept of procedural content generation.

As an avid Pokemon player I would always go into the new games knowing every new pokemon from information released before hand, whether it was from strategy guides back in the Johto days to the games in the Alola region. I however stumbled upon player made rom games and played them mostly blind and enjoyed them much more. The sense of discovery and figuring things out was so much more interesting and refreshing.

I then got into Pokemon randomizers where you can randomize as much or as little as you want, and that game fresh new life to old games I had played. This gave me the idea for using procedural generation, something akin to the rogue likes of today, but in a more exploratory or experimental way. I think you could look into procedural generation of the rules of the game as opposed to just specific content, and the player could have consistent ways to discover these rules playing the game each time. This way the player’s skill of discovery is really what is emphasized and rewarded as they get better, and they use this core skill to get better at whatever world they are put into.

How Command & Conquer: Tiberian Sun Solved Pathfinding: War Stories: Ars Technica

digm520admin / / AI, GameDesign, Informative, Pathfinding
December 18, 2019

War Stories

How Command & Conquer: Tiberian Sun Solved Pathfinding

How Command & Conquer: Tiberian Sun Solved Pathfinding | War Stories | Ars Technica

Link – Video

By: Ars Technica


Working on Pathfinding

Pathfinding, especially in a dynamic sense, is still a relatively expensive process to run. This is much more so when you are trying to apply it to a lot of units.

Tiberian Sun was running into a lot of issues they called “Artificial Idiocy”, which is when your AI just does really dumb stuff. Really illogical AI from a player’s game units very quickly make the player mad and aggitated. They say “If you spend more time making sure it doesn’t do something stupid, it will actually look pretty smart”. And to follow up, they didn’t need perfect pathfinding, they just needed “not stupid” pathfinding.

Some of their fixes included not accounting for the collision of other friendly units selected to move and wiggling stationary friendly units when encountered by moving friendly units. Not accounting for other selected friendly units made sense since most likely they would also be going to about the same place and would generally be out of each others’ ways. The wiggling was added as very simple to execute logic in hopes that it would “unlock” a path previously obstructed by the stationary units.

SUMMARY

This was just a cool video I stumbled upon pretty randomly. It was very interesting to see some of the “behind the scenes” for one of my first favorite computer games to play a long time ago. There are just so many things you take for granted that took a lot of hard work and were almost revolutionary for their time.

It is also interesting to see that some problems still exist to a degree, like the prcoessing intensity of dynamic pathfinding. I think my research in pathfinding recently is what brought this video recommendation to me on Youtube, so I have at least had a small taste of the pains they went through developing that. I also really like their thoughts on just minimizing the terrible choices of AI instead of maximizing its “smart” moments to make it nicer to work with and really look smarter in the end.

digm520admin / / AI, Book, GameDesign, Games, Readings

ARTIFICIAL INTELLIGENCE FOR GAMES – by Ian Millington, John Funge

October 1, 2019

Book

ARTIFICIAL INTELLIGENCE FOR GAMES

By: Ian Millington, John Funge

This was just an interesting reading I came across for a gaming AI class, so I wanted to note it for the future. It looks like it covers a lot of interesting topics so it could serve as a nice foundation for starting to understand a lot of the basics on gaming AI.

level-design.org and a GDC Talk on Level Designers

digm520admin / / GameDesign, LevelDesign
January 15, 2019

Level Design – Resources

Talks and Online Source

Youtube – GDC 2015 – Level Design in a Day: Level Design Histories and Futures
level-design.org site

These have been helpful level design resources for games that were brought up in our class today for Architectural Approach to Level Design. While not particularly useful now, they could be good resources to go back to.