Games Mini Micro

I'm working on a neo-retro modern-80s style virtual home computer! It's called Mini Micro, and it uses MiniScript as both the command language and the programming language.

In addition to the standard MiniScript intrinsics, it'll have an API as defined here that lets you easily make 2D games. This Flappy Bat game took less than an hour, and that was while monkeying with the underlying code (adding non-uniform sprite scaling, for example) too.

I'm super excited about this project — I think it's going to be a fantastic way for newbies to learn programming, and for old timers to hack around and have some fun too.

 

You mean people like me, who may be nostalgic for programming on an old Apple ][ or C-64? I might be interested from that angle.

If I spent a year-and-a-half grinding out some sort of TSI-gold-box style game using your system, will I be able to make a regular Desktop build of the final product?

 

Yep. I'm in the same boat (obviously). Nostalgia value is definitely there, but I also honestly think it would be a good environment for teaching or learning. It's hard to beat a REPL for "learn by doing."

Yeah, I've been thinking about that. I don't see why not. It would be basically just Mini Micro itself, bundled with a "startup disk" (zip file) that contains your code and assets, set to automatically run on launch. Should be pretty easy to deploy that as a desktop or web app.

 

Noodling around this evening with some turtle graphics, just for fun.


That's not an approach to drawing that's part of the standard Mini Micro API; it's just something I defined as a class that combines a turtle sprite with the standard line-drawing routines (that's what's in the first 70 lines of code not listed above). I'll probably provide it as library you can import when you want to do this sort of thing.

 

Will there be simulated low-level stuff like POKEing numbers directly into the virtual frame buffer? This is where you could really get creative, back in the day.

I could definitely understand why you wouldn't want to include that sort of stuff, though, as it was mostly just to get around the suffocating performance and memory restrictions, which aren't really a problem anymore. It could be seen as adding a bunch of pointless complication.

 

Right. An early version of the system did have PEEK and POKE, but then (like you) I realized that was just a workaround for various limitations that no longer apply. You can still directly get/set pixels, for example, but you do it with gfx.pixel and gfx.setPixel.

 

Last night I wrote a little "Mochi Bounce" game in Mini Micro.


If you want to try it, this link will take you right into the game. When the game is over, enter

run

to play again, or

edit

to monkey with the code. Use

help

to learn other commands that are available (including how to find and run the other built-in demos).

 

I'm thrilled to announce the very first public release of Mini Micro as a stand-alone Mac and Windows app! Grab it here:

https://miniscript.org/MiniMicro/​

This is version 0.1. It does not yet have support for sounds or tile maps, but text, pixel graphics, and sprites are all working fine! See the development roadmap for details. And be sure to grab the Mini Micro Cheat Sheet, which gives you everything you need to know about Mini Micro and MiniScript itself in only two pages!

I welcome any feedback. Thanks for giving it a try!

 

I was looking at the code. Does "sys/pics/" refer to a path in the build, or does Mini Micro have it's own virtual file system?

 

It has a virtual file system; each "disk" is actually a zip file. The /sys disk is built in and read-only; there's also a "/usr" disk (in the Mac/Win desktop versions) that is created automatically on first run, where you can store your own files.

 

Mini Micro version 0.2 is now released! This version adds extensive sound support, including sounds loaded from WAV files and sounds synthesized in code. Grab the latest here:

https://miniscript.org/MiniMicro/​

See the development roadmap for details on how this fits into the grand scheme of things (hint: the only major feature not done at this point is tile maps!). And be sure to grab the Mini Micro Cheat Sheet, which gives you everything you need to know about Mini Micro and MiniScript itself in less than three pages!

 

This week I'm adding support for tile maps. It supports both rectangular and hexagonal grids, via "oddRowOffset" and "oddColOffset" properties you can set as needed to shift the hexes into place.



This is the last of the display types, along with Off, Solid Color, Text, Pixel, and Sprite. Mini Micro has 8 display layers, any of which can be set to any display type. For example:



This shows the default setup, with layer 7 (at the back) set to a solid color, layer 5 set for pixel graphics, layer 4 for sprites, and layer 3 for text, with the other layers turned off. In the hex map test above, I set layer 2 to a tile display.

In early testing, I'm finding this a very nice combination of simplicity and power — you can configure the eight display layers to easily make any sort of 2D game.

The new tile functionality will appear in Mini Micro version 0.3, probably next weekend or so.

 

If anybody is interested in learning to use Mini Micro, I've started a "Getting Started" series of posts that guide you through it step by step. The first post is here.

This is really aimed at people who have never done any programming before, or at least not where they have to type (Scratch would be a decent backgrounder, but is not necessary). Most folks here are probably way beyond that level. But maybe you know somebody who would like to learn, but finds Unity a bit intimidating? Point them to that link, and by Day 2 they'll be doing stuff like this!

 

I'm happy to announce that version 0.3 of Mini Micro is now available!

This version adds support for Tile displays. A tile display is a regular grid of little images which are drawn very efficiently. Good for things like game boards, maps, all the static stuff in a platformer, etc. All the classic Nintendo games, for example, were built on a combination of sprites and tiles — now you can do the same in Mini Micro!

As an example, try the new "Wumpus Trap" game. You'll find it in the /sys/demo directory, or if you want to play on the web, try this link (you may have to flush your cache or use a private window if it's still loading v0.2 for you).



