Category: Uncategorized

Superman (Atari 2600) alternate map Romhacks, part 3

After publishing part 2 of this series, I played my grid map romhack a few times, and I think it’s rather good. I don’t know that I would say that I prefer it over the original map, but this is certainly a viable alternative map.

After a few playthroughs, I notice a few things:

  1. The helicopter moves bridge pieces away from the Bridge screen much more frequently. In the original, once you’ve placed a piece at the Bridge screen, the helicopter would only rarely remove it.
  2. The helicopter seems to move pieces from their starting screen much sooner, as well.

I like both of these differences; they make the game more challenging, and I think, more fun. You really feel like you need to race the helicopter to complete the bridge task. But I think it’s worth experimenting with the map to see if there’s a way to restore the original design intent, by reducing the number of paths into the Bridge screen. It occurs to me that an easy way to do this is to make the two screens above and below the Bridge screen connect to each other, rather than to the Bridge screen. So the Bridge will exit vertically to those screens, but reversing course will skip over the Bridge, but still place you near the Bridge; players would need to figure out that they are “around the corner” from the Bridge in this map, which is potentially disorienting, but should be less of a problem than the original map, which puts you clear across into the middle of the other end of the city.

I do think that this map has a few peculiarities that make it sub-optimal.

  1. Some of the subway entrances are right next to their exits. There’s little point in a subway trip that results in you re-emerging on the overworld map one screen over from where you started. For example, the Red subway entrance is one screen away from two of its exits, due to being on the top left corner of the grid, and the wrapping effect. The Blue and Yellow subway entrances are about optimally located relative to their exit screens, and the Green subway entrance is directly above one of its exit screens.

It’s possible to remedy this by moving the subway entrances around, or by changing their exits to more useful screens for this map layout. I was reluctant to try this, because I wanted to keep the changes that I am making to the maps minimal, but it seems that these changes are necessary for the good of the game.

Metropolis 21/7

Another thing that strikes me is that I didn’t need to remove one screen from the overworld in order to have even rows. 21 = 3 x 7, so I could have made an overworld map of 3 rows of 7 screens. This might make the subways more useful, since it would make it easier to place the subway exits such that they are 3-4 screens from their entrances.

A 7×3 grid will allow all 21 overworld screens to be included in the new map. Again, I went to an image editor and re-arranged the screens to make a layout, then visually reviewed and analyzed the map for playabiltiy concerns, and made tweaks.

My first iteration of this was to lay the screens out in the original map’s horizontal sequence, and see how that would play. That map looks like this:

First iteration

Without actually playing it, it’s easy to miss things, but I can see that this map has a few potential issues:

  1. The bridge pieces starting screens are all on the west end of the map, and are nearby the Bridge screen.
  2. The Phonebooth, Bridge, and Jail are all on the bottom row, which makes the bottom row feel too important, and the top row feel unimportant.
  3. The “critical path” relationships in the original map are broken in this map. This may not be a problem per se, but it will make the new map feel less familiar to experienced players.
Superman bridge piece routes
The original Metropolis map has a very tight spatial relationship between the most important screens on the map. The new map layout breaks this by moving the Jail screen far away from the rest of the screens.

Otherwise, I think the map looks pretty decent. I’m not sure how I feel about the potential issues I mention above.

I do think that the Bridge should be the center piece of the map, so I shifted rows and columns in order to make it so, but the rooms are still in the original order, using the horizontal progression from the original map.

It’s interesting how shifting things around can change perspectives on things. With this view, I’m able to notice different things:

  1. Now all the “important” screens (Jail, Bridge, Phonebooth, Daily Planet, and all but one of the bridge pieces) are on the west end of town.
  2. But balancing that, all the subway entrances are on the East end of town.
  3. Subway exits are somewhat evenly distributed, but there’s a few interesting things to point out: The Red subway exits all line up in a column at the far west edge of the map, while the Yellow subway exits are all distributed across the top row. The Green subway exits follow a diagonal from the northwest corner of the map, moving southeast. And the Blue subway exits are scattered about as far from each other as they could be.
  4. Shifting the screens changes the loopback point at the top right, and as a result the screen that normally is to the left of the Phonebooth screen no longer is. Which, despite what I thought when I first decided to shift the screens to put the bridge in the center of the map, does fundamentally change the map. Then I realize… I did it wrong!

