Pokemon Randomizers – Universal Pokemon Randomizer, UPR ZX, and pk3ds – Github Links and Intros

August 23, 2021

Pokemon Randomizers

Resources


Title:
Universal Pokemon Randomizer

By:
Dabomstew


Github – Repo #1

Description:
Original top level pokemon randomizer for generations 1 through 5.


Title:
Universal Pokemon Randomizer ZX

By:
Ajarmar


Github – Repo #2

Description:
Extended work from original universal pokemon randomizer that works for all original handheld generations 1 through 7.


Title:
pk3ds

By:
kwsch


Github – Repo #3

Description:
Randomizer for the 3DS pokemon games, which were generations 6 and 7.


Overview

I have always been a huge fan of pokemon randomizers for their ability to add replayability to games I am always looking to replay with different variations. I wanted to collect and archive some of the best current tools for doing so in one place to make them easy to reference, especially through their github repos since I am interested in seeing if I can make any contributions to add fun and exciting randomization settings.

Universal Pokemon Randomizer

This is the original randomizer tool that became the main standard for randomizing most pokemon games. It has a lot of very nice options and has just existed for a while now so its errors are not found as often and are generally more minor.

This however is limited in that in only works for pokemon generations 1 – 5, leaving a few on the 3DS unable to be randomized. The project was put on stop and archived as good enough, but it was recently continued with the ZX version to add further generation support. I will also note it is written almost exclusively in Java.

Universal Pokemon Randomizer ZX

This is an extension of the original Universal Pokemon Randomizer that adds support for generations 6 and 7 on top of the original 1 – 5. This appears to be relatively active and growing (with changes submitted between 2 months and 4 hours ago as of the time of collecting this information).

With how great the original tool is, I would love to explore this option with the newer generations. I have not personally tested this randomizer tool since it is on the newer side, but I’ve seen some cases for it working which look promising. As a continuation of the original Universal Pokemon Randomizer, this is also written primarily in Java.

pk3ds

This tool was created to fill the gap the original Universal Pokemon Randomizer had, as this tool was made specifically to randomize the 3DS pokemon games which cover generations 6 and 7.

With less background and time to mature, I remember it having a bit less flexibility in its options compared to the Universal Pokemon Randomizer, but it worked well for the primary need of shuffling the major content of the game. Being its own separate tool, this one is actually written majorly in C#, which fits directly in my wheel house.

via Blogger http://stevelilleyschool.blogspot.com/2021/08/pokemon-randomizers-universal-pokemon.html

HFFWS Thesis: Clearly Determining Space for Scenarios and Creating Barriers Between Them

March 11, 2020

Spacing Scenarios and Dividing with Obstacles

Thesis Project

Space Buffering

In the process of creating a simplified version of this generation system, I narrowed down the variability for now with a core focus on better defining the space a scenario has to work with. To keep it easier to work with, it is focused on a single axis for the most part, the x-axis, in spacing. This ties in to making the general space easier to define as well.

The overall spacing is mostly determined by spacing on the x-axis. The entire sequence of scenarios is constrained to a single overall platform with a fixed width, so every scenario is working with that same fixed width as well. The height does not particularly need to be constrained at this time, so determining a general x and z dimension for the space with an arbitrarily given y dimension works to define our space well for now.

Finally, to help visualize this space in the editor, I looked to DrawGizmos methods within Unity. I am currently creating a yellow wireframe cube centered at each of these central scenario locations with dimensions based on the scenario spacing (x-axis), the scenario width (z-axis), and an arbitrarily large height (y-dimension), each of which is determined within the DemoManager.

Creating Obstacles to Sequence the Scenarios

We wanted to start looking into having the chain of scenarios play into each other, so the first concept to look into for that was creating significant obstacles at the “end” of each scenario that needed to be overcome to reach the next one. The idea for the simplest approach for this was to create a significantly tall wall that covered the entire width of the play area and was placed at the end of the scenario space (the end on the x-axis). Again, to simplify the approach, this was investigated solely with ramp scenarios for now.