As you can see, the Tile display supports both rectangular and hexagonal layouts (and other arrangements too, such as isometric — it's very flexible!). What will you create?

 

I'm happy to announce the release of Mini Micro version 0.4! This release adds a whole bunch of new file-related APIs, including:

• the view command for previewing any text file, MiniScript source file, image, or sound
• File.readLines and File.writeLines for easily reading/writing a text file (or MiniScript source file)
• File.open for detailed control over reading/writing a file, including random access to any position therin

and much more! We also fixed a little bug in the pixel display that could cause it to fail to display any drawing done immediately after setting a display to pixel mode for the first time.

In addition, we also gave the code editor a major update, with improved auto-indentation, and a nifty "shift-return" feature that inserts the correct block closer for the last block opener! For example, try typing while true in the code editor, and then instead of just pressing Return, press shift-Return. This will insert a blank line, then end while, and put the cursor on the blank line, ready for you to fill in the body. Works with any kind of block, including for, if, and function!

So head over to https://miniscript.org/MiniMicro/ and grab the latest build for Mac or Windows (want Linux? Post here to let us know!). And be sure to get the version 0.4 Mini Micro Cheat Sheet too, which has been updated with all the latest goodies!

 

I've just posted version 0.5 of Mini Micro! This version rounds out the pixel display drawing routines, including drawEllipse, drawPoly, and fillPoly. In addition, all the "draw" commands, plus line, now take an optional penSize parameter, allowing you to draw lines, rects, ovals, and polygon outlines that are more than 1 pixel thick. The turtle module in /sys/lib has been updated to have a penSize property too!



We've also added a mathutil module in /sys/lib, which provides functions for testing whether a point (or any of a whole set of points) is within a polygon, converting degrees to radians and back, and other handy stuff.

You'll also find a new Tic-Tac-Toe demo in /sys/demo, which uses the new pen size parameter to draw the board. It also plays a half-decent game, but could probably be made smarter... why not see if you can improve it?

This is the last major feature update for Mini Micro. All the pieces are in place now! Version 0.6 will focus on fixing any inconsistencies or small gaps in the APIs, making more demos, and polishing up the ones we have. Version 0.7 will probably focus on performance optimizations. And as always, if any bugs are found, they will be promptly squashed!

So give it a try, and please let me know what you think!

 

It's been a long while since an update; version 0.6 is supposed to be wrapping up last-minute features and polishing off the demos, and doing all that just takes time.

Today I got inspired by Kenny's 1-Bit Pack, and used it as an excuse to finally add support for per-tile tint colors to the TileDisplay APIs:



I'm also working on some utility libraries to go in the /libs folder, including some character controllers, like this platformer character:



So... lots of great stuff going on! Hoping to finish up v0.6 in about a week.

 

Mini Micro version 0.6 is finally available!



This version includes a lot of refinements, more consistent APIs, and new demos and library code. Among the fresh goodness:

• new drumMachine demo lets you lay down a sick beat
• new levelEditor serves as both a demo of tile displays, and a handy utility for laying out maps for use in your own games
• new libraries in /sys/lib including spriteControllers, tileUtils, and sounds, to make your coding go even faster
• code editor now has keyboard shortcuts for Cancel as well as Save & Exit
• for the first time, includes a Linux build!
• included MiniScript now supports line continuation, improved import behavior, and several other enhancements

I did not, unfortunately, have time to finish the textAdventure demo... but I'll do that in 0.7 for sure, in addition to making various under-the-hood optimizations to increase performance even further. Versions 0.7 through 1.0 will include new & improved demos, help, and sample code, as well as external features such as publishing your games to the web or as a stand-alone app.

At this point, the Mini Micro API should be considered complete; any changes between now and 1.0 will be minor, and even that only when there is a very strong reason. So this is a great time to check it out, download the Cheat Sheet, and get started!

 

Mini Micro v0.7 is now available!

This version includes nifty new demos, including Drum Machine and a completed mini text adventure.

It also includes a number of new features for you to use in your code, such as sprite bounds checking, hit testing, and support for HTTP. The Mini Micro Cheat Sheet has been expanded from 2 pages to 3 (not counting the MiniScript Quick Reference appended on the end), both to cover the new features and to allow room for some examples and reference tables.

Some minor changes were made to the APIs; in particular, the File class is now file (all lowercase), because it is a module, like color or displayMode (or the new http module), rather than a class you would use with new. Existing code will have to be updated accordingly.

You can play online (with some limitations) or download for Mac/Win/Linux from either miniscript.org, or from its (new!) itch.io project page. 100% free as in beer. Check it out today!

Best,
- Joe

P.S. We are starting to get a bit of activity in the MiniScript Rosetta Code Contest. As of this writing, the top entrant has implemented 2 (count 'em!) tasks. You can take the lead for the $25 gift card by implementing three simple tasks... or implement one, and still be in line for the second-place prize ($15). There are only two weeks left, so get crackin'!

 

Hi Joe,

I have a couple of questions around intrinsics method calls.

Firstly, the integration guide explains how to bind intrinsic MiniScript methods to C# code. Is there any way to group intrinsic methods together - like maybe a namespace, or static methods on a static MiniScript class?

You provide an assignOverride example from Mini Micro (TextDisplay), but I don't believe the project source is available. What would the user script code look like? Could you provide an example with both the C# and user script code?

 

On the second part, I think I get assignOverride now. I'm looking for a way to override value selectors (getters) in the same way? So when the user script calls map.myValue, a C# delegate is invoked to evaluate the result?

 

You've got the right idea. You can create a module simply by making a ValMap() and storing functions on it. Those functions will be invoked when the user calls map.myValue. And then you use assignOverride to intercept assignments, and do whatever you like there.

As an example, here's the code for the mouse module in Mini Micro.

Code (CSharp):

1.     static ValMap mouseModule;
2.     static ValMap MouseModule() {
3.         if (mouseModule != null) return mouseModule;
4.         mouseModule = new ValMap();
5.         mouseModule.map[_x] = ValNumber.zero;
6.         mouseModule.map[_y] = ValNumber.zero;
7.         mouseModule.assignOverride = DisallowAllAssignment;
8.    
9.         Intrinsic f;      
10.  
11.         // mouse.button
12.         f = Intrinsic.Create("");
13.         f.AddParam("which", ValNumber.zero);
14.         f.code = (context, partialResult) => {
15.             int buttonNum = context.GetVar("which").IntValue();
16.             return Input.GetMouseButton(buttonNum) ? Intrinsic.Result.True : Intrinsic.Result.False;
17.         };
18.         mouseModule["button"] = f.GetFunc();
19.        
20.         // mouse.visible
21.         f = Intrinsic.Create("");
22.         f.code = (context, partialResult) => {
23.             return Cursor.visible ? Intrinsic.Result.True : Intrinsic.Result.False;
24.         };
25.         mouseModule["visible"] = f.GetFunc();      
26.        
27.         mouseModule.assignOverride = (key, value) => {          
28.             if (key.ToString() == "visible") Cursor.visible = MiniscriptUtils.ToBool(value);
29.             return true;
30.         };
31.         return mouseModule;
32.     }

Notice how we're using unnamed intrinsics here, and simply stuffing them into the module. (Note: you're not seeing functions for x and y here because I handle those differently; there's a MonoBehaviour Update() method that simply stuffs Input.mousePosition.x and .y into this map on every frame. _x and _y are simply static ValStrings, to save the expense of creating two new ValStrings every frame.)

And then this MouseModule is returned by a global intrinsic, initialized with all the others:

Code (CSharp):

1.         f = Intrinsic.Create("mouse");
2.         f.code = (context, partialResult) => {
3.             return new Intrinsic.Result(MouseModule());
4.         };

Does that help?

 

That's great - I was wondering if there might be some way to bind functions to the map.

It certainly helps a great deal - thanks, Joe!!

What about this bit, though:

Is there a way to bind a global map and assign functions to it?

So for example, I want to group some time functions - I might want:

Time.createTimer - to create an instance of a timer object with functions and bound values such as duration and time remaining

Time.now - to return the current server time in seconds elapsed since epoch.

Could I create a global map called Time? Is there another/better way?

 

You've got it! It'd be the same as my mouse example above. Create a global intrinsic called Time, that returns your (probably static) ValMap that contains your createTimer and now functions (etc.). Just like I did above with mouse.button and mouse.visible.

 

Thank you very much, Joe!

I'm really enjoying using MiniScript. Actually, I just realized I posted this on the wrong thread. I meant to post it on the MiniScript thread - sorry about that!

 

No big deal. I'm very glad you're enjoying it! And don't forget, you can flex your MiniScript skills and win up to $25 in the MiniScript Rosetta Code Contest — the bar for first place is still quite low.

 

Mini Micro version 0.8 is now available!



Changes since v0.7 include:

• Fixed an issue with sprite reuse.
• Fixed a bug causing the shell to fail to load if user.minidisk is not found.
• Added PixelDisplay width and height, scale, scrollX, and scrollY.
• Fixed Sprite.worldBounds computation in the case of a flipped (scale < 0) sprite.
• PixelDisplay.drawPoly: now works more robustly with duplicated points and perfectly horizontal edges.
• Fixed line-drawing problem where the start or end pixel was not drawn.
• Changed how the listUtil module (also in /sys/lib) works; it now mainly adds extension methods to the list type.
• Added new include modules in /sys/lib: mapUtil and stringUtil.
• Revised shaders to fix issues seen on older graphics cards (with the side-benefit of being even more efficient on newer machines).
• Added accented Roman characters (char(191) through char(255)) to the main text font.
• Input history (accessed with up/down arrow) no longer includes empty inputs.
• Incorporated all the latest language enhancements of MiniScript 1.5.
• Updated the Mini Micro Cheat Sheet.

Known issues in this version:

• New accented Roman letters are not yet available in the "small" and "large" fonts (used with PixelDisplay.print).
• The file.open method may fail to create a file if it doesn't exist, at least when using native files (as opposed to a zipped user.minidisk).
• PixelDisplay.clear clears to black; we are considering making it clear to transparent instead.
• Many APIs will cause failures if given `null` where a non-null argument is expected.
• No support yet for playing looping sounds (this is planned).

This is most definitely a recommended update for all users. If you have any questions, concerns, or comments, post 'em here, or at the MiniScript forums, or even join us on Discord!

 

Mini Micro 0.9 has been a long time coming, mostly because it's a pretty big update and I'm intending it to be more or less feature complete. This 0.9 will be almost a 1.0 (because that last 10% always takes longer than you think anyway).

But the end is in sight! I've started a Mini Micro version 0.9 progress thread over at the MiniScript forums. This has what I believe is a complete list of everything I still need to do before I can push 0.9 out the door, and I'm updating it to check things off as I complete them.

Just to give a sneak peek at some of the upcoming features... the code editor is getting quite a lot of love this release:

 

I thought I'd share one of the demos I'm preparing for version 0.9...



Version 0.9 is getting very close! I expect it will ship within a week.

 

Version 0.9 will be out this week! So I made a little trailer. I just realized I should have included the above visibility demo in it, but forgot to do so. Oh well, I hope you enjoy it anyway...

 

Version 0.9 is now available! Download it from the MiniScript web site or from itch.io.

This is a major upgrade over v0.8, especially with regard to the built-in code editor, which has gotten a lot of love in this update. It now features an editing toolbar, a sophisticated Find/Replace function, quick navigation to functions by name, and so much more. It also got some bug fixes and general polish.

The machine itself is more sophisticated now too, with two (count 'em!) disk slots that you can simply click to mount any folder or zip file as a Mini Micro disk. Trust me, this is life-changing.

And finally, there is a long list of fixes and performance enhancements that make development in Mini Micro better in every way.

Here's the full release notes:

Bug Fixes
Fixed a sprite bug, where changing the position of a sprite while hidden failed to updated the bounds.
Fixed a bug that occurred when drawing an alpha-blended image into a PixelDisplay
(now uses the maximum alpha value between the previous and the new color).
Fixed a bug with string comparison operators.
Fixed file.readLines when working with Windows line endings.
Fixed miscellaneous indentation problems in the code editor.
Fixed a bug in PixelDisplay.getImage that did not return an image usable as a sprite, and can be scaled without blurring.

New APIs
Added Sound.duration for loaded sounds.
Added color.lerp function.
Added image.pixel and .setPixel.
Added Sound.loop.
Added Sound.stopAll.
Added file.saveImage to write out a PNG, JPEG, or TGA file.

New Machine Features
Text may now be selected and copied from the main TextDisplay, whenever the system is waiting for user input (showing a blinking cursor).
Added accented Latin characters to small and large fonts.
Updated TileDisplay so that it draws top to bottom, so when tiles overlap, you always see
more of the row that's lower on screen (and more to the right). So if making 2.5D
isometric tiles, they should be designed to show a bit of the bottom (front) side and
the right side, and then they will layer with each other properly.
Fixed support for alpha channel in the TileDisplay cell tint color.
Added three more characters to the fonts: micro, pi, and dot.
Added two "disk slots" below the screen. The top one is /usr, while the bottom one is /usr2 (note that /sys is built-in and does not have a disk slot). Click on either of these to mount or create a ".minidisk" zip file, or to mount a host OS folder as a disk.
Made substantial improvements to the code editor, including a toolbar with buttons and menus for all standard functions, including code snippets, find & replace, and more!
Added /sys/lib/chars to provide names for all special characters.
Deprecated env.includePaths and added env.importPaths. If you've been using env.includePaths, please update your code accordingly.
Replaced the native file browser component (used when importing and exporting files, and now when creating/mounting disks) with a different one that supports Linux.
Updated the look of the screen bezel.
Added "bootOpts.grfon" file which can be used when packaging your app to customize the boot sequence (details in the wiki).
Optimized drawing of large filled rectangles, ellispes, and polygons (5X faster in my benchmarks).

New/Improved Demos and Library Modules
Added benchmark program to /sys/demo
Fixed a bug in textUtil.printWrap, and added stringUtil.wrap.
Added /sys/lib/tsv for reading files in Tab-Separated Value format.
Added handy new methods in the listUtil and mapUtil modules in /sys/lib (see these files for details).
Added more demos, such as "2dVis", "balloons", and "speedConquest", to /sys/demo.

 

Just wanted to say, looking really great Joe! Keep ups great work

 

To celebrate the release of v0.9, I'm hosting the Mini Micro v0.9 Game Jam, and giving away $90 in prizes!

If you're stuck at home for a while, why not use the time to learn this cool neo-retro programming environment, make a cool game, and maybe even win a prize?

 

Wow that's really generous, good luck with the entries.

 

I've updated Mini Micro to version 0.9.2. Changes since 0.9.1:

• Added `file.loadRaw` and `file.saveRaw`, for loading/saving raw binary data.
• Added support for loading sounds (WAV and OGG format) via `http.get`.
• Fixed detection of content-type "application/json" as text in `http.get` (broken in 0.9.1).
• Fixed detection of the Escape and Tab keys in the WebGL version.
• Fixed detection of quote, tilde, backtick, and caret keys on Mac using the "US - International PC" keyboard layout.

Download the latest & greatest from the Mini Micro home page or its itch.io page.

And don't forget to join the upcoming game jam — it starts in two weeks!

 

Just wanted to remind everyone that the Mini Micro 0.9 Game Jam starts one week from today!

We currently have 21 participants from all over the world. Some of them are brand new to game coding; others are experienced veterans (though all are new to the Mini Micro environment). Join us! It's going to be fun.