I can’t just grab the top row and move it to the bottom, and then slice the right couple of columns and move it to the left. That will not preserve the horizontal order of the screens. To do that, I need to grab the top-right screen, move it to the bottom left, and then let all the other screens shift right by one, snaking around. This approach gives this result:

Overall, it’s actually very similar to the first two iterations. It’s literally the same horizontal sequence as the first iteration, but it’s not all that different from the second iteration, either; the “important” screens are still mostly to the west, the subway entrances are still mostly to the east. I think the subway exits are a bit better distributed than in iteration 2.

The vertical path is quite different. I think this map will run slower, due to the placement of the Jail in the corner of the map, and its distance from most of the subway entrances, and the Phonebooth/Bridge screens. There might yet be some quick paths that will become apparent through repeated play, but for now I feel that the map feels disorienting because the Jail isn’t north of the Yellow subway entrance screen any longer, and I struggle to locate it as a result.

Certainly there are many other possible arrangements for the overworld map, and I haven’t even begun to re-design the subway. But I think this is enough to satisfy my curiosity, at least for the time being. I may come back and revisit this further if I feel a need to after playing the maps I already created more extensively.

There’s much more to do in a hack of Superman, as well. I would like to figure out how to randomize the starting places of the bridge pieces, for example. I would also be interested in figuring out how to put up a hard barrier around the outer edge of the map, rather than having the map wrap around at the edges. But these projects, if I ever attempt them, will have to wait until I have a deeper understanding of 6502 assembly.

Download all of my Superman map romhacks here:

Ouya shutdown shows the downside of Games as a Service

Ouya. The kickstarted, indie-friendly mini console based on Android that failed in the market, is now on its deathbed. After Ouya gave up on its dream, it sold off its assets to some company, and there was some vague plan of relaunching a new brand in China, or something, but it didn’t work out. Now, the games servers are going offline, and the games will not be able to be downloaded or even played in some cases, if they need to connect to servers that no longer exist.

There are some efforts to preserve the game library and keep the games available, but it’s likely that they will not be able to preserve 100% of everything.

This shows dramatically the dangers of digitally distributed games-as-a-service. When the service is discontinued, there’s nothing left to own. History is lost, and there is no legacy, as everything fades into oblivion.

Why creative types shouldn’t settle for anything less than ownership

Last week, I read an article by a professional game developer entitled “Making games for a living means being in constant fear of losing your job.”

The author’s solution idea is for game developers to unionize, in much the way the movie industry has unionized. I think unionization would be a great thing for the industry, but I’m not sure it goes far enough.

The videogame industry started about 40-50 years ago. The people who founded the industry worked very hard, started from nothing, and worked insane hours, pouring their life into creating the new industry. The ones who were successful ended up making a fortune.

That fortune was only made possible through ownership. It wasn’t making games that made the founders wealthy — it was making companies. In a lot of cases, the company came later. Nolan Bushnell and Ted Dabny started Atari in 1972 with $500 (about $3000 today). A kid like Richard Garriott or Jordan Mechner programmed a game in his bedroom on his home computer, sold it through mail order using a classified ad in the back of a computer magazine, and made a million dollars, and decided they should turn it into a company, using that money to hire more people to make more and bigger games.

Somehow, the expectation for the new employees was to work just as hard, just as many hours, and crank out more games that would make millions of dollars. Only, they were doing this work as a “work for hire”, and wouldn’t own their work — their employer would own it.

This means all the same hard work that the employee did that went into creating that game for his employer enriches the employer, when it could have gone to the employee’s own company that they owned and profited from. Employees enrich someone else’s empire. That’s the way capitalism works.

Because the industry now exists, it’s easier to work for pre-existing companies them than it is to start up a new company. Not only does a new company have all the struggles of just starting up, they also have to compete with already-functioning companies. But the owners who worked hundred hour weeks to found their business often expect no less of their employees.