Creating this wall originates with using the existing CreateObstacleTerrain class I created, which basically makes various rectangular-shaped obstacles. The scenarioWidth information is passed into this creation to ensure that the wall covers the full width of the play area. The scenario spacing information passed from the DemoManager helps with the placement of this wall at the end of the scenario.

The order of operations follows that the ramp is generated, and then the obstacle. With this, the ramp height is recorded and passed on to the wall to determine its height range. This ensures the wall is tall enough to provide a challenge, but not so tall that it can not be overcome.

Finally, to help position this obstacle even more accurately, it is actually repositioned after its parameters are determined. The systems chooses the wall obstacle’s dimensions from its available options, and then feeds this data into a method to finally place the wall. This helps adjust the position of the wall for its thickness especially when making sure it fits in the end of the scenario area without going into the next area.

HFFWS Thesis: Starting Ramp Puzzle Generation

March 5, 2020

Ramp Puzzle Scenario Generation

Thesis Project

Notes

I have added the basic foundation for creating ramp scenarios in my HFFWS generation system for my thesis project. This starts with simply making very standard full ramp objects with a corresponding obstacle object.

The ramp objects are the most straight forward ramp shape, being a flat angular shape. They are scaled randomly given a range of parameters for all three dimensions. These are generated first, and then the obstacle is generated with data passed from the creation of the ramp. Right now it just accepts the height data from the generated ramp and uses it as the new maxHeight option for the obstacle. The idea is that this will keep the obstacle from ever being out of reach of the ramp (but this will actually require the tweaking of a few other parameters as well, such as positioning).

Sample Image of 5 Generated Ramp Scenarios

Basics of System.Random in C#

February 14, 2020

System.Random Methods

C# and Unity

Random Class (from Microsoft)

Information – Link

By: Microsoft


General Methods Looked Into

Random.Next

This selects a random integer either between 0 and maximum value, or between two different designated values.

Random.NextDouble

This generates a random floating point value between 0.0 and 1.0. This is the main one I will be looking to use since I have a lot of parameters where floating point values make sense, however since it only returns values between 0.0 and 1.0 specifically, I will have to just use it as a random multiplication factor.

Random.NextByte

This requires an input of an array of bytes. It will then fill that array with random byte values.

Why I am Investigating

My thesis project uses a lot of random values with its focus on varied procedural content generation, but I want to control the randomness a bit more with the implementation of a seeding system. A tutorial I did a while back on cellular automata uses a very basic seeding system for its randomization that I was looking to copy. It centers around this line where seed is just a string variable that can be set in the editor:
System.Random psuedoRandom = new System.Random(seed.GetHashCode());

As long as the seed string is the same and a value is randomly selected using this Random variable psuedoRandom, the value selected for that particular case will remain the same over multiple plays of the program. This helps provide control and consistency to the random system generation so if I find good samples they can be recorded by their seed string.

Random.Next and Random.NextDouble are going to be the main two that I use, as they help generate random ints or random floating point values (doubles that can be cast as floats if necessary). Random.Next will be very useful in cases where I am generating a specific number of objects, where Random.NextDouble will be used to generate the varied values for parameters that are within specific ranges (such as the length or size of an object). As noted previously Random.NextDouble can only specifically generate values between 0.0 and 1.0, so it will be used as a random multiplication factor to get the results I need.

Notes on Research Paper: Automatic Game Progression Design through Analysis of Solution Features by Butler et al.

November 19, 2019

Thesis Research

Notes on Resources

TITLE:

Automatic Game Progression Design through Analysis of Solution Features

AUTHORS:

E. Butler, E. Andersen, A. M. Smith, S. Gulwani, and Z. Popović

IEEE Citation – Zotero

