Indie game storeFree gamesFun gamesHorror games
Game developmentAssetsComics
SalesBundles
Jobs

Internet Janitor

16
Posts
2
Topics
14
Followers
A member registered Aug 02, 2018 · View creator page →

Creator of

Recent community posts

Fantastic stuff!

A few days ago, I discovered that there's apparently a homebrewed SDK, technical documentation, and some demo software available for the 3310: http://nokix.sourceforge.net/help/blacksphere/sub_050main.ht

Maybe next year it would be an interesting challenge to get a game not only running on the proper LCD module, but on the stock phone itself. There's a MAME profile for the 3310, but I have no idea offhand how mature it is or how difficult it would be to turn that into a web build.

On the off-chance anyone is interested, I did a mildly more technical writeup about a few things I did to make this game work over on the Dev Log for Octo, my Chip-8 development tool:

https://internet-janitor.itch.io/octo/devlog/123567/scripting-in-octo

Thanks for the kind words, and best of luck to everyone in the judging!

I appreciate the kind words. I'm glad I was able to successfully evoke the look of the 3310 OS.

(1 edit)

Thanks! I had many fond memories of playing Space Trader for PalmOS and Beer Hunt for the ti83+ for inspiration.

Well, the game centers around exploiting a plague financially. Death, in this case, is good for business. It's helpful to know that this idea wasn't communicated well.

Glad to hear you enjoyed it, in any case.

(1 edit)

Visuals read well, but sprites are not actually pixel-aligned. Movement feels sort of slippery. Accidentally nudging corpses off the edge of a platform is very easy and intensely frustrating. I greatly appreciate the forgiving checkpointing.

Graphics look great and read well. Allowing the user to select a font is a nice touch. The map is disappointingly empty for its size, though, which makes exploration less fun than it should be.

You might want to tag that binary as a Windows executable.

Don't have a windows machine handy, but your GIFs look pretty spiffy!

I enjoyed this. The UI was intuitive and fluid. While working through the story was mostly trial-and-error, it was short enough not to drag. Interesting to see the Nokia 3310 itself used as a narrative conceit.

Day 4:

And that's a wrap! Did some additional playtesting and asked some friends for feedback. This morning I added a handful of minor new features, like a fancier view for the day titlecard which imitates the Nokia 3310 home screen:


I'm pretty satisfied with how this all came together. Best of luck to everyone else's submissions!

Apropos of nothing, I think this is my favorite part of the source code to my game (name elided):


(Perhaps you can guess its function based on its visual structure, and what else you know about the game!)

Day 3:

Core gameplay is all working!


Today I added a dynamic event system. At the end of every turn, a random event may occur- perhaps you encounter a mysterious weapons dealer, or read a news story about the disaster unfolding in the city around you!

In order to ensure that pacing and difficulty stays controllable, I use multiple random pools. The events are pre-initialized in appropriate proportions in a large array. I then shuffle several segments within that array, and then draw from the array in sequence as days progress in-game. By shuffling segments instead of the entire array, I ensure that, for example, the events which progressively unlock buying and selling certain commodities will be spaced out over the course of a 45-day cycle, instead of bunched up together at the start or end of that timespan.

I'm closing in on the RAM limits of the CHIP-8 platform with this game. Using the "XO-Chip" extended instruction set my code has to fit in 3.5kb, with an additional 60kb of storage for static data- graphics, working storage, lookup tables, etc. Right now I'm down to about 190 bytes of free code space, and I've just barely squeezed in most of the mechanics I originally planned. A big part of making everything fit was the use of a small special-purpose script interpreter which allows me to store the logic which drives many text screens and dialogues in that more spacious data-RAM.

I also added loan sharks, combat, and several exciting ways to die! Don't take my word for it, though- a WIP build is now up on Itch:

https://internet-janitor.itch.io/business-is-contagious

The page includes a downloadable Octo Cartridge File which includes full source-code, if anyone is curious. I plan to spend tomorrow fleshing out a few minor nice-to-haves, tweaking balance, and adding polish. I'd greatly appreciate any feedback or suggestions you folks may have!

(2 edits)

Day 2:

I've added a dynamic economy. The implementation is pretty simple: each commodity you can trade has a table with prices for five levels of demand: Very low, Low, Medium, High, and Very High. Every location has their own demand level for each commodity, and on each turn the demand for a few commodities in a few locations will be shifted. Thus, commodities have recognizable "good prices" and "bad prices" (once you get a feel for it), some are inherently higher-margin than others, and areas have demands which are predictable enough to plan around, but varied over time and between games.

To help plan your next turn, you can buy information from informants for a small fee:


There's no guarantee that a hint will be very useful to capitalize upon, though. There's also a chance that the informant in one location might (consistently) be a liar! If you get bad information, I hope you remember who told you!

After actually playing for a while, I slightly redesigned the "buy quantity" display- now it shows both the total price and the number of items you're purchasing in a batch. I now consistently use "x" as a prefix in menus (like "x32") to indicate a quantity, and "$" as a prefix to indicate price.

It's now possible to end the game (this will be more of a strategic choice when everything else is finished):


Perhaps you'll find the casino and have a few rounds of Blackjack:


...hopefully getting luckier than I did.

Overall, still bare-bones, but it now resembles a playable game. Next, I need to implement a system for overall story progression within the city, in the form of semi-randomized interstitial events between turns, and a few more special features for certain areas of the city.

(1 edit)

I've decided to have a go at making a reinterpretation of the classic Drugwars. You'll play as a plague profiteer. Having snuck into a quarantined city grappling with an unknown infectious disease, you can buy, sell, and steal (among other things) medical supplies, clawing your way to massive profits, while taking care not to fall ill yourself or fail to escape before the plague overwhelms the city.

Since I'm writing my game in an assembly language I spent most of the morning working on foundations: higher-precision math, text and number rendering, and a flexible menu system modeled after the Nokia 3310 OS. Here's how it looks so far:


I have the rudimentary buy/sell/travel mechanics working. Tomorrow I'll need to add more mechanical flesh to these bones: dynamic markets, random events, loan sharks, informants, and more.

Octo is a development environment I maintain which targets the Chip-8 platform, a virtual game console from 1977. Working within the creative constraints of Chip-8 is in a very similar spirit to this game jam. I've prepared a pair of template programs that make it easier to respect the requirements of Nokiajam submissions: resolution and palette.

The SCHIP Template uses only instructions and capabilities from the SCHIP extensions to the basic Chip8 platform. To reduce the native resolution of 128x64 pixels to 84x48, a routine is included for filling a "letterbox" border around the logical screen. The advantage of using this template is that your game will be playable on any of the hundreds of SCHIP interpreters available on the internet.


http://johnearnest.github.io/Octo/index.html?key=aQPWzRRq

The XO-CHIP Template uses the newer XO-CHIP extended instructions introduced in Octo. The "letterbox" border in this example is drawn on a secondary graphics plane layered on top of the primary graphics plane. Unlike the SCHIP version, which requires the programmer to carefully avoid drawing graphics outside the logical boundary, this version will clip at the border automatically. It's set-and-forget. This also makes taking advantage of scrolling instructions much simpler than usual. Finally, XO-Chip has monophonic audio support, so your games can include a variety of evocative beeps and boops.


http://johnearnest.github.io/Octo/index.html?key=gDi7uAHs

Octo can export standalone HTML versions of games that are suitable for embedding on Itch pages- check out "Binary Tools -> Save HTML" in the Toolbox. There are even a number of mobile-friendly touch control schemes available.

If anyone has questions, feel free to reach out. I hope these resources are helpful for some other participants!

Great, thanks for clarifying!

(1 edit)

I think really the question is whether we're allowed to do something along the lines of letterboxing a game down to 84x48. For example, here's a very simple "SuperChip" CHIP-8 program which logically runs at 128x64 pixels, but which fills the border with a solid matte. The light-colored region of the screen, where one would draw game graphics, is 84x48: http://johnearnest.github.io/Octo/index.html?key=aQPWzRRq

Octo can use any colors for its palette (there are 2-color and 4-color palette modes available, the former of which is suitable for this Jam), but I think PICO-8 is off the table because its palette cannot be altered to meet the jam requrements.

Thanks! Doing low-res monochrome pixel art is really fun, because it's often more about "suggesting" visuals than representing them.