Yet, the vast majority of employees don’t get compensated with an ownership interest the company for their hundred hour work weeks. They just get burned out and dumped when their project ships. For working for someone else, you got only a salary, not a company.

Ownership comes with things like a share of the profits. There’s also a lot of risk, but it’s balanced by the compensation package that comes with owning a company, whereas work-for-hire employees don’t get this level of compensation, yet have just as much if not more risk associated with their employment in the form of layoffs. Employees creating works-for-hire don’t even get royalties, and job security is non-existent. Once the product shipped, they were no longer needed and if there wasn’t another new project waiting for them that could exploit their talents, they were expendable.

That’s a raw deal.

Game developers who want to make money and have job security should own their work, and that means owning a piece of the company they work for.

It sounds like I’m suggesting that every game developer should be an indie game developer. I’m not. Clearly, being an indie is not easy either. In fact, it’s brutal. There’s a lot of competition. An indie has to do everything well in order to be successful, and almost no one is that talented at everything needed to be a success. Game development requires a lot of diverse skills, and a good team can cover those bases a lot better than a sole proprietor.

But what is good about being an indie developer is that you get to own your creative work. You get to create new IP, rather than toil on the sequels to someone else’s successful IP franchise. But even for workers making the next iteration of a successful known entity (let’s say Mario, for sake of example), being employed means that they should take on a share of the ownership stake in the Mario franchise, or in the company that owns Mario. That means royalties on sales, in perpetuity, of the product they worked on, and it means the right to produce new works in the Mario milieu.

This would go a long way toward padding the job insecurity that is endemic to the game development industry. Making money through royalties on existing works, and owning stocks that would pay dividends, would be a critical income stream to supplement an (ir-)regular salary.

Game developers will never get this, unless they strike out on their own and create their own companies from scratch, or if they strike together, unionize, and demand it from the companies that currently exploit them.

If an employer wants to commission creative work on a “for hire” basis, then the working conditions should be reflective of the compensation being offered: 40 hour work weeks, additional compensation for overtime, 1099 employment status rather than W-2, and salary at a higher rate to reflect the short-term nature of the work arrangement, to allow skilled professionals to earn enough to cover lean times between contracts (generally more than twice what a full-time employee would expect to be paid).

New “Link’s Awakening” triggers debate on remakes

It seems a lot of forum activity has been generated by yesterday’s announcement by Nintendo about the remake of Link’s Awakening on the Nintendo Switch.

In short, it seems that a significant number of fans are not in favor of the remake for one reason or another. Mostly this can be summed up as: “It’s not the exact same game as the original.”

Which, is true. The remake completely changes the graphics style, from the old 2-D look of the Game Boy original to something almost claymation-like, using a fixed 3/4 perspective, but with 3D models done in a cartoonish style. It remains to be seen what other changes are in store, and whether they are good or bad. It’s rather likely that the game will play differently in some respects, whether due to differences in the game engine, or changes in the design of the game.

I happen to love the way the new graphics look, so this doesn’t bother me. I liked the original graphics, too. And if I want to play the original game, I still can, and so can anyone with a the original hardware or a decent emulator.
But it seems that, among Zelda fans, there’s a certain segment who prefer the graphics to look “serious” — like Ocarina of Time, Skyward Sword, Breath of the Wild, etc., and not “cartoony” like Wind Waker or Four Swords Adventures. Somehow, original LoZ pleases both camps, and Link’s Awakening is in the vein of LoZ and Zelda 3: A Link to the Past. And I guess the new look for Link’s Awakening is too cartoony for them. This does not bother me. I like good art direction, and that can be “serious” or “cartoony” or something else.

It’s certainly true that many attempts at re-making some original classic game fail to capture what was special about the original game. It’s tempting to try to re-imagine something that was very, very good, thinking that adding something more will make it even better. Often that’s not the case.