[1]E. Butler, E. Andersen, A. M. Smith, S. Gulwani, and Z. Popović, “Automatic Game Progression Design through Analysis of Solution Features,” 2015, pp. 2407–2416.
ABSTRACT
– use intelligent tutoring systems and progression strategies to help with mastery of base concepts 
as well as combinations of these concepts
– System input: model of what the player needs to do to complete each level
– Expressed as either:
– Imperative procedure for producing solutions
– Representation of features common to all solutions
– System output: progression of levels that can be adjusted by changing high level parameters
INTRODUCTION
– Level Progression: “how game introduces new concepts and grows in complexity as the player progresses”
– link between level progressions and player engagement
– “Game designer Daniel Cook claims that many players derive fun from “the act of mastering 
knowledge, skills and tools,” and designs games by considering the sequence of skills that the 
player masters throughout the game [11].”
– *** Why we want to have system produce similar but varied versions of the same type 
of experience
– “Intelligent tutoring systems (ITS) [29, 22] have advanced the
teaching potential of computers through techniques that track
the knowledge of students and select the most appropriate
practice problems [8, 12].”
– “We aim to enable a different method
of game design that shifts away from manual design of levels
and level progressions, towards modeling the solution space
and tweaking high-level parameters that control pacing and
ordering of concepts”
– *** Possible major goal of my research
– “Andersen et al. [1] proposed a theory to automatically
estimate the difficulty of procedural problems by analyzing
features of how these problems are solved”
– Procedural Problems: those that can be solved by following a well-known solution procedure
– i.e. Integer division using long division
– Procedural Paths: code paths a solver would follow when executing procedure for a particular 
problem
– Use this as a measure of difficulty
– “This is mainly because Andersen’s
framework does not account for pacing. In contrast,
our system allows a designer to control the rate of increase
in complexity, the length of time spent reinforcing concepts
before introducing new ones, and the frequency and order
in which unrelated concepts are combined together to construct
composite problems”
– *** Another goal/direction for my research
RELATED WORK
– Intelligent Tutoring Systems have “several models for capturing student knowledge and selecting 
problems”
– *** Possible future work research
– “Generated levels are not useful in isolation; they must be sequenced
into some design-relevant order, called a progression”
APPLICATION
– Game called Refraction
– split lasers into number fractions that need to satisfy certain values at end
SYSTEM OVERVIEW
– Level: “any completeable chunk of content”
– Level Progression: “sequence of levels that create an entire game”
– Solution Features: “properties of the solution to a level”
– “need to be able to extract features from the levels that can
be used to create an intelligent ordering” for progression
EXTRACTING SOLUTION FEATURES
– Example of following procedural traces and n-grams within the exercise of doing hand subtraction
– Certain steps have a letter output that is recorded to see if a certain type of step 
was used and how often (i.e. Was borrowing necessary for subtraction?)
– n-grams: n-length substrings of the trace
– Example: Trace = ABABCABAB
– 1-grams: {A, B, C}
– 2-grams: {AB, BA, BC, CA}
– 3-grams: {ABA, BAB, ABC, BCA, CAB}
– 1-grams are fundamental concepts
– Compare complexity by comparing n-grams
– They used these general concepts to build their own similar, but not identical, system
– their game didn’t fit this model perfectly well, so they broke their game down into 
graph objects that they thought were more representative
– they had fundamental graph objects (similar to 1-grams), that could then build into 
more complex graph objects by combining these defined fundamental graph objects
AUTOMATICALLY GENERATING LEVELS
– “We applied the level generation process described by Smith et
al. [30] to generate a large and diverse database of puzzles”
– *** Look into this for our system?
CREATING A PROGRESSION
– n-grams = graphlets (their specific type of n-gram)
– “To summarize, given two levels L1 and L2, L1 is considered conceptually simpler if, for
some positive integer n, the set of n-grams of L1 is a strict subset of the set of n-grams of L2″
– if a level contains the steps required for another level, it is more complex (has the same and 
more basically)
– Because of several issues, their approach was create a rather large library of generated levels 
to choose from, and choose a select few that represent an effective progression
– model tracks whether player has completed a problem containing each component
– also track n-grams of those components (up to very small n as values get exponentially huge)
– hard to know what to do on failure
– General Framework:
– set of problems
– domain of concepts
– player model
– These three things are what are used to generate sequence of problems for the player
– Choosing the Next Problem
– given current model state and set of problems, what is appropriate next problem?
– dynamic cost model
– cost of problem, p, is weighted sum of the n-grams in the trace of p
– weight has 2 components:
– one based on what model knows about player
– one designer-specified weight
– Player Model Cost:
“First, at each point in the progression, for a given n-gram
x, the player model assigns a cost k(x). This cost should
be high for unencountered n-grams and low for ones already
mastered, which will ensure more complex problems have a
higher cost than simpler ones with respect to the player’s history”
– Designer Added Cost:
“as expert designers, we know
(possibly from data gathered during user tests) that particular
concepts are more challenging than others or should otherwise
appear later in the progression”
– “Thus, given a library of problems P, choosing the next problem
pnext consists of finding the problem with the closest cost
to some target value T”
– “In order for this sequencing policy to be effective, it requires
a large library of levels from which to choose. The levels
should be diverse, covering the space of all interesting solution
features. Furthermore, in order to enable effective control
of pacing, this space should be dense enough that the progression
can advance without large conceptual jumps”
– *** Supports need for my thesis work

