Orkn's Pulp Prototypes

It's been a while again since I've posted anything here, but I have been steadily working away on Resonant Tale. The big news is that I now have a collaborator for music and sound! My own efforts at them (even with Pulp's simple interface) proved woefully inadequate so I'm pretty excited. Good sound really is transformative! It's great being able to get an insight into that side of things by working with someone who knows their stuff :slight_smile:

On the subject of smooth movement, my approach here in some ways already feels outdated since people have found draw can accept non-integers, which can free you from the grid constraints entirely (with a bit of effort). I'm already tied in to my approach, which is fine as it works for what I want it to do, and the last thing I did was extend it so that the player can be smoothly animated while descending a ladder - like this:

resonant_tale_ladder

(While on a ladder you also can't turn to face left or right, and you can't place bombs or shoot arrows.)

2 Likes

Absolutely, thank you! And of course not- I'm doing all my own art :playdate:

1 Like

Over the last couple of days I revisited my tile-based pulp platformer prototype to shape it into a little "arcade cabinet" for inclusion in another soon-to-be-revealed project I was approached about.

My goal was to:

  • Make a proper level
  • Crop the screen to an arcade cabinet feeling aspect ratio
  • Implement coins to collect with a saved high score
  • Implement a timer with a saved high score
  • Give the game some polish with little things like a title screen
  • Refactor all of it to be self-contained and as easy as possible to drop into a larger pulp project!

Here is what it looks like right now:

tile_hill_pits_and_spikes

tile_hill_springs_and_saws

Implementing coins

The code is simple, but it's a lot of effort!

Coins are an item tile with this basic script:

on collect do
	
end

on pickup do
	thill_coins++
	tell event.room to
		call "pickupCoin{event.x}x{event.y}y"
	end
	swap "white"
end

collect is overriden to do nothing because of the non-standard player movement. Instead every frame I call the pickup event on the player's location.

The implementation of screen scroll (by having overlapping rooms with inset edge exits stitching them together) means that the "same" coin will be placed in multiple rooms. When the player picks up a coin in the level it not only needs to be swapped out of the current room, but any other room in which it is visible. For this reason every coin has its own variable to track whether it has been collected, and when picking up a coin the room script has a matching event to set the correct coin variable:

on pickupCoin2x10y do
	thill_coin_1 = 1
end

There is an event like this for every coin that can be picked up in that room.

When entering a room the coin variable needs to be checked to see whether each coin visible in the room should be swapped in or out. Swapping in as well as out means the level can easily be reset without restarting the entire game:

on enter do
	if thill_coin_1==0 then
		thill_tile = "thill coin"
	else
		thill_tile = "white"
	end
        tell 2,10 to
		swap thill_tile
	end
end

That's it for the concept - but multiply up for every coin (each appearing in multiple rooms) and it's a lot of code and a lot of copy/paste while changing the numbers!

Making it portable

I refactored extensively to try and make it as easy as possible to just drop in to another project:

  • "Portable" means "small". The game uses 11 rooms (10 for the level and 1 for the title screen). In addition to the default black/white world tiles the game only uses 10 player tiles, 11 sprite tiles, and 4 item tiles (cut down from the original prototype).

  • Every variable starts with thill_ so there shouldn't be any conflicts despite pulp having only global variables.

  • All of the rooms and tiles similarly start with thill so they will be grouped together in the pulp editor's alphabetically sorted lists

  • All of the code is self-contained within tile and room scripts, primarily a tile hill code tile (that doubles up as the coin HUD icon, just to save on tiles!). The player and game scripts have the minimum hooks to relay the required pulp events to the Tile Hill code. Essentially to start Tile Hill from within another pulp game someone just needs to call the one boot event to start the game and ensure those events are relayed for the duration (probably just with a flag that is set when the game is running).

  • Pressing "B" while playing will return the player to the title screen. Pressing "B" on the title screen will call a quit event which is intended to quit the player out of Tile Hill and back to the containing pulp game. This requires a little bit of tidying of config changes and resetting the screen crop.

Hopefully that's mildly interesting!

2 Likes

ART& was just released on catalog - check it out and head to the in game arcade if you want to give Tile Hill a play. It's very cool to have contributed something to a catalog release!

1 Like

I still think what you did with it is magic

Resonant Tale is finally approaching a complete game, and while it's not quite finished yet, yesterday I spent a surprisingly short amount of time trying to make the game more accessible. I thought my experience might be interesting to share :slightly_smiling_face:

Accessibility in Resonant Tale

Previously I have implemented some cheat codes in Resonant Tale that can be entered on the title screen, partly for fun and partly for making testing easier. One of those cheats was player invincibility, but it occured to me this would really be better as an easily discoverable option in some assistance settings. That prompted me to consider accessibility in the game in general.

I was a bit trepidatious about exploring accessibility. It's not something I'm familiar with or have consciously addressed before and I was worried about how much work the additional functionality would be, especially using Pulp. Obvious accessibility features that sprung to mind having seem them in other games, like adjustable font sizes, are not readily supported by Pulp (which I think is a fair trade off with Pulp's intended simplicity as a starting point into game development). Nethertheless I started reading up on Accessible Player Experiences and Game Accessibility Guidelines, both great resources. I geared my mindset to thinking about what can be easily done rather than getting hung up on what can't!

More details below, but this is the assist menu as it now looks in game:

resonant_tale_assist_menu

Settings persistence

Up until now my approach to save data has been really simple - if the player selects Continue from the title screen I use restore while if the player selects New Game I use toss. With assistance settings however I want them to persist even if a new game is started. I replaced my toss call with a custom game event (also called "toss") that looks like this:

on toss do
	toss
	// Re-store persistent vars
	store "assist_damage"
	store "assist_bosses"
	store "assist_crank"
	store "assist_timing"
	store
end

This works great and is going to be useful beyond these assist settings as I'm planning on keeping a record of whether the game has ever been beaten so I can offer a New Game Plus!

Player damage

I already had a version of this implemented in my invincibility cheat so this was easy. From an accessibility perspective being able to turn off player damage is a maybe heavy handed but simple solution to a host of potential issues.

I already had all player damage implemented through a player event takeDamage so this was as easy as adding this one conditional to the start of the event handler:

on takeDamage do
  if assist_damage==1 then
    done
  end
  // code handling player damage
end

Boss battles

I'd describe Resonant Tale as "low combat" - there are numerous hazards but few traditional enemies. Bosses are the exception as tests of player execution and as barriers to progress. While a valuable aspect of the game, making them optional prevents them blocking someone from enjoying the rest of the game which is not as challenging or demanding of execution.

Again I already had logic in place for triggering bosses, previously there to prevent bosses from being fought multiple times if returning to the boss room for example. This made implementing a simple skip almost trivial as (for the most part) I only needed to alter a few conditionals. The first dungeon's boss, for example, has a conditional changed from this

on enter do
  if has_bell_of_vitality==1 then
    // code toggling the boss
  end
end

to this

on enter do
  flags = has_bell_of_vitality
  flags += assist_bosses
  if flags>=1 then
    // code toggling the boss
  end
end

(The flags>=1 pattern is a pulpscript version of an or)

Crank puzzles

Input, especially analogue input, is an obvious consideration for accessibility. Resonant Tale has minimal use of the crank, used only in a couple of instances, only one of which is required to beat the game. A setting to remove those instances to prevent a small aspect of the game stopping someone from playing it entirely seems an obvious win!

With the assist option enabled, for an optional puzzle I simplify the puzzle to no longer require the crank. For the required puzzle simplifying it was not an option so I just made it pre-solved (although I may revisit this to make an alternative solution instead).

Timing puzzles

Timing puzzles refers to anything (outside of bosses) where precise timing is required from the player. This covers a relatively significant minority of Resonant Tale and was the most work to implement as I took different bespoke approaches depending on what content I was changing.

Take this room as an example - it has retracting spikes that the player must time passing over to not take damage:

resonant_tale_retracting_spikes_without_timing_assist

With the assist option enabled I replace the retracting spikes with static spikes and add a path through for the player to navigate:

resonant_tale_retracting_spikes_with_timing_assist

Not every timing puzzle has quite as nice a replacement as this and in multiple places I simply removed the challenge entirely, but I like being able to offer an alternative like this where I can!

2 Likes

Really excited that a reveal trailer for Resonant Tale just featured in the Playdate Community Direct! Here it is if you missed it :smile:

2 Likes

This looks wonderful! Amazing it's in Pulp too!
:trophy::crossed_swords: :shield:

1 Like

Something completely different for a change, a little toy called Paint with Pulp!

paint_with_pulp

Drawing at double the room tile resolution! I made 16 sprite tiles that represent all permutations of a 4 sub-tile grid, and these get swapped in as you draw.

The player is hidden (trapped in the middle of the room) and instead I draw the cursor using fill , with the position updated through the sprite interact event that's mimicked across the tiles.

Anyway, at the moment a lot of games have a nice launcher card but the default list view icon, so I decided I wanted to make a joke game which has a nice list view icon but where the launcher card looks like a card version of the default icon. I think it came out pretty well (read: terrible)!

paint_with_pulp_cursed

I added a second canvas to draw on, you can switch between them by cranking - this allows for some very basic animation. Also note that the canvas is saved (I just reused my room saving code from Pulpino :smile:)

If you want to try it out (and ruin the look of your card view launcher), here's the pdx:

Paint-with-Pulp!.pdx.zip (60.0 KB)

4 Likes

I realise I haven't posted about it here, but Resonant Tale is coming to Catalog! It launches September 12th on both Catalog and Itch, which is almost exactly a month away, so please look forward to that!

Anyway, I actually came here to share a concept called Travelling Balloon:

travelling_balloon_movement_concept

The player controls a hot air balloon that moves automatically with the wind, but the crank moves the balloon between different air layers with different wind directions (see HUD on right). The top layer is the prevailing wind for that room; the middle and lower layers vary by tile (which means 16 permutations for every tile to cover all wind direction combinations). The little arrows on the tiles are for ease of concepting only - the intention is that you'd only see the wind direction on the HUD and would have to learn the hidden wind patterns across the map.

One of the "tricks" here is that every map tile is a sprite, not a world tile. For one the tiles being solid means the dpad won't trigger any movement without me having to ignore input, and second it means each map tile can define its wind directions in its script.

1 Like

So many end lines. :woozy_face:

How about calling it a "stairway to heaven", or maybe a "pass" because when you look at it, you want to look away. :sweat_smile:

Personally I would have made the player automatically step off the warp tile right after warping, instead of continuing to spin around after warping and save myself from some grief, but we all do things differently and there's no "right way" when making your own game.

Keep up the great work!

1 Like

Thank you!

I've built out more of Travelling Balloon, but no more to share yet. What I do have to share is this unrelated prototype I've put together tonight:

pulp_16x16_prototype

  • A tileset made up of 16x16 meta-tiles
  • A 16x16 player drawn using the decimal draw trick for off-grid movement
  • A solid 20fps on device!

The black border along the bottom and right hand side is because of the odd number of 8x8 tiles across the screen. How I'll "hide" that depends on what I decide to make, but I guess it'll be in a HUD of some kind!

(This is 100% "why not just use the SDK" territory here... but I'm having fun :smile:)

2 Likes

Today is (finally) the release day of Resonant Tale, available now on Catalog and Itch! A massive thank you to everyone who has been following the game through this thread, whenever my motivation has waned it's been the support of all the lovely people in the Playdate community that has kept me going. Much love to you all and here is a final something to share from the game!

resonant-tale-action-sizzle

3 Likes

Congratulations on your release! Hope everyone with a Playdate plays it! :slight_smile:

1 Like

Thanks Grim! Appreciate it!

1 Like

Something silly I needed to get out of my head as I could see how simple some of the mechanics would be to implement just with the default pulp collect behaviour...

Carrie Cargo: Parody Walking Action

What if Death Stranding was on the Playdate... and British?! Collect cargo, earn claps, and reconnect Britain to the DATA CANAL NETWORK.

carrie_cargo_delivery

Collect more cargo for a multiplier! Crank to balance!

carrie_cargo_londoners

Watch out for LONDONERS and reconnect Britain!

carrie_cargo_yodellers

These YODELLERS will chase you for your cargo!

carrie_cargo_bikers

Don't get run over by these BIKERS!

carrie_cargo_intro_1

As expected there is a thrilling plot...

carrie_cargo_intro_2

...full of shocking twists!

It's very unpolished (default font and there's no sound whatsoever!) but if you'd like to give it a play, here's a pdx!

Carrie-Cargo_-Parody-Walking-Action.pdx.zip (38.2 KB)

3 Likes

Just announced and released during the community direct, Goodnight Universe is a micro audio game to fall asleep with about the heat death of the universe.

I've had this idea in my head since before the Playdate, but the lack of front or backlight on the console really makes it make sense as it can be played in the dark with no screen light causing a disturbance.

I was also inspired by Pulp's noise channel to add an extra feature where the game's title screen continually generates low volume noise, meaning it can double up as a passive sleep aid. It was fun to work out how to poke the pulp music editor in the right way to do that!

The game's trailer was created in Pulp and can be watched in-game by entering the Konami code on the title screen. I really can't resist including cheat codes in my games!

This is definitely on the more experimental and conceptual end of the scale but I think Playdate really encourages that kind of thing.

Goodnight Universe is free or pay what you want on Itch :slight_smile:

1 Like

Runaround Reaper was my entry for PlayJam 4 - my first ever game jam! I finished mid table which I was happy with, especially considering "use of console" was one of the three categories in which my game came deservedly second last (not using any unique features of the Playdate at all really).

Mainly though it was an excuse to have a go at refining some chaser enemy behaviour in Pulp. It's probably too intensive to do any actual pathing in Pulpscript, but what I ended up with was an enemy that can chase the player (or move towards another target) and navigate around rectangular obstacles. As long as there are no inside corners to get trapped in, it works :smile:

I wasn't planning on participating as I didn't think I'd have the time, but it was fun to take part in a jam, even if it was on my own and without the full weekend to build out an idea over. I'd definitely like to properly dedicate a weekend to a jam with a team if I get the chance in the future!

It's been a while since I posted anything here, but I've been playing with lots of ideas! Here are some of them:

Tourist

A pathfinding puzzle game. Visit every unvisted tile without going back on yourself.

tourist_teaser

This started as me wanting to make a game that uses only black and white tiles, which is an effective resolution of 25x15. This kind of simple puzzle might be familiar as it appears in games like Zelda and Pokemon, and it can often be found as a standalone game using a "lawn mowing" premise.

The dpad is used to solve the puzzles, while the B button is used to reset the current puzzle. The puzzles are arranged vertically so that the crank can be used to scroll through them. I also aimed for consistency in having the puzzles start in the bottom-left, so the player knows (roughly) where to look to begin. All of this was to solve for not wanting any other tiles, including text.

At first I just tried making abstract puzzles. They were kind of fun, but lacked charm. Switching up to picross-style images-as-puzzles felt a lot better! The releasable game I'm aiming for has several sets of puzzles, each around a theme and with their own linear progression. The clip above shows the start of a Resonant Tale set!

Splitting the game into sets does mean I now have a horizontally scrolling menu which does use text and tiles other than black/white in appearance, but I think that's a fair concession to making a more polished experience.

Little Hungers

An uneasy walk through the woods.

little_hungers_bowels

The forest at night is a dangerous place for a mouse.

little_hungers_perspective

I've only made a few screens, but I envision Little Hungers as a micro adventure game or walking sim. It's horror-adjacent, but more about general vibes of unease than actual frights or peril. I want every screen to be unique and visually appealing with differing perspectives yet minimalistic in use of tiles.

little_hungers_scrolling_forest

This is the last room I created, faking a scrolling forest that is larger than the screen. It's all fakery, the trees arranged to make a nice repeating pattern and with the player actually looping around the centre of the room, with the player's "coordinates" tracked in code (shown here for debugging) and the animals drawn in based on those coordinates. I think it's pretty effective!

Bunk-A-Bust

A vertical orientation crank controlled bomb survival game.

bunk-a-bust-teaser

Back when I was playing Little Big Planet on PS3, "bomb survival" levels were all the rage. I'm not sure where the specific genre originated, but in LBP they were quick and easy to make and fun to play, so there were loads of them. I thought a crank controlled Pulp-made variation would be a fun project, but I lost motivation given real-world events. It's parked for now, but I would like to revist it as the core gameplay is fun!

Pulp Fishing Prototype

A proof of concept for top-down fishing with the crank!

pulp_fishing_prototype

Probably the most complex code-wise of all of the above, this proof of concept is fully playable. It's hard to tell without UI elements and actual visuals, but there are multiple stages to fishing. You can move around to find a spot, then get locked in place when you cast your line. Casting involves you selecting distance and direction which are based on rod stats. You then have to wait for a bite and press A quickly enough to hook the fish, then reel it in with the crank while it fights against you - there's line strength in there too, just without any indication yet! Similarly unclear is that the fish you hook have their own stats (like exhaustion) and each water tile has its own set of fish that are catchable, with odds that can vary by tile and can be modified by your choice of lure.


That's all I'd like to share for now... but I've also been thinking about possible sequel ideas for Resonant Tale, as well as wanting to revisit some of my earlier pulp prototypes! I should definitely pick something to stick with through to completion but... that's always the hard part!

I'd love to hear what (if any) of the above people think is most exciting :slight_smile:

3 Likes

Thanks for sharing these, it's nice to have a few projects going on to keep the ideas flowing!

I actually really like the look/idea of Little Hungers, partly as I think the basicness of pulp tiles can encourage more imagination on the part of the player, hooking into that sense of unease. I also like that you've got different perspectives in there, and maybe there's scope to play with expectations in the style of something like Superliminal :upside_down_face:

Maybe you could even get the portrait mode view in there too, to really disorient players? :slight_smile:

1 Like