Certainly, there’s a built-in expectation that a remake has to live up to, which a fresh new game doesn’t, and this can offset whatever advantage the remake had in being based off of a familiar, known, successful game. It can be very easy to mess up by deviating from the original in the wrong way. For example, updating the graphics in a style that fans don’t like, or likewise with the music. But worse would be a major change in the story, something that violates canon or continuity, or is just a change that upsets fans by breaking an unwritten contract to keep the game authentic to the characters and world that Fandom has already accepted. And perhaps the gravest mistake would be failing to ensure that the controls feel tight and responsive and give the game a good feel, ideally something virtually identical to the original. There’s nothing like tasting someone else’s attempt at your favorite recipe that your mom made when you were a kid, and no matter what they do it’s always just slightly off in a way that, even if it’s not bad, it prevents you from accepting it. I think that’s ultimately what makes fans of the original all but impossible to please when it comes to embracing a remake.

But that’s not to say that remaking a game is always a bad thing. I don’t view a remake as an attempt to replace or supplant the original. Rather, I look at it like in the way I look at theater: A playwright can write a play, and it can be performed by an original troupe of actors. And other theater companies can put on productions of the same play. Some may try to do it exactly the way the original was done, following a tradition, while others may stray and experiment. Some will be good, some will not. But it’s not like people shouldn’t continue to put on performances of Shakespeare just because purists who were fans of the original will find something not to like about it. And of course people should continue to write new, original scripts. The entertainment industry is large enough, and the audience is large enough, to sustain both.

Ultimately, it will come down to how the game plays. It’s only fair to judge the remake based on what it is, and not what it’s not. And to be clear, it will not be:

  • The same as the original.
  • A brand new, original game.
  • Different from the original in exactly the way everyone would like it to be.

Will it be worthy? That remains to be seen, and will be a matter of opinion and consensus. But I’m excited about it.

I’m buying a Switch, and other reasons I’ll be a happy gamer in 2019

So a bunch of great announcements from Nintendo came earlier today. For me, the highlights are:

Link’s Awakening Remake

Yeah, Breath of the Wild blew everyone away at launch and sold a few million systems, and I’ll admit I was very tempted to rush out and buy a Switch when it was released.

But I’m not an early adopter and I wanted to wait and see if the system would be a success, particularly after seeing how Nintendo struggled with making the Wii U realize its potential. So I held off.

I like 2-D Zelda more than 3-D Zelda, because 2D > 3D, as far as I’m concerned. And this Link’s Awakening remake looks fantastic.

I’m actually maybe more excited about this than I am about finally getting to play BotW soon.

Super Mario Maker 2

I told myself at the time, I would buy a Switch if they had Super Mario Maker for it. For a while I debated getting a Wii U so I could play both Breath of the Wild and Super Mario Maker, but I decided I wanted the real, full BotW experience with the improved controls made possible by the Switch’s joycon technology.

I’m glad I waited, now. I didn’t have to wait, I could have predicted even then that we’d see a SMM at some point on the system; it was just too popular not to be a thing. But now that it’s announced and official, I can’t wait. Really looking forward to designing some Mario levels in June.

Tetris 99

Battle Royale Tetris, awww yeah!!!!

Non-Nintendo news

Well, actually I’m not quite done with Nintendo news, but these next two are NES homebrew releases.

Full Quiet

First, Full Quiet has got me all hot and bothered to put some more hours on my AVS console. I backed the Kickstarter, and got to play it and talk to creator Tim Hartman at Portland Retro Gaming Expo back in October of last year. I’m pleased to say that this game is already looking incredible, and it should be out later this year. Even if it’s not, and release slips another year, it will be worth the wait. This is not one to miss.

Just look at the latest video showing it in action.

Without exaggerating, I will say that this may end up going down as one of the greatest releases on the NES. And considering the greatness of the NES library, that’s a truly staggering accomplishment.

From talking to Tim, I’m aware that his game will also be released on Steam, playable on PC though emulation of the NES hardware, which means that even if you don’t own a working NES for some reason, you can play this game. And you should.

MicroMages

MicroMages should also be shipping sometime in 2019. This game bears a resemblance to Towerfall, the 4-player archery arena battle indie sensation from a few years ago, but runs on NES hardware, and is pretty fantastic in its own right.