Unity Procedural Landmass Generation by Sebastian Lague

October 21, 2019

Procedural Terrain Generation

Tutorial

Procedural Landmass Generation (E01: Introduction)

Tutorial #1 – Link

By: Sebastian Lague


This is the beginning of a procedural landmass tutorial by Sebastian Lague. This appears to get move involved in setting up noise with more controlled variability along with shading and other interesting tricks. This will compliment a procedural terrain tutorial I followed by Brackeys since this gets much more involved and gives many more designer options.

Procedural Fence Asset in Houdini

May 20, 2019

Houdini Procedural Fence Asset

Vimeo – Intro to Procedural Modeling in Houdini: Making a Fence Asset

By: trzanko

Notes: Projecting Curve down onto surface – make sure curve is entirely above surface first – done by transforming this up in y an amount equal to the bounding box of the terrain – can use Ray node – used wrangle – VEXpression to project curve onto terrain: vector rayd = {0, -100, 0}; vector hitP, hitUVW; int hitPrim = intersect(1, @P, rayd, hitP, hitUVW); @P = hitP; – this has every point fire a ray downward and determines where this ray intersects the terrain, and then sets that point’s position to the intersection point Create Orthos – used a Polyframe node – turned off the Normal Name and reassigned the Tangent Name to “N” – this made all the point normals basically follow allong the curve – use VEXpression to direct normal vectors – used wrangle: – VEXpression: vector up = {0, 1, 0}; v@side = normalize(cross(up, @N)); v@up = normalize(cross(@N, v@side)); – Seeing as this did two cross products in a row, I this sets v@side directly perpendicular to the curve (in plane) then v@up creates a vector perpendicular to all of this, including the plane (so this creates a vector that is up from the line) Created the Posts – simple boxes where we polyextruded the top with a bit of an inset Copy Posts to Terrain – Used simple copyToPoints with our post and points along the terrain – this placed their centers at the curve location however, so they were buried half way underground – to fix this, we added another attribute wrangle before the copyToPoints where we moved the points along their v@up vector a distance equal to half of an offsetDistance – the offsetDistance channel then referenced the box sizey so it was always half of the height of the box – this positioned the posts directly onto the surface Starting Fence Links Simple Spread – Made 3 new copies of our offsetDistance wrangle node – the general offset to center the posts went into the first copy – this copy offset was used for the link locations – this copy then went into both of the remaining offset copies – one of these final offset copies had an inverse relative reference to the other’s offset – these were merged – this merge with the combined offsets created a spread, where changing the offset of the one offset corresponded to a reverse offset of the other Creating Separate Staggered Lines – put all of the points of the link lines into a group called cut – used polycut node to turn all of these small line segments between the points into individual prims – used an attribute wrangle with modulus 2 function to basically remove every other primitive – we then used a copy of this setup but with the opposite modulus (when equal to 1 instead of 0) to delete the opposite segments – these were then combined with an offset to give an overall controllable pair of segment groups – this entire setup was then copied to create a second set of links all together Parameterization – Using the offset attribute wrangle we created in several different locations lets us control several dimensions of the fence links – overall distance of links from the ground – distance between the two sets of links – spread distance within a link set itself Creating Links – used a small grid as the base object – used Sweep node to place these all along the link points – used a Polyfill (the polycap they used must be deprecated) to fill in the ends of the links Extra Polish – to make the fence links feel less identical, they added a varied horizontal offset to them – this was done by using another copy of the offset wrangle created, but changing the v@up to v@side – they then added a dir (direction) vector, which used another mod 2 function, but fit the result between -1 and 1 – this was also applied to the offset, so the links would alternate offset directions with each link

