Oct 24

The eight-year reconnection – Chain Factor to Universal Paperclips

Back in 2009 I was fairly obsessed with Chain Factor – a game by Frank Lantz that would later become Zynga’s Drop7. I got good enough at it to be a consistent name in the all-time ranked leaderboard, always trading top 10 scores with some other person whose user handle i can’t recall anymore, so i decided that I wanted to record a video of me doing a decent run. The run took 22 minutes, and at the time YouTube’s maximum video length was 10 minutes, so i had to find a way to edit/speed it up.

That led to me creating my first real video editing project that i eventually titled Chain Factor Chaos:

It’s a pretty rough final product execution wise, and conceptually i don’t like what I did with the first big “section” anymore (the first 3’40”), but I’m still incredibly happy with the rest of it leading to the recap transition (3’40”-9’00″ish). A part of me would love to take a second crack at it given the sort of video editing chops I have now, but a) i don’t know that I still have access to the source video anymore, and b) if it came down to it i’d rather do something new from scratch than re-hash an old project.

In any case, when I posted my blog entry that talked about the project, Frank Lantz happened to come across it and commented on it saying how much he liked it. I remember feeling very touched (and, truth be told, a little overwhelmed) that he took the time to write to me. I wrote him an email to say “you’re welcome”, and we had a brief email exchange where he gave me more nice words about it. After that exchange, that was that.

Fast forward eight years later to yesterday.

Recently, a new browser game called Universal Paperclips has made the viral rounds. It’s what some people classify as an “idler”, and it’s a game type i’ve enjoyed playing in the past, so when my brother shared it with me, I said, “sure, i’ll give it a shot.” After I finally finished the game (which ended up taking a few days), there was an end credit line that said, “(c) 2017 by Frank Lantz”.

And i was like, “i recognize that name… oh! It’s the Chain Factor guy!” It took me a moment, but even after eight years I remembered who he was, the interactions we exchanged. So i found him on twitter, and said, “hey, i just finished your new game, remember me?” and he tweeted me back and said, “Of course!”, said he still found the video amazing, and it was nice to reconnect. I told him that his game was great and that I was going to play it as part of a video game marathon for charity, and he tweeted a link to my charity page and also gave me a donation.

Such a random eight-years-apart reconnection made with a damned awesome guy. I might start using twitter more often because it definitely shouldn’t be another eight years before we interact again.

 

Oct 12

Thoughts about my Buffer Loop Patches

I’ve created a Buffer Recorder and Buffer Loop engine for Minkowski Etudes for Dylan and I’ve hit upon a small programming snag that means I might have to modify how I tag loops and how they end.

Some background first:

This is my BufferRecord patch:

It’s pretty straightforward – you give a command for what buffer you want to record into, it activates the recording and sets a timer to track the length of time recorded. When you’re done recording, it turns off the Record function and stores the length in ms into a list that it can then use for reference for looped playback (because otherwise it would loop the whole buffer which i’ve set at a default for 20s).

This is my Loop patch:

There’s a lot of small things going on there, but the relevant point to this entry is that the actual engine for playback is going through that [poly~] object. [Poly~] is a way to “clone” a subpatch with multiple instances without actually copy/pasting those individual instances which necessitates routing signals to those individual instances via cumbersome gates and switches. Everything is instead set by a single [poly`] object that has a definable number of “voices” that can be dealt with all at once or individually. In this patch I have 16 different voices. When a loop is activated, a counter iterates to the next [poly~] voice and then all of the loop info is assigned to that voice – it iterates to one voice higher in number to the one that was last used, so if the last voice used was 8, the next loop activation chooses voice 9.

Here’s the patch that exists inside of the [poly~] object: 

The [groove~] object is what actually plays the loop. I send in the buffer name to loop (which replaces the default i created “Buffer1”) as well as all of the variables of loop start/end time and speed.

The problem is: since i’m not personally tracking which [poly~] voice is being used for an individual loop (because i just have the counter iterating to the next available voice), I needed to find an alternate way to find a specific loop within a voice instance so i could end just that specific loop as needed. I decided to use the Buffer name (in this instance “1-01”) as a means of doing that, so if i send the command [LoopEnd 1-01], it would find the [poly~] voice that’s looping 1-01 by name and then turn it off. Except what if I want to run multiple voices with the same buffer simultaneously and I only want to turn off some of those voices later? Sending the command [LoopEnd 1-01] would turn off all voices that hold a buffer named 1-01 at once with no ability to deal with that partially.

There’s a few different ways to address this. The quick and dirty method is to take any instance in which i want the same buffer materials looped and write that material into multiple buffers. That way, voices in the [poly~] will never have duplicate names. It’s sloppy and would require a ton of extra CPU buffer depending on how many copies of a single buffer i would want to create.

A more programmatically clean but inflexible way is to identify the loops by poly voice only with no concern for what’s there. That could create some potential problems down the road if, say, one Record Buffer fails to trigger or the counter iterates wrong or something and now sample 1 is not located in voice 1 where it’s supposed to be and i accidentally activate or cut the wrong loop.

The most airtight but most difficult to program way is to somehow link the name of the sample with either the voice it’s connected to or its simultaneous iteration number and then somehow program LoopEnds to know which voice each simultaneous iteration is connected to even if that voice is different every performance. As i type this out, I may have a strategy to address this, but I still need to work out some of the details in my head to make sure it will work. If it doesn’t, i’ll probably go quick and dirty and hope that my laptop can handle the CPU load that would be necessary. We’ll see what happens.

Sep 07

Brainstorming an arrowsmash/fighting game hybrid

Fighting games have evolved a great deal since I abandoned them in the decline of arcades (the last real fighting games i took with any degree of seriousness were Marvel vs Capcom 2 and Killer Instinct 2 back in the early 2000s), and in attempting to regain some relevance and competency in the genre in the form of Injustice 2, I’ve learned just how important frame data and knowledge of that frame data is for competitive fighting game players:

This has some parallels to the old competitive music video game scene (the most popular in the US being Dance Dance Revolution) where the degree of precision to hit a “marvelous” window or “fantastic” window was defined in milliseconds (but the calculation of such varies depending on the game). But there’s a fundamental difference between competitive music video games vs fighting games – in the former, the competitive aspect comes from two players who are independently trying to perfectly execute a stepchart but otherwise don’t have any interaction with each other. In the latter, competition is entirely conversational – competitors are directly interfacing with each other, reacting to each others’ attacks and defenses, and playing rapid constant mind-games with their opponent in efforts to trip them up and not get tripped up themselves.

At some point in the last couple of weeks, a notion came to me: what if there was a way to combine the two?

A “Battle Mode” in dancing games has been tried in the past (particularly in stepmania and the stepmania-based ITG) where reaching a landmark of execution would throw “mods” at the opponent’s screen in an attempt to trip them up:

 

but this is unsatisfying because the stepchart itself doesn’t vary, or even if it does, the player doesn’t have direct control over how those arrows are changed – particularly rhythmically. So “defenders” of mods are merely reacting to a change in visual presentation of the same predetermined script of arrows and the “attacker” has about much influence on the defender’s gameplay choices as a single person in Twitch Plays Pokémon.

So i started brainstorming for gameplay ideas/components that could successfully merge the two genres together into a single hybrid eSports-worthy game.

Idea 1: Dance Game Simultaneous Call and Response – Set up designated times within a stepchart where each player “records” their individual steps and then has to execute the others’ recorded steps immediately after.

For example, suppose measure 2 of a chart is set up as a “record” measure and measure 3 is set up as a “execute” measure. As the second measure scrolls by, each player steps whatever they want during that measure and then in measure 3, the recorded steps are scrolled on the opposite side for the other player to step accurately. Quicker pressure can be made from creating record/execute patterns of half measures or single quarter note beats, or bigger forms can be created if record/execute patterns are multiple measures, like every 4 or every 8.

There are two potential pitfalls to this. One is disparity in skill level. If player one can AAA the end of PSMO in their sleep but player two struggles with basic skills, player one could use their “record” function to perform something they know their opponent can’t do. For competitions that’s fine and dandy, but for casual and “building the community” sort of play that wouldn’t be appropriate. This could maybe be solved by creating difficulty settings that compensates for that – if player two sets a difficulty of “easy” against player one, player one’s recorded steps that are quicker than eighth notes get discarded, for example (and maybe vice versa where simpler steps have other steps added to make it more challenging). The logic behind that would have to be complicated to make it work out to still be idiomatic.

Second issue would be: what if a player is not great at executing arrows with the beat or what if the player decides to deliberately execute a flurry of random arrows not on the beat? Quantization might help address that, but how is it decided whether execution of recorded steps are either sloppy/sabatoge-y versus legitimate? You wouldn’t want, say, the 24th notes of Go 60 Go Expert to be quantized as sixteenth or 32nd notes and thus stifle creativity at a more professional level.

Idea 2: Fighting Game Attack/Defend Arrow Pattern Scripting – Create a cast of characters that have their own “move lists” (like a regular fighting game) that’s executed by various arrow patterns for attack and defense.

For example, suppose that each character has three basic arrow patterns that executes “rock”, “paper” and “scissors”. While the music is playing in the background and still with some sort of pulsing arrows or indicator, one player could execute patterns for “rock, rock, scissors” as an attack that the opponent then has to execute “paper, paper, rock” as defense. A player could switch between attack and defense by doing a “toggle” pattern and have to make quick judgement on whether to attack or defend based on the timing of the opponent’s own attack and defense as well as some balancing rules for frequency of attack or defense (like how in Injustice 2, you can’t have a B3/F3 continue a combo if a B3/F3 was already used in a previous part of the combo).

After basic attacks, each cast member could also have their own unique “special moves” – arrow patterns of attack and defense that can deal or absorb more damage or need to have specific reactions against them. Special Moves can be more complex patterns or they could even be slight variations of basic patterns – for example, maybe if “rock” is DFU then “special rock” could be DDFU – something that looks similar but with slight variation. The opponent then needs to throw “special paper” to defend against it, which requires them to be particularly observant and quick about recognizing the difference between “rock” and “special rock”. Other special moves could also throw mines or require extra arrow inputs for basic attack or defense moves of their opponent.

If executed in the right way there aren’t any immediate pitfalls in my mind, the main challenge stems from the fact that there’s no real model for a game like this so it would need to be conceptualized and designed from scratch.

Could something like this gain traction? It’s hard to say. While fighting games still have relevance in today’s video game and eSports world, the competitive music video game scene died years ago in the US. I posit that a lot of that has to do with the rise of home console and internet quality – multiplayer console and PC gaming can happen in the comfort of the home with people across the globe in real time, whereas dance games have always required actual arcade play because of proprietary and quality controllers/dance pads to be truly competitive. A home market for network-based competitive dance gaming seems unlikely too because quality dance pads require extra physical real estate and a price point that could not attract a casual player.

Still, there might be a good avenue for this in the future in some form. We’ll see if i have the time and energy to move it past a conceptual stage and what it’s potential and viability is.

Older posts «