FPGA retro consoles

If that’s not enough, I’m also looking forward to the delivery of the Analogue Mega SG, a FPGA-based, HDMI-output implementation of the Sega Genesis, and the Collectorvision Phoenix, a FGPA-based, upgraded ColecoVision plus.

I can’t imagine that I’ll have enough free time to play all of these nearly as much as I’d like to, but I still can’t wait, and I can’t believe all the good stuff that’s happening in the world of gaming, so much of it the product of cottage industry efforts devoted to keeping older systems relevant. 2019 is going to be a fantastic year.

Collectorvision Phoenix demoed at Portland Retro Gaming Expo

I attended the Portland Retro Gaming Expo this past weekend, and enjoyed myself very much.

One of the many highlights of the show was getting to try out the new Phoenix console from Collectorvision.

Having seen it in person and tried it firsthand, I can say that it is the real deal, and is absolutely worth the money they’re asking for it on kickstarter.

The campaign is a bit behind the pace with their funding goal, and they need and deserve support. Just 1000 pre-orders are all that’s needed to successfully fund the project and make the system a reality.

You can back the project here:

https://www.kickstarter.com/projects/1408938247/collectorvision-phoenix-an-fpga-colecovision-conso/description

For just $200, you get an enhanced, 100% compatible, 100% accurate ColecoVision with HDMI output, built in Super Game Module and FA-18 mods, cartridge slot and SD card slot, original and SNES controller ports, and a ps2 keyboard port. Collectorvision announced Atari 2600 compatibility, and plans for supporting other vintage game systems such as the Adam and MSX.

ColecoVision is an underrated and underappreciated console, both in its heyday and today. With graphics capabilities between the Atari 2600 and the NES, it has a small but very loyal following, and a decent library of original games and an active homebrew community releasing new games. It’s a great time to get into the system if you are vintage gamer.

GameMaker Tutorial: Audio speedup with sync

In so many games, music speedup is a great way to get the message to the player that they need to hurry up and get things done.

It’d be great if you could simply set a new tempo with a simple GML function, and have the current background music adjust on the fly. Something like audio_sound_set_speed(sound, speed) would be lovely. But it’s not as simple as that in GameMaker, as I found out recently.

Here’s how I implemented a speedup for my GMLTetris project:

First, I created two music tracks, one at normal speed, and one at double speed, and added them to the game project as sound assets.

Everything else is just programming:

if <condition> {stop slow_music; start fast_music;}

This is easy enough, the trickiest part is probably getting the condition right to switch tracks, but depending on the game, that condition could be very simple, too.  The only real complication is that if you’re checking the condition repeatedly, as you normally would every Step, you only want to trigger the changeover once.  So to do that, set up a variable to track whether the switch has happened already, and check it, too, even if the condition that triggers the changeover continues to remain true on successive steps.

if <condition> && !music_switched {stop slow_music; start fast_music; music_switched = true;}

The music speedup that happens in a game like Super Mario Bros., where the music speedup occurs when the level timer hits 100, is a typical example of such a technique. If you only need to do a single, one-way switch, this is all you need.

If your game needs to switch back and forth between slow and fast music, your conditional needs to be more sophisticated.

if <condition>
{
   if !<fast_music_already_playing>
   {stop slow_music; start fast_music;}
}
else
{
   if !<slow_music_already_playing>
{stop fast_music; start slow_music;}
}

Here, because the game can switch multiple times, when the condition check happens, we can’t get away with a music_switched variable that changes one time. What we need to do is check to see if the music we need to switch to is already playing, and if not, stop the current music and switch to the other music.

One thing to keep in mind, this basic technique will start the fast music from the beginning of the track. This might be what you want, but it would also be good if you could start the fast music at the position where the slow music was, for a seamless transition.

GML has the functions to do this: audio_sound_get_track_position() and audio_sound_set_track_position(). But in order to make use of them, we need to do a bit more work.