Concept for System for Generative Approach for Physics Based Games

January 31, 2019

Thesis – Generative System for Physics Based Games Concept

Text Book Problem Generator

My current thought on a system for developing generative processes for these games is somewhat like making a framework for problems in a physics text book. With the new system I’ve setup for directly tying physics concepts to these physics games (those lists of physics topics), I think I can relate a game’s parameters (those systematic game mechanic values) to the variables of the foundational equations corresponding to that same game’s potential learning concepts. Again, using Angry Birds as an example, let’s say “Impulse and Momentum” is a potential learning concept. A basic equation for momentum is (momentum) = (mass) * (velocity). Using this information, we can see that varying any parameters equivalent to or pertaining to the variables in this equation will require the player to “solve” the new “problem” presented to them by similarly varying their responses to the system.

So for example (an example within an example), varying the bird’s mass parameter directly correlates to varying the mass in the momentum equation. If the player is still trying to meet a similar/certain momentum result, they basically have to “solve” this equation by determining the correct velocity.

I know this might seem a bit obvious, but I’m hoping it’s one of those situations where it just works out so nicely because it’s actually a good solution. This system also presents a fairly basic way of ensuring different in-game scenarios feel differently. You could keep track of the values for the “problems” presented to the player, and just check if a produced “problem” has values that are “too close” to these archived values. Back to the Angry Bird example, a game scenario presented to the player that they needed momentum in the range of (10 kg*m/s – 15 kg*m/s) with a bird of mass 5 kg (so solution range velocity is (2 m/s – 3 m/s)). The next produced scenario is a momentum range of (11 kg * m/s – 16 kg * m/s) with a bird of mass 5 kg (solution range velocity is (2.2 m/s – 3.2 m/s); maybe the system throws this out and generates a new scenario because it sees the momentum range, mass, and solution velocity are all very similar to something produced before.

The needed “distance away” from an archived problem could also be a weighted, combined distance of all the variables that could be tweaked depending on how you want to setup the system. This way, maybe you have another problem with a similar solution value (like the (2 m/s – 3m/s)), but the momentum and mass involved in the scenario are so different that it still feels like a different, interesting experience.

Procedural Generation in Game Design by Tanya X. Short and Tarn Adams

January 7, 2019

Procedural Generation in Game Design

By: Tanya X. Short and Tarn Adams

80.lv – Link to Book Cover

From the link: “Basically, it is a wonderful exploration of the thinking and practice behind procedural generation in games and the way it relates to game design.” This could be a good source to look into for exactly what the title says, procedural generation in games.

GDC Talks – GDC 2018 – Math for Programmers by Squirrel Eiserloh

September 26th, 2018

Math for Programmers: 6 Courses on Procedural Content Generation for Games – GDC 2018

by: Squirrel Eiserloh

There are 6 talks about techniques and implementations of procedural content generation in games. The order is as follows:

  1. The Power of Procedural Recipes – Procedural Recipes
  2. Semi-Procedural Content Pipelines – Semi-Procedural Methods
  3. Staged Parametric Map Generation – Staged Parametric Generation
  4. Digging with Perlin Worms – Perlin Worms (for rivers/roads/caves)
  5. Discrete Constructs in Endless Worlds – Infinite Worlds
  6. Juicing World Generation with Metadata Feedback – Juicing PCG with Metadata