First, since the gml functions return the absolute time position of the track, and since two tracks play at different speeds, we need to adjust the position proportionately when we switch tracks, so that the position is at the same position percentage-wise. This is actually easy, as long as we know the tempo change, which we do. Since the fast track is double speed, we can easily calculate the equivalent position in the other track by multiplying or dividing by 2.

Slow to fast: position *= 0.5;

Fast to slow: position *= 2;

Where I ran into trouble was, I needed to be able to switch both ways. It seemed like it should be simple — just check whether the desired track is already playing, and if not, get the position of the current track, adjust it proportionately, start the desired track, set the position. Easy, right?

Let’s look at it in pseudocode first:

if <condition to switch to fast music>
{
   if audio_is_playing(slow_music)
   {get position; stop slow music; start fast music; set position;}
}
else
{
   if audio_is_playing(fast_music)
   {get position; stop fast music; start slow music; set position;}
}

This was when I discovered that audio_play_sound() returns a handle for identifying the specific instance of the sound that is playing. This is necessary to use to set the track position of the playing sound. You can’t just set the position for the sound_index; you have to set it for the specific handle of the currently playing instance of the sound. If you set the track position for the sound_index, any time that sound resource is played in the future, it will start from that position.

///Create Event:
bgm = audio_play_sound(slow_music, 10, true);
///Step Event:
if <condition>
{
  if audio_is_playing(slow_music)
  {
  var pos = audio_sound_get_track_position(bgm);
  audio_stop_sound(bgm);
  bgm = audio_play_sound(fast_music, 10, true);
  audio_sound_set_track_position(bgm, pos * 0.5);
  }
}
else
{
  if audio_is_playing(fast_music)
  {
  var pos = audio_sound_get_track_position(bgm);
  audio_stop_sound(bgm);
  bgm = audio_play_sound(slow_music, 10, true);
  audio_sound_set_track_position(bgm, pos * 2);
  }
}

I also discovered that detecting which track is playing with audio_is_playing() does not work for this purpose. I still don’t have a clear understanding of what was happening in my code, but some debugging showed that my track position calculations were being distorted by being called multiple times. This doesn’t make sense to me because the song should no longer be playing after the first step when the switch condition is met. But my theory is that since the audio is played in another process from the main program, there’s some messaging going between the two processes asynchronously, and as a result audio_sound_is_playing() can still return true a step later, even after the message is sent to stop the track playing.

By trying to set the track point multiple times in quick succession, weird and unexpected results happened, and the tracks switched but did not set to the correct position.

So I had to come up with a surer method of knowing which music is playing.

Debugging was tricky, since I couldn’t tell from listening where the audio position was. To aid debugging, I drew the position of the playing track to the screen, and then I was able to see that the position was not being set correctly as expected. Somehow, switching from slow to fast would drop the track back from about 10 seconds to 2 seconds, and then switching from fast to slow would jump from 2 seconds to 38 seconds. It wasn’t consistently the same timing, but depending on when the switch was triggered, it would jump around, seemingly at random, but within a range of a second or so around these positions.

I couldn’t figure out why that was happening, so I tried using show_debug_message() and watched the output console, and saw that the track position would update 2 or 3 times when the tracks switched; I was expecting it to only update once.

This is what clued me in to what I believe was happening due to the multiple processes communicating asynchronously.

The solution I used in the end was easy and simple: instead of checking which track was currently playing using the audio functions to directly check whether it was playing, and then switching from slow to fast or vice versa based on the currently-playing audio asset, I just added a new variable, condition_previous, and compared condition to condition_previous, and made the switch happen only when the current condition didn’t match condition_previous. This only happens in one step, when the condition changes from false to true, or vice versa, and so the track position is set once, when the bgm switches tracks and syncs up the new track to where the old track left off.

switch_previous = switch;

switch = <condition to check for switching to the fast music>;

if switch && !switch_previous
{
var pos = audio_sound_get_track_position(bgm);
audio_stop_sound(bgm);
bgm = audio_play_sound(fast_music, 10, true);
audio_sound_set_track_position(bgm, pos * 0.5)
}
else
{
if !switch && switch_previous
{
var pos = audio_sound_get_track_position(bgm);
audio_stop_sound(bgm);
bgm = audio_play_sound(slow_music, 10, true);
audio_sound_set_track_position(bgm, pos * 2);
}
}

This works, because it guarantees that the condition checks will be accurate, as they do not depend on checking the status of the audio playing in another thread.

Steam and Censorship

A recent announcement by Valve on Steam’s community blog has created a great deal of controversy.

I’m not entirely sure how I feel about this, but my inclination is that Valve is trying to do the right thing, in a situation where they cannot possibly please everyone, and prefer to be neutral and let the market sort this out, allowing gamers to play games they want to play, and developers develop games they want to develop.

I tend to agree with their stance and reasoning.  I haven’t thought about it a whole lot, and I haven’t looked into specifics of what problems have been going on within the Steam community that gave rise to this decision, so this is just a preliminary reaction.  But I like free expression, I don’t like censorship in any form.  I think people should use their discretion when it comes to what they say, and what they choose to experience as entertainment.  I want games to be as powerful a medium as film or literature, and I believe in their potential to be more powerful than either.

Obviously, there’s a lot of nuance to this — we don’t always get to choose our experiences.  Games can surprise and shock people. But I don’t believe that games should be simply light entertainment that never offends anyone.  Part of what makes art powerful is its ability to shock, offend, or even traumatize.  When an authority attempts to exercise control over ways in which it is permissible to shock, offend, and traumatize, you end up with art that is safe for the establishment and promotes the interests of the powerful, and serves to persist the status quo.  Whether that’s good or not, depends on whether your values align to that of the authority.

I believe in authority that defends the rights of individuals to speak out in ways that contradict the establishment, challenge it, and can force it to re-evaluate, change course, and reform as needed, as times and prevailing attitudes change.

Obviously, people can be and are sometimes hurt in the course of this.  This is something I think most of us try to avoid.  Even so, it happens — occasionally deliberately, but often not.  Perhaps some degree of mitigation of this is not bad.  But it is dangerous, and needs to be considered very carefully.  I’d rather allow the offensive, controversial content to exist, and surround it with robust discussion, than to prevent it from being published and distributed.

Adobe Flash EOL in 2020 – how will we preserve games?

Adobe announced today that it would cease development and support of Flash in 2020.

Of course, there were (and are) a lot of issues with Flash:

  • the proprietary nature of the Flash Player plugin;
  • memory and CPU usage;
  • stability problems;
  • security problems;
  • privacy concerns over Flash cookies;
  • Flash advertising/malware;
  • lack of accessibility in many Flash objects, resulting in issues for people with disabilities, screen readers, search engine indexing spiders, or for anyone who simply didn’t have the Flash Player installed, etc.;
  • and poorly programmed Flash objects.

So it’s not entirely a bad thing that Flash’s time is nearly at an end.

While this news doesn’t exactly come as a surprise to those who have been following the life of Flash since the iPhone launched, it does raise a serious question:

What will happen to all the games created in Flash when Flash is dropped from mainstream web browser support?

How will the history of games developed in Flash be preserved?

[Update 5/2/2018:] Here’s an article on one effort to preserve Flash games.

This is no small question. Over the 20+ years that Flash has been around, thousands of games have been built with it. Many of them are good games that still hold replay value. But without a viable platform with which to play them, will they wink out of existence and be forgotten?

I think the best approach to preserving Flash’s historical legacy would be to create a version of the Flash Player in Javascript or Web Assembly, and then any web site can use that to backfill support for any Flash objects that they wish to serve.

What are your favorite Flash games?

The Ongoing Sale

Since I announced yesterday that I’d finally earned my first $100 payout through the GameMaker Marketplace, I dropped my price on all paid assets to $0.99. I had another purchase today, so to celebrate that, I decided to adjust the terms of the sale.

The payday celebration sale will continue through 4/10/17 as planned.

For each paid purchase I get during the sale, I will extend the sale by one day.

Update, I had another sale today, 4/11/17, which will extend the discounts another day.

So as of right now, the sale on all my paid assets will last until 4/12/2017.

Get csanyk GameMaker assets on GameMaker Marketplace!