MiniScript Wiki - User contributions [en]

How to mount a virtual disk in Mini Micro

2026-02-08T16:26:56Z

JoeStrout:

A "virtual disk" is just a folder, .zip file, .minidisk file, or [[Image Disks|image disk]] which can be used with Mini Micro. Mini Micro can mount (make use of) two virtual disks at any one time; these are called "/usr" and "/usr2" in the Mini Micro file system.

There are two methods for mounting a virtual disk:

== 1. Disk slot menu ==

Click on one of the two disk slots in the lower-left corner of the Mini Micro window, below the Mini Micro screen. Select "Mount Folder..." or "Mount Disk File...". Select the file or folder you want to use.

[[File:MountFolder.png|frameless]]

== 2. Drag and Drop (Mac/Windows only) ==

Have Mini Micro already running. Grab the folder or file you want to mount in the Windows Explorer or Mac Finder. Drag it onto the Mini Micro window, and let go. The folder or disk file will be mounted in slot 1, i.e. "/usr". (It is not possible to load a disk as /usr2 using this method.)

[[Category:Mini Micro]]
[[Category:How To]]

How to package a Mini Micro game

2026-02-08T16:25:51Z

JoeStrout:

To "package" a [[Mini Micro]] game means to bundle up all the files into a format that end-users can download (or access on the web) and play without needing anything else.

The basic idea is simple: Mini Micro will automatically look for a zip file (or folder) next to the executable called '''user.minidisk''', and if it finds this, it would automatically mount that as '''/usr''' and run any program it finds there as '''/usr/startup.ms'''. So packaging amounts to taking a standard Mini Micro distribution, adding the desired '''user.minidisk''' file, and tweaking things like the app name and icon. Exact details, though, vary with the platform you're targeting.

Note that while the directions below include links to zip instructions/tools on the corresponding platform, it is ''not'' necessary to be on the platform you are packaging for. In other words, it should work perfectly well to package for all platforms, from whatever platform you happen to use. Also note that the first three steps in each section below are the same, and only need to be done once no matter how many platforms you package for.

== Packaging for Windows Download ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that runs your program. For example, your startup.ms might contain just <c>run "myGame"</c>.
# If your virtual disk is (in the real file system) a folder, [https://www.laptopmag.com/articles/how-to-zip-files-windows-10 zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''. Test it by [[How to mount a virtual disk in Mini Micro|mounting]] this user.minidisk file in Mini Micro, and then <c>reboot</c>; it should launch your game.
# Download the Windows distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''Mini Micro.exe''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''Mini Micro_Data/StreamingAssets''' subfolder.
# If you like, rename '''Mini Micro.exe''' to the name of your game. Note: Do not forget to change the folder '''Mini Micro_data''' to the name change with the exe with '''_data'''. example: '''strat.exe''', data folder would be '''strat_data'''.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the .exe, your '''user.minidisk''' file, and everything else that came with the original Windows distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for MacOS Download ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that runs your program. For example, your startup.ms might contain just <c>run "myGame"</c>.
# If your virtual disk is (in the real file system) a folder, [https://www.lifewire.com/how-to-zip-and-unzip-files-and-folders-on-a-mac-2260188 zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''. Test it by [[How to mount a virtual disk in Mini Micro|mounting]] this user.minidisk file in Mini Micro, and then <c>reboot</c>; it should launch your game.
# Download the MacOS distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.app''' file. (If you are doing this in Windows or Linux, '''MiniMicro.app''' will appear as a folder; on a Mac, the same folder appears as an app, and the .app extension may be hidden.)
# If desired, make a '''[[bootOpts.grfon]]''' file, and place that inside the application bundle under '''Contents/Resources/Data/StreamingAssets'''.
# If you like, rename '''MiniMicro.app''' to the name of your game.
# Zip up (or place on a [https://support.apple.com/guide/disk-utility/create-a-disk-image-dskutl11888/mac disk image]) the whole folder containing the app and your '''user.minidisk''' file.

The resulting zip or DMG can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for Linux Download ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that runs your program. For example, your startup.ms might contain just <c>run "myGame"</c>.
# If your virtual disk is (in the real file system) a folder, [https://www.cyberciti.biz/tips/how-can-i-zipping-and-unzipping-files-under-linux.html zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''. Test it by [[How to mount a virtual disk in Mini Micro|mounting]] this user.minidisk file in Mini Micro, and then <c>reboot</c>; it should launch your game.
# Download the Linux distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.x86_64''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''MiniMicro_Data/StreamingAssets''' folder.
# If you like, rename '''MiniMicro.x86_64''' to the name of your game.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the executable, your '''user.minidisk''' file, and everything else that came with the original Linux distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for the Web ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that runs your program. For example, your startup.ms might contain just <c>run "myGame"</c>.
# If your virtual disk is (in the real file system) a folder, zip the contents of that folder. Rename the zip file exactly '''user.minidisk'''. Test it by [[How to mount a virtual disk in Mini Micro|mounting]] this user.minidisk file in Mini Micro, and then <c>reboot</c>; it should launch your game.
# Download the WebGL Template from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file into the '''StreamingAssets''' folder, replacing the (empty) user.minidisk there in the template.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that next to '''user.minidisk'''.
# If uploading to itch.io, zip up the whole folder containing '''Build''', '''index.html''', and '''StreamingAssets'''.
# Upload that archive to itch.io, or upload the folder to your web site. If asked for viewport dimensions, use 1024 by 768 pixels.

== Common problems ==

* When making your '''user.minidisk''' file from a mounted folder, make sure you zip the ''contents'' of the folder, not the folder itself.
* Also be sure the result is actually named '''user.minidisk''', rather than '''user.minidisk.zip'''. (Some file managers will try to "helpfully" keep the .zip extension, and just hide it from you in the UI; use a terminal window to be sure.)

[[Category:Mini Micro]]
[[Category:How To]]

How to mount a virtual disk in Mini Micro

2026-02-08T16:21:01Z

JoeStrout: Created page with "A "virtual disk" is just a folder, .zip file, .minidisk file, or image disk which can be used with Mini Micro. Mini Micro can mount (make use of) two virtual..."

How to package a Mini Micro game

2026-02-08T15:40:41Z

JoeStrout:

To "package" a [[Mini Micro]] game means to bundle up all the files into a format that end-users can download (or access on the web) and play without needing anything else.

The basic idea is simple: Mini Micro will automatically look for a zip file (or folder) next to the executable called '''user.minidisk''', and if it finds this, it would automatically mount that as '''/usr''' and run any program it finds there as '''/usr/startup.ms'''. So packaging amounts to taking a standard Mini Micro distribution, adding the desired '''user.minidisk''' file, and tweaking things like the app name and icon. Exact details, though, vary with the platform you're targeting.

Note that while the directions below include links to zip instructions/tools on the corresponding platform, it is ''not'' necessary to be on the platform you are packaging for. In other words, it should work perfectly well to package for all platforms, from whatever platform you happen to use. Also note that the first three steps in each section below are the same, and only need to be done once no matter how many platforms you package for.

== Packaging for Windows Download ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.laptopmag.com/articles/how-to-zip-files-windows-10 zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the Windows distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''Mini Micro.exe''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''Mini Micro_Data/StreamingAssets''' subfolder.
# If you like, rename '''Mini Micro.exe''' to the name of your game. Note: Do not forget to change the folder '''Mini Micro_data''' to the name change with the exe with '''_data'''. example: '''strat.exe''', data folder would be '''strat_data'''.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the .exe, your '''user.minidisk''' file, and everything else that came with the original Windows distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for MacOS Download ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.lifewire.com/how-to-zip-and-unzip-files-and-folders-on-a-mac-2260188 zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the MacOS distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.app''' file. (If you are doing this in Windows or Linux, '''MiniMicro.app''' will appear as a folder; on a Mac, the same folder appears as an app, and the .app extension may be hidden.)
# If desired, make a '''[[bootOpts.grfon]]''' file, and place that inside the application bundle under '''Contents/Resources/Data/StreamingAssets'''.
# If you like, rename '''MiniMicro.app''' to the name of your game.
# Zip up (or place on a [https://support.apple.com/guide/disk-utility/create-a-disk-image-dskutl11888/mac disk image]) the whole folder containing the app and your '''user.minidisk''' file.

The resulting zip or DMG can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for Linux Download ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.cyberciti.biz/tips/how-can-i-zipping-and-unzipping-files-under-linux.html zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the Linux distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.x86_64''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''MiniMicro_Data/StreamingAssets''' folder.
# If you like, rename '''MiniMicro.x86_64''' to the name of your game.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the executable, your '''user.minidisk''' file, and everything else that came with the original Linux distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for the Web ==

# Make a virtual disk (folder or .minidisk) containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, zip the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the WebGL Template from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file into the '''StreamingAssets''' folder, replacing the (empty) user.minidisk there in the template.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that next to '''user.minidisk'''.
# If uploading to itch.io, zip up the whole folder containing '''Build''', '''index.html''', and '''StreamingAssets'''.
# Upload that archive to itch.io, or upload the folder to your web site. If asked for viewport dimensions, use 1024 by 768 pixels.

== Common problems ==

* When making your '''user.minidisk''' file from a mounted folder, make sure you zip the ''contents'' of the folder, not the folder itself.
* Also be sure the result is actually named '''user.minidisk''', rather than '''user.minidisk.zip'''. (Some file managers will try to "helpfully" keep the .zip extension, and just hide it from you in the UI; use a terminal window to be sure.)

[[Category:Mini Micro]]
[[Category:How To]]

How to package a Mini Micro game

2025-09-15T16:33:32Z

JoeStrout:

To "package" a [[Mini Micro]] game means to bundle up all the files into a format that end-users can download (or access on the web) and play without needing anything else.

The basic idea is simple: Mini Micro will automatically look for a zip file (or folder) next to the executable called '''user.minidisk''', and if it finds this, it would automatically mount that as '''/usr''' and run any program it finds there as '''/usr/startup.ms'''. So packaging amounts to taking a standard Mini Micro distribution, adding the desired '''user.minidisk''' file, and tweaking things like the app name and icon. Exact details, though, vary with the platform you're targeting.

Note that while the directions below include links to zip instructions/tools on the corresponding platform, it is ''not'' necessary to be on the platform you are packaging for. In other words, it should work perfectly well to package for all platforms, from whatever platform you happen to use. Also note that the first three steps in each section below are the same, and only need to be done once no matter how many platforms you package for.

== Packaging for Windows Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.laptopmag.com/articles/how-to-zip-files-windows-10 zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the Windows distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''Mini Micro.exe''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''Mini Micro_Data/StreamingAssets''' subfolder.
# If you like, rename '''Mini Micro.exe''' to the name of your game. Note: Do not forget to change the folder '''Mini Micro_data''' to the name change with the exe with '''_data'''. example: '''strat.exe''', data folder would be '''strat_data'''.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the .exe, your '''user.minidisk''' file, and everything else that came with the original Windows distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for MacOS Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.lifewire.com/how-to-zip-and-unzip-files-and-folders-on-a-mac-2260188 zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the MacOS distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.app''' file. (If you are doing this in Windows or Linux, '''MiniMicro.app''' will appear as a folder; on a Mac, the same folder appears as an app, and the .app extension may be hidden.)
# If desired, make a '''[[bootOpts.grfon]]''' file, and place that inside the application bundle under '''Contents/Resources/Data/StreamingAssets'''.
# If you like, rename '''MiniMicro.app''' to the name of your game.
# Zip up (or place on a [https://support.apple.com/guide/disk-utility/create-a-disk-image-dskutl11888/mac disk image]) the whole folder containing the app and your '''user.minidisk''' file.

The resulting zip or DMG can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for Linux Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.cyberciti.biz/tips/how-can-i-zipping-and-unzipping-files-under-linux.html zip] the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the Linux distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.x86_64''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''MiniMicro_Data/StreamingAssets''' folder.
# If you like, rename '''MiniMicro.x86_64''' to the name of your game.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the executable, your '''user.minidisk''' file, and everything else that came with the original Linux distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for the Web ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, zip the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the WebGL Template from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file into the '''StreamingAssets''' folder, replacing the (empty) user.minidisk there in the template.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that next to '''user.minidisk'''.
# If uploading to itch.io, zip up the whole folder containing '''Build''', '''index.html''', and '''StreamingAssets'''.
# Upload that archive to itch.io, or upload the folder to your web site. If asked for viewport dimensions, use 1024 by 768 pixels.

== Common problems ==

* When making your '''user.minidisk''' file from a mounted folder, make sure you zip the ''contents'' of the folder, not the folder itself.
* Also be sure the result is actually named '''user.minidisk''', rather than '''user.minidisk.zip'''. (Some file managers will try to "helpfully" keep the .zip extension, and just hide it from you in the UI; use a terminal window to be sure.)

[[Category:Mini Micro]]
[[Category:How To]]

Sprite

2025-08-05T22:46:18Z

JoeStrout: add uvs and setUVs

<c>Sprite</c> is a built-in class in the [[Mini Micro]] API. It represents an image which can be added to a [[SpriteDisplay]], enabling it to be drawn to the screen very efficiently while also being scaled, rotated, or tinted, and layered consistently with other sprites and the surrounding displays.

== Methods and properties used with Sprite objects ==

Use these methods on Sprite instances, created with <c>[[new]] Sprite</c>.
{| class="wikitable"
|-
! Method or Property !! Purpose !! Type
|-
| colspan=3 style="text-align: center;" | '''Edit and read'''
|-
| [[Sprite.image]] || image displayed by the sprite || [[Image]]
|-
| [[Sprite.x]] || horizontal position of the sprite || number
|-
| [[Sprite.y]] || vertical position of the sprite || number
|-
| [[Sprite.scale]] || sprite scale (default 1.0) || number
|-
| [[Sprite.rotation]] || sprite rotation (degrees counter-clockwise) || number
|-
| [[Sprite.tint]] || tint color (defaults to white) || string (color)
|-
| [[Sprite.localBounds]] || stores the local bounds of the sprite || [[Bounds]]
|-
| colspan=3 style="text-align: center;" | '''Read only'''
|-
|-
| [[Sprite.worldBounds]] || computes world bounds from local bounds and current position || pair of numbers
|-
| [[Sprite.contains]](''x'', ''y'') || return whether the sprite contains the given world point || bool
|-
| [[Sprite.overlaps]](''other'') || return whether this sprite is touching another sprite or [[Bounds]] || bool
|-
| [[Sprite.corners]] || return <c>[x,y]</c> screen positions of the four corners of this sprite, counter-clockwise from bottom left || 4 pairs of numbers
|-
| [[Sprite.uvs]] || return <c>[u,v]</c> texture coordinates of the four corners of this sprite, counter-clockwise from bottom left || 4 pairs of numbers
|-
| colspan=3 style="text-align: center;"| '''Run'''
|-
| [[Sprite.setCorners]] ''corners''|| set new screen positions for the four sprite corners (counter-clockwise from bottom left)
|-
| [[Sprite.setUVs]] ''uvs''|| set new texture coordinates for the four sprite corners (counter-clockwise from bottom left)
|-

|}

== Usage Notes (Soda) ==

In [[Soda]] there is currently only one, implicit, [[Display]]. So to add sprites to this display, push them onto a global list called <c>sprites</c>.

[[Soda]] does not currently support [[Sprite.corners]] or [[Sprite.setCorners]].

== Example ==

This example creates a sprite, loads it into display 4 (which by default is a [[SpriteDisplay]]), and rotates it through 360 degrees.

<ms>spr = new Sprite
spr.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push spr
spr.x = 480
spr.y = 320
for r in range(0,360)
spr.rotation = r
yield
end for</ms>

== See also ==

* [[How to move a sprite forward]]
* [[How to detect a click on a sprite]]
* [[How to move a sprite with directional inputs]]
* [[How to load a sprite from the web]]
* [[How to make a sprite translucent]]
* [[How to move a sprite towards a target]]
* [[How to point a sprite at a target]]
* [[How to use a sprite sheet]]

[[Category: Mini Micro]]
[[Category: Soda]]

Lua

2025-08-01T22:21:42Z

JoeStrout: /* Lists */ fix formatting typo

Lua is a scripting language first released in 1993, and particularly popular as an embedded language. This article compares Lua to MiniScript, and may be useful to people coming to MiniScript with a background in Lua.

For a side-by-side comparison on a collection of short programs, see [https://miniscript.org/compare/lua.html here].

== Similarities ==

=== Block Syntax ===

Both Lua and MiniScript delineate code blocks and control structures with explicit keywords. There are some minor differences in syntax, summarized in the table below.

{| class="wikitable"
|-
! Lua
! MiniScript
|-
| function / end
| function / end function
|-
| if / elseif / end
| if / else if / end if
|-
| while ... do / end
| while / end while
|-
| for i = 1, 10, 2 do / end 
| for i in range(1, 10, 2) / end for 
|-
| repeat / until
| style="font-style:italic;" | (no direct equivalent)
|}

The most notable difference is that while Lua uses <c>end</c> alone to terminate a <c>function</c>, <c>if</c>, <c>while</c>, or <c>for</c> block, MiniScript uses <c>end function</c>, <c>end if</c>, <c>end while</c>, and <c>end for</c> respectively. MiniScript lacks a <c>repeat</c>-<c>until</c> structure; the standard idiom is to use a <c>while true</c> (infinite) loop, and [[break]] out of it when termination conditions are met.

=== Data Types ===

Five of the seven basic types in Lua -- nil, number, string, function, and table -- have direct equivalents in MiniScript. '''nil''' is called <c>[[null]]</c> in MiniScript, and tables are called ''maps''.

Strings in both languages are immutable. MiniScript strings are Unicode, and index by Unicode character; interpretation of Lua strings is implementation-dependent, and index by byte. While Lua has several ways of writing string literals, in MiniScript, string literals are always enclosed in double-quotes (and if you need a double-quote inside a string literal, write it twice, as in SQL).

<ms>greeting = "Hello, ""Bob""! Pleased to meet you."
print greeting // prints: Hello, "Bob"! Pleased to meet you.</ms>

While MiniScript maps are conceptually quite similar to Lua tables, their syntax and usage is rather different; see the section on '''Maps''' under Differences.

== Differences ==

=== Variable Scope ===

In Lua, variables are always global by default; you use the <c>local</c> keyword to explicitly declare a local variable. In MiniScript, variables are always local by default (and are never declared; they spring into being when you assign to them). To update a global variable in MiniScript from within a function, you would use the [[globals]] or [[outer]] prefix.

=== Lists ===

Perhaps the biggest difference between Lua and Python is in handling of array-like data. MiniScript has a '''list''' data type with no direct Lua equivalent. Readers comfortable with [[Python]] should think of it as a Python-style list; others may find the following table helpful.

{| class="wikitable"
|-
! Task
! Lua
! MiniScript
|-
| Create an array literal
| a = {"one", "two", "three"} 
| a = ["zero", "one", "two"]
|-
| Print the first item in an array 
| print(a[1])
| print a[0]
|-
| Print the entire array
| print(table.concat(a, ", "))
| print a
|-
| Get the length of an array
| print(#a)
| print a.len
|-
| Append an item to an array
| table.insert(a, "foo") 
| a.push "foo"
|-
| Insert item at front of array
| table.insert(a, 1, "hey")
| a.insert 0, "hey"
|- style="border-color:inherit;"
| Pop the last item off the array
| last = table.remove(a)
| last = a.pop
|- style="border-color:inherit;"
| Pull the first item off the array
| first = table.remove(a, 1) 
| first = a.pull
|- style="border-color:inherit;"
| Remove item at index ''i''
| table.remove(a, i) 
| a.remove i
|-
| Get index of an array item
| style="font-style:italic;" | no standard method
| idx = a.indexOf("two")
|-
| Get sub-array from ''i'' to ''j''
| style="font-style:italic;" | no standard method
| print a[i:j]
|}

The key differences to note:
* MiniScript lists are 0-based, rather than 1-based
* MiniScript lists are manipulated by [[Slice|slicing]] or [[Dot syntax|dot-syntax]] methods like <c>len</c>, <c>insert</c>, and <c>remove</c>, rather than by functions in the <c>table</c> module.
* MiniScript lists can safely contain [[null]].
* MiniScript lists can be concatenated with the <c>+</c> operator.

=== Maps ===

Lua tables (when used as associative arrays, not list-style arrays) are similar in purpose to MiniScript maps, but there are a number of differences.

Maps in MiniScript can take any data type as keys. In map literals these keys use the same syntax as in any other context (unlike in Lua, where string keys are specified without quotes if they are valid identifiers, or with square brackets plus quotes otherwise). Instead of <c>=</c>, MiniScript uses <c>:</c> to separate the keys from the values.

{| class="wikitable"
|-
! Lua
! MiniScript
|-
| <pre>d = {one=1, two=2, three=3, ["forty two"]=42}</pre>
| <ms>d = {"one":1, "two":2, "three":3, "forty two":42}</ms>
|}

Accessing items by key is done with square-brackets in both languages. When the keys are valid identifiers, MiniScript also allows [[dot syntax]].
<ms>print d["one"]
d["one"] = "uno"
d.two = "dos"</ms>

Iterating over the key-value pairs is common in both languages, but the syntax is different. In MiniScript, iterating over a map gives you, on each iteration, a little map containing <c>key</c> and <c>value</c>.

{| class="wikitable"
|-
! Lua
! MiniScript
|-
| <pre>for k,v in pairs(d)
do print(k,v)
end</pre>
| <ms>for kv in d
print kv.key + " " + kv.value
end for</ms>
|}

Commonly used map methods include [[len]], [[remove]], [[hasIndex]], [[indexOf]], [[indexes]], and [[values]]. Note that [[len]] returns the number of key-value pairs in the map, which is different from both <c>getn</c> and <c>#</c> in Lua.

<ms>print "This map has " + d.len + " pairs in it."
print "The keys are: " + d.indexes
print "and values are: " + d.values
if d.hasIndex("two") then
print """two"" is one of the indexes, and its value is " + d["two"]
else
print "but ""two"" is not one of the indexes."
end if
print "The index that maps to ""uno"" is: " + d.indexOf("uno")</ms>

Maps can be combined with the `+` operator.

=== Strings ===

Strings in MiniScript and Lua are similar in most ways, though in MiniScript, all strings are composed of Unicode characters and indexing is always by character rather than by byte. The table below shows common operations in both languages.

{| class="wikitable"
|-
! Task
! Lua
! MiniScript
|-
| Assign a string literal
| s = "Hello world!"
| s = "Hello world!"
|-
| Print the first character of a string 
| print(string.sub(s,1,1))
| print s[0]
|-
| Print all but the first 2 characters
| print(string.sub(s,3)
| print s[2:]
|-
| Get the length of a string
| print(#s)
| print s.len
|-
| Combine two strings
| s = "Really... " .. s
| s = "Really... " + s
|-
| Get index of a substring
| idx = string.find(s, "world")
| idx = s.indexOf("world")
|-
| Get substring from ''i'' to ''j''
| print(string.sub(i,j))
| print s[i:j]
|}

[[Category:Community]]

User:Darryl5137

2025-07-28T20:40:56Z

JoeStrout: Removed spam link.

25 year-old Account Coordinator Bevon Edmundson, hailing from Keswick enjoys watching movies like Yumurta (Egg) and Air sports. Took a trip to San Marino Historic Centre and Mount Titano and drives a S40.

How to package a Mini Micro game

2025-07-27T13:11:14Z

JoeStrout: /* Packaging for the Web */

To "package" a [[Mini Micro]] game means to bundle up all the files into a format that end-users can download (or access on the web) and play without needing anything else.

The basic idea is simple: Mini Micro will automatically look for a zip file (or folder) next to the executable called '''user.minidisk''', and if it finds this, it would automatically mount that as '''/usr''' and run any program it finds there as '''/usr/startup.ms'''. So packaging amounts to taking a standard Mini Micro distribution, adding the desired '''user.minidisk''' file, and tweaking things like the app name and icon. Exact details, though, vary with the platform you're targeting.

Note that while the directions below include links to zip instructions/tools on the corresponding platform, it is ''not'' necessary to be on the platform you are packaging for. In other words, it should work perfectly well to package for all platforms, from whatever platform you happen to use. Also note that the first three steps in each section below are the same, and only need to be done once no matter how many platforms you package for.

== Packaging for Windows Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.laptopmag.com/articles/how-to-zip-files-windows-10 zip it]. Rename the zip file exactly '''user.minidisk'''.
# Download the Windows distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''Mini Micro.exe''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''Mini Micro_Data/StreamingAssets''' subfolder.
# If you like, rename '''Mini Micro.exe''' to the name of your game. Note: Do not forget to change the folder '''Mini Micro_data''' to the name change with the exe with '''_data'''. example: '''strat.exe''', data folder would be '''strat_data'''.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the .exe, your '''user.minidisk''' file, and everything else that came with the original Windows distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for MacOS Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.lifewire.com/how-to-zip-and-unzip-files-and-folders-on-a-mac-2260188 zip it]. Rename the zip file exactly '''user.minidisk'''.
# Download the MacOS distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.app''' file. (If you are doing this in Windows or Linux, '''MiniMicro.app''' will appear as a folder; on a Mac, the same folder appears as an app, and the .app extension may be hidden.)
# If desired, make a '''[[bootOpts.grfon]]''' file, and place that inside the application bundle under '''Contents/Resources/Data/StreamingAssets'''.
# If you like, rename '''MiniMicro.app''' to the name of your game.
# Zip up (or place on a [https://support.apple.com/guide/disk-utility/create-a-disk-image-dskutl11888/mac disk image]) the whole folder containing the app and your '''user.minidisk''' file.

The resulting zip or DMG can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for Linux Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.cyberciti.biz/tips/how-can-i-zipping-and-unzipping-files-under-linux.html zip it]. Rename the zip file exactly '''user.minidisk'''.
# Download the Linux distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.x86_64''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''MiniMicro_Data/StreamingAssets''' folder.
# If you like, rename '''MiniMicro.x86_64''' to the name of your game.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the executable, your '''user.minidisk''' file, and everything else that came with the original Linux distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for the Web ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, zip the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the WebGL Template from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file into the '''StreamingAssets''' folder, replacing the (empty) user.minidisk there in the template.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that next to '''user.minidisk'''.
# If uploading to itch.io, zip up the whole folder containing '''Build''', '''index.html''', and '''StreamingAssets'''.
# Upload that archive to itch.io, or upload the folder to your web site. If asked for viewport dimensions, use 1024 by 768 pixels.

== Common problems ==

* When making your '''user.minidisk''' file from a mounted folder, make sure you zip the ''contents'' of the folder, not the folder itself.
* Also be sure the result is actually named '''user.minidisk''', rather than '''user.minidisk.zip'''. (Some file managers will try to "helpfully" keep the .zip extension, and just hide it from you in the UI; use a terminal window to be sure.)

[[Category:Mini Micro]]
[[Category:How To]]

Apps using MiniScript

2025-05-27T14:13:59Z

JoeStrout:

This page is an (incomplete) list of games and other applications (other than [[Mini Micro]]) that use MiniScript in some way that's exposed to players/end-users.

* [https://store.steampowered.com/app/1383570/Ballex2_The_Hanging_Gardens/ Ballex²: The Hanging Gardens]: ball-rolling skill/puzzle game. MiniScript is used in the creation of custom levels.

* [[Farmtronics]]: mod for Stardew Valley that adds a MiniScript-programmable home computer and farm robots.

* [https://store.steampowered.com/app/2027330/GoreBox/ GoreBox]: 3D physics-based sandbox game. Uses MiniScript in the creation of custom levels.

* [https://store.steampowered.com/app/605230/Grey_Hack/ Grey Hack]: massively multiplayer online hacking game. Uses MiniScript extensively as the built-in scripting language, a central part of the gameplay experience.

* [https://store.steampowered.com/app/2312770/Linkito/ Linkito]: gadget-building puzzle game. MiniScript is used for advanced programmable components.

* [https://store.steampowered.com/app/2809460/Terminal_ESC/ Terminal/ESC]: puzzle game in a simulated computer that uses MiniScript as the programming language.

* [https://machiaworx.net/?p=914 Re:Code]: live-coding music sequencing software; write MiniScript code to make music in real time! ([https://www.youtube.com/watch?v=g52rHtOzGnI Demo Movie])

* [https://store.steampowered.com/app/3384560/Pastopia_Demo/ Pastopia]: Third-person, open-world adventure where MiniScript coding unlocks the secrets of a forgotten world.

[[Category:Community]]

Sound

2025-04-12T17:07:41Z

JoeStrout: /* Methods and properties used with Sound objects */

In [[Mini Micro]], the <msinline>Sound</msinline> class both represents individual audio clips that can be played, and a handful of global sound-related properties and methods.

=== Methods and properties called on Sound ===

Use the following properties and methods directly on the Sound class itself.

{| class="wikitable"
|-
! Method or Property !! Purpose
|-
| [[Sound.sineWave]] || represents a sine wave (pure tone)
|-
| [[Sound.triangleWave]] || represents a triangle wave (almost pure)
|-
| [[Sound.sawtoothWave]] || represents a sawtooth wave (slightly "buzzier")
|-
| [[Sound.squareWave]] || represents a square wave (most buzzy/retro sound)
|-
| [[Sound.noiseWave]] || creates a pseudo-random "static" waveform
|-
| [[Sound.stopAll]] || stops all currently playing sounds
|}

=== Methods and properties used with Sound objects ===

Use these methods on Sound instances, created with <c>[[new]] Sound</c> or <c>[[file.loadSound]]</c>.

{| class="wikitable"
|-
! Method or Property !! Purpose
|-
| [[Sound.duration]] || length of the sound, in seconds
|-
| [[Sound.freq]] || sound frequency, i.e. how many times the waveform is repeated per second
|-
| [[Sound.envelope]] || volume over time (0 to 1)
|-
| [[Sound.waveform]] || shape of waveform over an audio cycle
|-
| [[Sound.fadeIn]] || length of the fade-in period when the sound begins, in seconds
|-
| [[Sound.fadeOut]] || length of the fade-out period when the sound ends, in seconds
|-
| [[Sound.loop]] || true (1) to set the sound to repeat indefinitely until stopped
|-
| [[Sound.init]] ''duration'',''freq'',''envelope'',''waveform'' || initialize a sound with the given parameters
|-
| [[Sound.mix]] ''sound2'',''level'' || add another synthesized sound into this one
|-
| [[Sound.play]] ''volume'',''pan'',''speed'' || play this sound (looping if [[Sound.loop|.loop]] is true)
|-
| [[Sound.adjust]] ''volume'',''pan'',''speed'' || change volume/pan/speed of a playing sound
|-
| [[Sound.isPlaying]] || returns true (1) while sound is playing, false (0) otherwise
|-
| [[Sound.stop]] || stop playing this sound
|}

See also: <c>[[file.loadSound]]</c>; <c>[[noteFreq]]</c>

[[Category:Mini Micro]]
[[Category:Soda]]

Bibliography

2025-04-10T03:23:45Z

JoeStrout: /* Blog Posts */

This page lists published articles that include some nontrivial mention of MiniScript or Mini Micro.

== Primary Sources ==

Primary sources are those written by people directly involved. Currently, that mostly means things written by [[User:JoeStrout|Joe Strout]].

=== Books ===

* Strout, J (2020). ''Learn to Code in 30 Days: with MiniScript and Mini Micro''. MiniScript Press. ISBN 978-1-7361676-0-1. (Also available as ebook: ISBN 978-1-7361676-2-5.)

* Strout, J (2021). ''Introduction to Computer Programming: for kids of all ages''. MiniScript Press. ISBN 978-1-7361676-1-8.

=== Articles & Conference Proceedings ===

* Strout, J. "[https://ieeexplore.ieee.org/document/9625108 MiniScript: A new language for computer programming education.]" [http://istem-ed.com/istem-ed2021/ iSTEM-Ed] (2021). (preprint [https://miniscript.org/files/Strout_iSTEM-Ed2021.pdf PDF])

* Strout, J. "[https://kidscodecs.com/mini-micro-coding-introduction/ Introducing Mini Micro]" [https://beanzmag.com/ Beanz Magazine] February 2022, p. 8-9.

* Strout, J. "[https://kidscodecs.com/mini-micro-stars-experiment/ Experimental Coding]" [https://beanzmag.com/ Beanz Magazine] April 2022, p. 24-25.

* Strout, J. "[https://kidscodecs.com/mini-micro-space-game-project/ An Apple a Day...]" [https://beanzmag.com/ Beanz Magazine] June 2022, p. 13.

* Strout, J. "[https://kidscodecs.com/mini-micro-clock-timer/ Make a Clock Timer]" [https://beanzmag.com/ Beanz Magazine] August 2022, p. 13.

* Strout, J. "[https://kidscodecs.com/mini-micro-secret-message-rot13/ Loopy Secret Messages] [https://beanzmag.com/ Beanz Magazine] October 2022, p. 12-13.

* Strout, J. "[https://kidscodecs.com/farmtronics/ Auto-Code in Stardew Valley]" [https://beanzmag.com/ Beanz Magazine] December 2022, p. 4-5.

* Strout, J. "[https://kidscodecs.com/farmtronics-gardening-howto/ A Bot “Outstanding in its Field”]" [https://beanzmag.com/ Beanz Magazine] February 2023

* Strout, J. "[https://kidscodecs.com/farmtronics-finding-your-way/ Finding Your Way]" [https://beanzmag.com/ Beanz Magazine] April 2023

* Strout, J. "[https://kidscodecs.com/minimicro-project-find-objects/ Explore Mars like a Rover]" [https://beanzmag.com/ Beanz Magazine] June 2023

=== Blog Posts ===

* Strout, Joe. "Why MiniScript?" Luminary Apps, 06 Sep. 2019, https://luminaryapps.com/blog/miniscript-why/. Accessed 5 Dec. 2021.

* Strout, Joe. "VT100 Escape Codes in Command-Line MiniScript" Luminary Apps, 03 Oct. 2021, https://luminaryapps.com/blog/vt100-codes/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "Debugging with a Validate Method" Luminary Apps, 01 Nov. 2021, https://luminaryapps.com/blog/validate/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "String Fill and Match" Luminary Apps, 10 Jun. 2022, https://luminaryapps.com/blog/ms-fill-match/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "Advanced Tricks with Import" Luminary Apps, 16 Jun. 2022, https://luminaryapps.com/blog/advanced-import/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "Use GPT-3 in Mini Micro" Dev.to, 21 Dec. 2022, https://dev.to/joestrout/use-gpt-3-in-mini-micro-1h63. Accessed 12 May 2024

* Strout, Joe. "Advent of Code 2022 Wrap-Up" Dev.to, 13 Jan. 2023, https://dev.to/joestrout/advent-of-code-2022-wrap-up-2402. Accessed 12 May 2024

* Strout, Joe. "Image Artsification in Mini Micro" Dev.to, 15 Jan. 2023, https://dev.to/joestrout/image-artsification-in-mini-micro-3fh0. Accessed 12 May 2024

* Strout, Joe. "Make a `rerun` command for Mini Micro" Dev.to, 21 Jan. 2023, https://dev.to/joestrout/make-a-rerun-command-for-mini-micro-30h1. Accessed 12 May 2024

* Strout, Joe. "MiniScript 1.6 Now Available" Dev.to, 6 Feb. 2023, https://dev.to/joestrout/miniscript-16-now-available-fc7. Accessed 12 May 2024

* Strout, Joe. "What's New in Command-Line MiniScript v1.2" Dev.to, 9 Feb. 2023, https://dev.to/joestrout/whats-new-in-command-line-miniscript-v12-4ce9. Accessed 12 May 2024

* Strout, Joe. "MiniScript v1.6.1" Dev.to, 1 Jul. 2023, https://dev.to/joestrout/miniscript-v161-jka. Accessed 12 May 2024

* Strout, Joe. "Customizing the Mini Micro code editor" Dev.to, 5 Jul. 2023, https://dev.to/joestrout/customizing-the-mini-micro-code-editor-6ji. Accessed 12 May 2024

* Strout, Joe. "Converting 100 Classic BASIC Games to MiniScript" Dev.to, 25 Aug. 2023, https://dev.to/joestrout/converting-100-classic-basic-games-to-miniscript-4p3g. Accessed 12 May 2024

* Strout, Joe. "100 BASIC Computer Games, Ported to MiniScript" Dev.to, 24 Oct. 2023, https://dev.to/joestrout/100-basic-computer-games-ported-to-miniscript-3oj3. Accessed 12 May 2024

* Strout, Joe. ""MiniScript Mentor" GPT" Dev.to, 13 Nov. 2023, https://dev.to/joestrout/miniscript-mentor-gpt-9ig. Accessed 12 May 2024

* Strout, Joe. "Join the MiniScript "Advent of Code" contest!" Dev.to, 29 Nov. 2023, https://dev.to/joestrout/join-the-miniscript-advent-of-code-contest-3gm5. Accessed 12 May 2024

* Strout, Joe. "Using textures from /sys/pics/textures" Dev.to, 24 Jan. 2024, https://dev.to/joestrout/using-textures-from-syspicstextures-478m. Accessed 12 May 2024

* Strout, Joe. "Demo Highlight: Asteroids" Dev.to, 31 Jan. 2024, https://dev.to/joestrout/demo-highlight-asteroids-250d. Accessed 12 May 2024

* Strout, Joe. "MiniScript Ports" Dev.to, 7 Feb. 2024, https://dev.to/joestrout/miniscript-ports-jp9. Accessed 12 May 2024

* Strout, Joe. "Announcing Command-Line MiniScript 1.3 (with `exec`!)" Dev.to, 19 Feb. 2024, https://dev.to/joestrout/announcing-command-line-miniscript-13-with-exec-477b. Accessed 12 May 2024

* Strout, Joe. "MiniScript on a bare-metal Raspberry Pi" Dev.to, 2 Mar. 2024, https://dev.to/joestrout/miniscript-on-a-bare-metal-raspberry-pi-59p6. Accessed 12 May 2024

* Strout, Joe. "Off-screen displays in Mini Micro" Dev.to, 6 Mar. 2024, https://dev.to/joestrout/off-screen-displays-in-mini-micro-41mb. Accessed 12 May 2024

* Strout, Joe. "Announcing Mini Micro 1.2.1" Dev.to, 3 Apr. 2024, https://dev.to/joestrout/announcing-mini-micro-121-5e3n. Accessed 12 May 2024

* Strout, Joe. "MiniScript and Micro Jam Join Forces for Mega Fun" Dev.to, 10 Apr. 2024, https://dev.to/joestrout/miniscript-and-micro-jam-join-forces-for-mega-fun-2b9c. Accessed 12 May 2024

* Strout, Joe. "Text entry tricks in Mini Micro" Dev.to, 17 Apr. 2024, https://dev.to/joestrout/text-entry-tricks-in-mini-micro-1p65. Accessed 12 May 2024

* Strout, Joe. "The making of Kip and the Caves of Lava" Dev.to, 8 May 2024, https://dev.to/joestrout/the-making-of-kip-and-the-caves-of-lava-mk3. Accessed 12 May 2024

* Strout, Joe. "Demo highlight: cardFlip" Dev.to, 19 May 2024, https://dev.to/joestrout/demo-highlight-cardflip-26o1. Accessed 19 May 2024

* Strout, Joe. "Version Checking in MiniScript" Dev.to, 20 Jun 2024, https://dev.to/joestrout/version-checking-in-miniscript-gob. Accessed 20 Jun 2024

* Strout, Joe. "Make a digital clock in Mini Micro" Dev.to, 03 Jul 2024, https://dev.to/joestrout/make-a-digital-clock-in-mini-micro-3mpl. Accessed 03 Jul 2024

== Tutorials ==

* "Learn X in Y Minutes: MiniScript": https://learnxinyminutes.com/docs/miniscript/. Access 20 Jun 2024

== Secondary Sources ==

Secondary sources are those written by people not directly involved in the work.

=== Magazine/Journal Articles ===

* Slavin, Tom. "Make a Mini Micro Collection Game." ''Beanz'' Vol. 11, No. 3, Dec 2023. Also available online at https://kidscodecs.com/mini-micro-space-game/ (accessed 12 Dec 2023).

=== Blog Posts ===

* Nozzi, Sebastian. “Neo-Retro Computing.” Dev.to, 20 Nov. 2021, https://dev.to/sebnozzi/about-mini-micro-short-1g0e. Accessed 5 Dec. 2021.

* TopaAzul062. "Review of Learn to Code in 30 Days." OnlineBookClub.org, 21 Oct. 2021, https://forums.onlinebookclub.org/viewtopic.php?f=24&t=205860. Accessed 5 Dec. 2021.

* Khorne. "Where to begin, where to start?" Khornes MiniScript Journey, 2 Mar. 2022, https://khornemsjourney.blogspot.com/2023/07/where-to-begin-where-to-start.html. Accessed 2 Aug. 2023. (Originally located [https://khornems.blogspot.com/2022/03/where-to-begin-where-to-start.html here].)

* Nozzi, Sebastian. "Counting 5-letter words" Dev.to, 25 Oct.2022, https://dev.to/sebnozzi/counting-5-letter-words-2cdo. Accessed 12 May 2024

* Nozzi, Sebastian. "Most common word length" Dev.to, 26 Oct. 2022, https://dev.to/sebnozzi/most-common-word-length-e7e. Accessed 12 May 2024

* Nozzi, Sebastian. "Counting word lengths (map approach)" Dev.to, 26 Oct. 2022, https://dev.to/sebnozzi/counting-word-lengths-map-approach-43p1. Accessed 12 May 2024

* Kratt, Max. "Launch in Mini Micro". Max Kratt's blog, 19 Jan. 2023, https://maxkratt.hashnode.dev/launch-in-mini-micro

* Tomes, Trey. “Fluent Interfaces.” Micro-Hack wiki, 30 Mar. 2023, https://github.com/treytomes/micro-hack/wiki/Fluent-Interfaces

* Quinn. "Unleashing Creativity with Mini Micro: Code Games and More with MiniScript" Dev.to, 4 Aug. 2023, https://dev.to/midsubspace/unleashing-creativity-with-mini-micro-code-games-and-more-with-miniscript-2djm. Accessed 12 May 2024

* Quinn. "Getting Started with Farmtronics" Quinn's Blog, 12 Aug. 2023, https://midsubspace.hashnode.dev/getting-started-with-farmtronics

* Lefebvre, Paul. "Mini Micro and MiniScript: A Great Retro Programming Combination." Goto 10 RetroComputing, 22 Sep. 2023, https://www.goto10retro.com/p/mini-micro-and-miniscript-a-great. Accessed 22 Sep. 2023.

* Hansen, Russell. "MiniScript Roundup #1" Dev.to, 8 Oct. 2023, https://dev.to/synapticbytes/miniscript-roundup-1-a7n. Accessed 12 May 2024

* Hansen, Russell. "Designing the MiniScript to Godot Framework" Dev.to, 9 Oct. 2023, https://dev.to/synapticbytes/designing-the-miniscript-to-godot-framework-3jm1. Accessed 12 May 2024

* Hansen, Russell. "MiniScript in Godot Progress Report #1" Dev.to, 13 Oct. 2023, https://dev.to/synapticbytes/minscript-in-godot-progress-report-1-5bg1. Accessed 12 May 2024

* Nozzi, Sebastian. "Coin Collector Game" Dev.to, 4 May 2024, https://dev.to/sebnozzi/coin-collector-1lh6. Accessed 12 May 2024

* Selfish Dev. "Why Miniscript" Dev.to, 27 Feb. 2025, https://dev.to/selfish_dev/why-miniscript-13fi. Accessed 9 Apr. 2025.

* Selfish Dev. "How to render a sprite in Mini Micro" Dev.to, 4 Mar. 2025, https://dev.to/selfish_dev/how-to-render-a-sprite-in-mini-micro-h03. Accessed 9 Apr. 2025.

* Selfish Dev. "How to register sprite clicks in mini micro" Dev.to, 8 Mar. 2025, https://dev.to/selfish_dev/how-to-register-sprite-clicks-in-mini-micro-2j42. Accessed 9 Apr. 2025.

* Selfish Dev. "Bounds In Mini Micro" Dev.to, 7 Mar. 2025, https://dev.to/selfish_dev/bounds-in-mini-micro-3pl1. Accessed 9 Apr. 2025.

* Selfish Dev. "WTF Mini Micro!" Dev.to, 13 Mar. 2025, https://dev.to/selfish_dev/wtf-mini-micro-6j5. Accessed 9 Apr. 2025.

* Selfish Dev. "Mini-Micro : Physics , Fixes and WTF" Dev.to, 15 Mar. 2025, https://dev.to/selfish_dev/mini-micro-physics-fixes-and-wtf-3gc4. Accessed 9 Apr. 2025.

* Selfish Dev. "How to load a sprite from web" Dev.to, 28 Mar. 2025, https://dev.to/selfish_dev/how-to-load-a-sprite-from-web-1kcp. Accessed 9 Apr. 2025.

* BibleClinger. "Mini Micro and the 6502: Adding retro to the neo-retro" Dev.to, 12 Mar. 2025, https://dev.to/bibleclinger/mini-micro-and-the-6502-adding-retro-to-the-neo-retro-3mgh. Accessed 9 Apr. 2025.

* BibleClinger. "Mini Micro and the 6502: Adding Keyboard Input" Dev.to, 16 Mar. 2025, https://dev.to/bibleclinger/mini-micro-and-the-6502-adding-keyboard-input-1cjm. Accessed 9 Apr. 2025.

* BibleClinger. "Does MiniScript Need Variadic Functions?" Dev.to, 13 Mar. 2025, https://dev.to/bibleclinger/does-miniscript-need-variadic-functions-53a0. Accessed 9 Apr. 2025.

* BibleClinger. "MiniScript's Parent-Class Variable Pitfall" Dev.to, 14 Mar. 2025, https://dev.to/bibleclinger/miniscripts-parent-class-variable-pitfall-4koi. Accessed 9 Apr. 2025.

* BibleClinger. "MiniScript's locals, outer, and globals" Dev.to, 6 Apr. 2025, https://dev.to/bibleclinger/miniscripts-locals-outer-and-globals-1pcn. Accessed 9 Apr. 2025.

* Kinggd. "How I Made Drag-and-Drop Physics in Mini Micro" https://medium.com/@kinggd2424, 9 Apr. 2025,

=== Pro Journalism ===

* Stanton, Rich. "Stardew Valley mod adds farming bots." PC Gamer, 01 Jan. 2022, https://www.pcgamer.com/stardew-valley-mod-adds-farming-bots/

[[Category:Community]]

Bibliography

2025-04-10T03:23:05Z

JoeStrout: /* Blog Posts */

This page lists published articles that include some nontrivial mention of MiniScript or Mini Micro.

== Primary Sources ==

Primary sources are those written by people directly involved. Currently, that mostly means things written by [[User:JoeStrout|Joe Strout]].

=== Books ===

* Strout, J (2020). ''Learn to Code in 30 Days: with MiniScript and Mini Micro''. MiniScript Press. ISBN 978-1-7361676-0-1. (Also available as ebook: ISBN 978-1-7361676-2-5.)

* Strout, J (2021). ''Introduction to Computer Programming: for kids of all ages''. MiniScript Press. ISBN 978-1-7361676-1-8.

=== Articles & Conference Proceedings ===

* Strout, J. "[https://ieeexplore.ieee.org/document/9625108 MiniScript: A new language for computer programming education.]" [http://istem-ed.com/istem-ed2021/ iSTEM-Ed] (2021). (preprint [https://miniscript.org/files/Strout_iSTEM-Ed2021.pdf PDF])

* Strout, J. "[https://kidscodecs.com/mini-micro-coding-introduction/ Introducing Mini Micro]" [https://beanzmag.com/ Beanz Magazine] February 2022, p. 8-9.

* Strout, J. "[https://kidscodecs.com/mini-micro-stars-experiment/ Experimental Coding]" [https://beanzmag.com/ Beanz Magazine] April 2022, p. 24-25.

* Strout, J. "[https://kidscodecs.com/mini-micro-space-game-project/ An Apple a Day...]" [https://beanzmag.com/ Beanz Magazine] June 2022, p. 13.

* Strout, J. "[https://kidscodecs.com/mini-micro-clock-timer/ Make a Clock Timer]" [https://beanzmag.com/ Beanz Magazine] August 2022, p. 13.

* Strout, J. "[https://kidscodecs.com/mini-micro-secret-message-rot13/ Loopy Secret Messages] [https://beanzmag.com/ Beanz Magazine] October 2022, p. 12-13.

* Strout, J. "[https://kidscodecs.com/farmtronics/ Auto-Code in Stardew Valley]" [https://beanzmag.com/ Beanz Magazine] December 2022, p. 4-5.

* Strout, J. "[https://kidscodecs.com/farmtronics-gardening-howto/ A Bot “Outstanding in its Field”]" [https://beanzmag.com/ Beanz Magazine] February 2023

* Strout, J. "[https://kidscodecs.com/farmtronics-finding-your-way/ Finding Your Way]" [https://beanzmag.com/ Beanz Magazine] April 2023

* Strout, J. "[https://kidscodecs.com/minimicro-project-find-objects/ Explore Mars like a Rover]" [https://beanzmag.com/ Beanz Magazine] June 2023

=== Blog Posts ===

* Strout, Joe. "Why MiniScript?" Luminary Apps, 06 Sep. 2019, https://luminaryapps.com/blog/miniscript-why/. Accessed 5 Dec. 2021.

* Strout, Joe. "VT100 Escape Codes in Command-Line MiniScript" Luminary Apps, 03 Oct. 2021, https://luminaryapps.com/blog/vt100-codes/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "Debugging with a Validate Method" Luminary Apps, 01 Nov. 2021, https://luminaryapps.com/blog/validate/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "String Fill and Match" Luminary Apps, 10 Jun. 2022, https://luminaryapps.com/blog/ms-fill-match/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "Advanced Tricks with Import" Luminary Apps, 16 Jun. 2022, https://luminaryapps.com/blog/advanced-import/index.html. Accessed 13 Jul. 2022.

* Strout, Joe. "Use GPT-3 in Mini Micro" Dev.to, 21 Dec. 2022, https://dev.to/joestrout/use-gpt-3-in-mini-micro-1h63. Accessed 12 May 2024

* Strout, Joe. "Advent of Code 2022 Wrap-Up" Dev.to, 13 Jan. 2023, https://dev.to/joestrout/advent-of-code-2022-wrap-up-2402. Accessed 12 May 2024

* Strout, Joe. "Image Artsification in Mini Micro" Dev.to, 15 Jan. 2023, https://dev.to/joestrout/image-artsification-in-mini-micro-3fh0. Accessed 12 May 2024

* Strout, Joe. "Make a `rerun` command for Mini Micro" Dev.to, 21 Jan. 2023, https://dev.to/joestrout/make-a-rerun-command-for-mini-micro-30h1. Accessed 12 May 2024

* Strout, Joe. "MiniScript 1.6 Now Available" Dev.to, 6 Feb. 2023, https://dev.to/joestrout/miniscript-16-now-available-fc7. Accessed 12 May 2024

* Strout, Joe. "What's New in Command-Line MiniScript v1.2" Dev.to, 9 Feb. 2023, https://dev.to/joestrout/whats-new-in-command-line-miniscript-v12-4ce9. Accessed 12 May 2024

* Strout, Joe. "MiniScript v1.6.1" Dev.to, 1 Jul. 2023, https://dev.to/joestrout/miniscript-v161-jka. Accessed 12 May 2024

* Strout, Joe. "Customizing the Mini Micro code editor" Dev.to, 5 Jul. 2023, https://dev.to/joestrout/customizing-the-mini-micro-code-editor-6ji. Accessed 12 May 2024

* Strout, Joe. "Converting 100 Classic BASIC Games to MiniScript" Dev.to, 25 Aug. 2023, https://dev.to/joestrout/converting-100-classic-basic-games-to-miniscript-4p3g. Accessed 12 May 2024

* Strout, Joe. "100 BASIC Computer Games, Ported to MiniScript" Dev.to, 24 Oct. 2023, https://dev.to/joestrout/100-basic-computer-games-ported-to-miniscript-3oj3. Accessed 12 May 2024

* Strout, Joe. ""MiniScript Mentor" GPT" Dev.to, 13 Nov. 2023, https://dev.to/joestrout/miniscript-mentor-gpt-9ig. Accessed 12 May 2024

* Strout, Joe. "Join the MiniScript "Advent of Code" contest!" Dev.to, 29 Nov. 2023, https://dev.to/joestrout/join-the-miniscript-advent-of-code-contest-3gm5. Accessed 12 May 2024

* Strout, Joe. "Using textures from /sys/pics/textures" Dev.to, 24 Jan. 2024, https://dev.to/joestrout/using-textures-from-syspicstextures-478m. Accessed 12 May 2024

* Strout, Joe. "Demo Highlight: Asteroids" Dev.to, 31 Jan. 2024, https://dev.to/joestrout/demo-highlight-asteroids-250d. Accessed 12 May 2024

* Strout, Joe. "MiniScript Ports" Dev.to, 7 Feb. 2024, https://dev.to/joestrout/miniscript-ports-jp9. Accessed 12 May 2024

* Strout, Joe. "Announcing Command-Line MiniScript 1.3 (with `exec`!)" Dev.to, 19 Feb. 2024, https://dev.to/joestrout/announcing-command-line-miniscript-13-with-exec-477b. Accessed 12 May 2024

* Strout, Joe. "MiniScript on a bare-metal Raspberry Pi" Dev.to, 2 Mar. 2024, https://dev.to/joestrout/miniscript-on-a-bare-metal-raspberry-pi-59p6. Accessed 12 May 2024

* Strout, Joe. "Off-screen displays in Mini Micro" Dev.to, 6 Mar. 2024, https://dev.to/joestrout/off-screen-displays-in-mini-micro-41mb. Accessed 12 May 2024

* Strout, Joe. "Announcing Mini Micro 1.2.1" Dev.to, 3 Apr. 2024, https://dev.to/joestrout/announcing-mini-micro-121-5e3n. Accessed 12 May 2024

* Strout, Joe. "MiniScript and Micro Jam Join Forces for Mega Fun" Dev.to, 10 Apr. 2024, https://dev.to/joestrout/miniscript-and-micro-jam-join-forces-for-mega-fun-2b9c. Accessed 12 May 2024

* Strout, Joe. "Text entry tricks in Mini Micro" Dev.to, 17 Apr. 2024, https://dev.to/joestrout/text-entry-tricks-in-mini-micro-1p65. Accessed 12 May 2024

* Strout, Joe. "The making of Kip and the Caves of Lava" Dev.to, 8 May 2024, https://dev.to/joestrout/the-making-of-kip-and-the-caves-of-lava-mk3. Accessed 12 May 2024

* Strout, Joe. "Demo highlight: cardFlip" Dev.to, 19 May 2024, https://dev.to/joestrout/demo-highlight-cardflip-26o1. Accessed 19 May 2024

* Strout, Joe. "Version Checking in MiniScript" Dev.to, 20 Jun 2024, https://dev.to/joestrout/version-checking-in-miniscript-gob. Accessed 20 Jun 2024

* Strout, Joe. "Make a digital clock in Mini Micro" Dev.to, 03 Jul 2024, https://dev.to/joestrout/make-a-digital-clock-in-mini-micro-3mpl. Accessed 03 Jul 2024

== Tutorials ==

* "Learn X in Y Minutes: MiniScript": https://learnxinyminutes.com/docs/miniscript/. Access 20 Jun 2024

== Secondary Sources ==

Secondary sources are those written by people not directly involved in the work.

=== Magazine/Journal Articles ===

* Slavin, Tom. "Make a Mini Micro Collection Game." ''Beanz'' Vol. 11, No. 3, Dec 2023. Also available online at https://kidscodecs.com/mini-micro-space-game/ (accessed 12 Dec 2023).

=== Blog Posts ===

* Nozzi, Sebastian. “Neo-Retro Computing.” Dev.to, 20 Nov. 2021, https://dev.to/sebnozzi/about-mini-micro-short-1g0e. Accessed 5 Dec. 2021.

* TopaAzul062. "Review of Learn to Code in 30 Days." OnlineBookClub.org, 21 Oct. 2021, https://forums.onlinebookclub.org/viewtopic.php?f=24&t=205860. Accessed 5 Dec. 2021.

* Khorne. "Where to begin, where to start?" Khornes MiniScript Journey, 2 Mar. 2022, https://khornemsjourney.blogspot.com/2023/07/where-to-begin-where-to-start.html. Accessed 2 Aug. 2023. (Originally located [https://khornems.blogspot.com/2022/03/where-to-begin-where-to-start.html here].)

* Sebastian Nozzi "Counting 5-letter words" Dev.to, 25 Oct.2022, https://dev.to/sebnozzi/counting-5-letter-words-2cdo. Accessed 12 May 2024

* Sebastian Nozzi "Most common word length" Dev.to, 26 Oct. 2022, https://dev.to/sebnozzi/most-common-word-length-e7e. Accessed 12 May 2024

* Sebastian Nozzi "Counting word lengths (map approach)" Dev.to, 26 Oct. 2022, https://dev.to/sebnozzi/counting-word-lengths-map-approach-43p1. Accessed 12 May 2024

* Kratt, Max. "Launch in Mini Micro". Max Kratt's blog, 19 Jan. 2023, https://maxkratt.hashnode.dev/launch-in-mini-micro

* Tomes, Trey. “Fluent Interfaces.” Micro-Hack wiki, 30 Mar. 2023, https://github.com/treytomes/micro-hack/wiki/Fluent-Interfaces

* Quinn. "Unleashing Creativity with Mini Micro: Code Games and More with MiniScript" Dev.to, 4 Aug. 2023, https://dev.to/midsubspace/unleashing-creativity-with-mini-micro-code-games-and-more-with-miniscript-2djm. Accessed 12 May 2024

* Quinn. "Getting Started with Farmtronics" Quinn's Blog, 12 Aug. 2023, https://midsubspace.hashnode.dev/getting-started-with-farmtronics

* Lefebvre, Paul. "Mini Micro and MiniScript: A Great Retro Programming Combination." Goto 10 RetroComputing, 22 Sep. 2023, https://www.goto10retro.com/p/mini-micro-and-miniscript-a-great. Accessed 22 Sep. 2023.

* Hansen, Russell. "MiniScript Roundup #1" Dev.to, 8 Oct. 2023, https://dev.to/synapticbytes/miniscript-roundup-1-a7n. Accessed 12 May 2024

* Hansen, Russell. "Designing the MiniScript to Godot Framework" Dev.to, 9 Oct. 2023, https://dev.to/synapticbytes/designing-the-miniscript-to-godot-framework-3jm1. Accessed 12 May 2024

* Hansen, Russell. "MiniScript in Godot Progress Report #1" Dev.to, 13 Oct. 2023, https://dev.to/synapticbytes/minscript-in-godot-progress-report-1-5bg1. Accessed 12 May 2024

* Nozzi, Sebastian. "Coin Collector Game" Dev.to, 4 May 2024, https://dev.to/sebnozzi/coin-collector-1lh6. Accessed 12 May 2024

* Selfish Dev. "Why Miniscript" Dev.to, 27 Feb. 2025, https://dev.to/selfish_dev/why-miniscript-13fi. Accessed 9 Apr. 2025.

* Selfish Dev. "How to render a sprite in Mini Micro" Dev.to, 4 Mar. 2025, https://dev.to/selfish_dev/how-to-render-a-sprite-in-mini-micro-h03. Accessed 9 Apr. 2025.

* Selfish Dev. "How to register sprite clicks in mini micro" Dev.to, 8 Mar. 2025, https://dev.to/selfish_dev/how-to-register-sprite-clicks-in-mini-micro-2j42. Accessed 9 Apr. 2025.

* Selfish Dev. "Bounds In Mini Micro" Dev.to, 7 Mar. 2025, https://dev.to/selfish_dev/bounds-in-mini-micro-3pl1. Accessed 9 Apr. 2025.

* Selfish Dev. "WTF Mini Micro!" Dev.to, 13 Mar. 2025, https://dev.to/selfish_dev/wtf-mini-micro-6j5. Accessed 9 Apr. 2025.

* Selfish Dev. "Mini-Micro : Physics , Fixes and WTF" Dev.to, 15 Mar. 2025, https://dev.to/selfish_dev/mini-micro-physics-fixes-and-wtf-3gc4. Accessed 9 Apr. 2025.

* Selfish Dev. "How to load a sprite from web" Dev.to, 28 Mar. 2025, https://dev.to/selfish_dev/how-to-load-a-sprite-from-web-1kcp. Accessed 9 Apr. 2025.

* BibleClinger. "Mini Micro and the 6502: Adding retro to the neo-retro" Dev.to, 12 Mar. 2025, https://dev.to/bibleclinger/mini-micro-and-the-6502-adding-retro-to-the-neo-retro-3mgh. Accessed 9 Apr. 2025.

* BibleClinger. "Mini Micro and the 6502: Adding Keyboard Input" Dev.to, 16 Mar. 2025, https://dev.to/bibleclinger/mini-micro-and-the-6502-adding-keyboard-input-1cjm. Accessed 9 Apr. 2025.

* BibleClinger. "Does MiniScript Need Variadic Functions?" Dev.to, 13 Mar. 2025, https://dev.to/bibleclinger/does-miniscript-need-variadic-functions-53a0. Accessed 9 Apr. 2025.

* BibleClinger. "MiniScript's Parent-Class Variable Pitfall" Dev.to, 14 Mar. 2025, https://dev.to/bibleclinger/miniscripts-parent-class-variable-pitfall-4koi. Accessed 9 Apr. 2025.

* BibleClinger. "MiniScript's locals, outer, and globals" Dev.to, 6 Apr. 2025, https://dev.to/bibleclinger/miniscripts-locals-outer-and-globals-1pcn. Accessed 9 Apr. 2025.

* Kinggd. "How I Made Drag-and-Drop Physics in Mini Micro" https://medium.com/@kinggd2424, 9 Apr. 2025,

=== Pro Journalism ===

* Stanton, Rich. "Stardew Valley mod adds farming bots." PC Gamer, 01 Jan. 2022, https://www.pcgamer.com/stardew-valley-mod-adds-farming-bots/

[[Category:Community]]

Color.lerp

2025-03-29T13:58:01Z

JoeStrout:

<c>color.lerp</c> is a method that implements linear interpolation between two colors. It is commonly used for changing colors over time or painting gradients.

(The term "lerp" is short for "linear interpolate".)

== Parameters ==

The method has this signature: <c>color.lerp c1, c2, t</c>

{| class="wikitable"
|-
! Parameter !! Description
|-
| c1|| First color in hexcolor format
|-
| c2|| Second color in hexcolor format
|-
| t|| Variable for how far to interpolate between the two colors (t <= 0 retunrs c1, t >= 0 returns c2, 0 < t < 1 returns color inbetween)
|}

== Example ==

<ms>
color.lerp color.red, color.blue, 0
#FF0000FF
color.lerp color.red, color.blue, 1
#0000FFFF
color.lerp color.red, color.blue, 0.5
#7F007FFF
color.lerp color.red, color.blue, 0.25
#BF003FFF
</ms>

See also: [[Color]], [[MathUtil]]

[[Category:Mini Micro]]

Env

2025-03-24T21:15:11Z

JoeStrout:

<c>env</c> is a built-in map in [[Mini Micro]], [[Farmtronics]], and [[command-line MiniScript]]. It has somewhat different meaning and usage in each environment.

== Mini Micro ==

In [[Mini Micro]], <c>env</c> refers to a map of special values that affect the Mini Micro environment. It contains at least the following keys:

{| class="wikitable"
|-
! Key !! Meaning
|-
| bootOpts || a complete copy of the data in the [[bootOpts.grfon]] file
|-
| curdir || current working directory (same as [[pwd]])
|-
| cmdLine || command line command that was used to launch Mini Micro (where applicable)
|-
| cmdLineArgs || command line arguments (as a [[list]]) used when Mini Micro was launched (where applicable)
|-
| importPaths || [[list]] of directories searched for [[import]] modules
|-
| prompt || [[string]] or [[function]] to use as the command-line prompt
|-
| morePrompt || [[string]] or [[function]] to use as the prompt when more input is needed
|-
| shell || path to the current [[Env.shell|shell]] program (<c>""</c> for the default Mini Micro shell)
|}

== Command-Line MiniScript ==

In [[command-line MiniScript]], <c>env</c> is a copy of the shell environment variables. Assignments to entries of <c>env</c> add or update environment variables. (Deleting environment variables is not possible; you may delete from the <c>env</c> map, but this does not actually affect the environment.)

The exact meaning of environment variables varies with the platform. They have many uses, such as in [http://www.cgi101.com/book/ch3/text.html CGI scripts].

=== Windows Version ===
{| class="wikitable"
|-
! Key !! Default !! Meaning
|-
| MS_EXE_DIR || Launch directory ||Returns the directory ([[String]]) of which the miniscript.exe was launched from
|-
| MS_IMPORT_PATH || "$MS_SCRIPT_DIR/lib:$MS_EXE_DIR/lib" ||directory listings ([[String]]) of where MiniScript files are located allowing [[Import]] to search in those for file import.
|-
| HOMEPATH || User home || Returns the home Directory ([[String]]) of the user that had launched miniscript.exe
|}

=== Linux Version===
{| class="wikitable"
|-
! Key !! Default !! Meaning
|}

== Useful tips ==

=== Adding more import paths (Windows Command Line) ===
To add more folders to [[Import]] from, alter or add the path with a dollar sign ('''$''') to the beginning of $MS_SCRIPT_DIR or $MS_EXE_DIR [[String]] text with a forward slash ('''/''') before the folder name like so: '''$MS_SCRIPT_DIR/sprites'''. To add multiple paths for import simply add a colon (''':''') between the designated paths to indicate multiple directories to import from. Apply the string to the [[Env|env]].MS_IMPORT_PATH like below:

<ms> env.MS_IMPORT_PATH = "$MS_SCRIPT_DIR/sprites" // replaces the default with one folder named sprites
env.MS_IMPORT_PATH = "$MS_SCRIPT_DIR/lib:$MS_EXE_DIR/lib:$MS_SCRIPT_DIR/sprites" // default plus new folder sprites</ms>

[[Category:Mini Micro]]
[[Category:Command-Line MiniScript]]
[[Category:Farmtronics]]

Image Disks

2025-03-08T17:53:26Z

JoeStrout: Created page with "Mini Micro, since version 1.2.4, allows you to mount specially formatted PNG image files that contain an embedded minidisk, hidden inside the image via [https://en.wikiped..."

[[Mini Micro]], since version 1.2.4, allows you to mount specially formatted PNG image files that contain an embedded minidisk, hidden inside the image via [https://en.wikipedia.org/wiki/Steganography steganography].

(More details coming soon!)

{{stub}}

How to package a Mini Micro game

2025-03-07T15:26:21Z

JoeStrout: /* Packaging for MacOS Download */

To "package" a [[Mini Micro]] game means to bundle up all the files into a format that end-users can download (or access on the web) and play without needing anything else.

The basic idea is simple: Mini Micro will automatically look for a zip file (or folder) next to the executable called '''user.minidisk''', and if it finds this, it would automatically mount that as '''/usr''' and run any program it finds there as '''/usr/startup.ms'''. So packaging amounts to taking a standard Mini Micro distribution, adding the desired '''user.minidisk''' file, and tweaking things like the app name and icon. Exact details, though, vary with the platform you're targeting.

Note that while the directions below include links to zip instructions/tools on the corresponding platform, it is ''not'' necessary to be on the platform you are packaging for. In other words, it should work perfectly well to package for all platforms, from whatever platform you happen to use. Also note that the first three steps in each section below are the same, and only need to be done once no matter how many platforms you package for.

== Packaging for Windows Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.laptopmag.com/articles/how-to-zip-files-windows-10 zip it]. Rename the zip file exactly '''user.minidisk'''.
# Download the Windows distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''Mini Micro.exe''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''Mini Micro_Data/StreamingAssets''' subfolder.
# If you like, rename '''Mini Micro.exe''' to the name of your game. Note: Do not forget to change the folder '''Mini Micro_data''' to the name change with the exe with '''_data'''. example: '''strat.exe''', data folder would be '''strat_data'''.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the .exe, your '''user.minidisk''' file, and everything else that came with the original Windows distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for MacOS Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.lifewire.com/how-to-zip-and-unzip-files-and-folders-on-a-mac-2260188 zip it]. Rename the zip file exactly '''user.minidisk'''.
# Download the MacOS distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.app''' file. (If you are doing this in Windows or Linux, '''MiniMicro.app''' will appear as a folder; on a Mac, the same folder appears as an app, and the .app extension may be hidden.)
# If desired, make a '''[[bootOpts.grfon]]''' file, and place that inside the application bundle under '''Contents/Resources/Data/StreamingAssets'''.
# If you like, rename '''MiniMicro.app''' to the name of your game.
# Zip up (or place on a [https://support.apple.com/guide/disk-utility/create-a-disk-image-dskutl11888/mac disk image]) the whole folder containing the app and your '''user.minidisk''' file.

The resulting zip or DMG can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for Linux Download ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, [https://www.cyberciti.biz/tips/how-can-i-zipping-and-unzipping-files-under-linux.html zip it]. Rename the zip file exactly '''user.minidisk'''.
# Download the Linux distribution of Mini Micro from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file next to the '''MiniMicro.x86_64''' file.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that in the '''MiniMicro_Data/StreamingAssets''' folder.
# If you like, rename '''MiniMicro.x86_64''' to the name of your game.
# Zip up (or otherwise archive, as you prefer) the whole folder containing the executable, your '''user.minidisk''' file, and everything else that came with the original Linux distribution.

The resulting archive file can then be uploaded to DropBox or itch.io, or otherwise distributed to your players.

== Packaging for the Web ==

# Make a virtual disk containing just the files needed for your game or app.
# Add a [[startup.ms]] script that loads and runs your program.
# If your virtual disk is (in the real file system) a folder, zip the contents of that folder. Rename the zip file exactly '''user.minidisk'''.
# Download the WebGL Template from the [https://miniscript.org/MiniMicro/ official web page].
# Put your '''user.minidisk''' file into the '''StreamingAssets''' folder, replacing the (empty) user.minidisk there in the template.
# If desired, make a '''[[bootOpts.grfon]]''' file and place that next to '''user.minidisk'''.
# If uploading to itch.io, zip up the whole folder containing '''Build''', '''index.html''', and '''StreamingAssets'''.
# Upload that archive to itch.io, or upload the folder to your web site. If asked for viewport dimensions, use 1024 by 768 pixels.

[[Category:Mini Micro]]
[[Category:How To]]

How to get started with Mini Micro

2025-03-05T16:39:26Z

JoeStrout: /* 3. About synthesized sounds */

[https://miniscript.org/MiniMicro/ Mini Micro] is a popular environment for creating 2D games and demos in MiniScript. It is a retro-style virtual computer, which runs on most desktop platforms. Mini Micro games can be [[How to package a Mini Micro game|packaged]] as stand-alone games for desktop or the web.

This page is meant for people who have never used Mini Micro before, but want to make a Mini Micro game. It is a step-by-step guide to building your first simple demo involving a sprite, game input, and sound effects, including your own resources, as quickly as possible.

== Get Mini Micro ==

While you can run Mini Micro on the web, the web version has no ability to save files (nor does it support copy/paste). So it's not useful for developing your own Mini Micro games.

Go to the [https://miniscript.org/MiniMicro/#download Mini Micro download] page, click the button for your platform (Mac, Windows, or Linux), and save the resulting file to your local machine. (If you don't have a Mac, Windows, or Linux desktop machine, then unfortunately you can't use Mini Micro yet, though iOS and Android versions are under development.)

The downloaded file will be a .zip (Mac/Windows) or .tar.gz (Linux) file. ''Unpack this file completely.'' Don't try to run Mini Micro from ''within'' the archive; extract all files to a real folder on your hard drive.

Then, find the Mini Micro application in that folder. Double-click it to launch Mini Micro. The result should look like this.

[[File:MiniMicro.png|thumb|center]]

== Mount a folder as /usr ==

Mini Micro can access two virtual "disks" at once; within the Mini Micro environment, these are accessed as <c>/usr</c> and <c>/usr2</c>. Each of these can be either a '''.minidisk file''', or a '''real folder''' on the host (desktop) system. Out of the box, Mini Micro creates an empty .minidisk file for you, to keep things nice and neat. But for any serious development, you're going to want to mount a real folder instead, so that you can easily move files in and out of this folder, use your favorite external image/sound editors, etc.

Create a folder on your desktop system, wherever you normally keep your documents. This will be your project folder for your first Mini Micro game. Put a small text file, image (in PNG or JPEG format), or sound file (in WAV or OGG format) in there. Our goal now is to see and view this file (and any others in that folder or its subfolders) in Mini Micro.

=== Method 1: Use the disk slot menu ===

Those two thin dark rectangles in the bottom-left corner of the Mini Micro window are "disk slots." The top slot represents <c>/usr</c>, and the bottom slot represents <c>/usr2</c>. Click the top slot to pop open the menu, and select the "Mount Folder..." command.

[[File:MountFolder.png|frameless|center]]

Selecting that command should bring up the native file dialog for your platform, allowing you to select any folder you have access to. Pick the project folder you created above. (Note: some Linux platforms have a bug which crashes Mini Micro at this point; if that happens to you, go on to Method 2.)

Now, in the Mini Micro display, at the blinking orange prompt, type:

<ms>dir</ms>

and press Return or Enter. You should see your file listed. Now try:

<ms>view "myfile.txt"</ms>

but replace ''myfile.txt'' with the name of whatever file you placed in your project folder. Be sure to include the quotation marks; you're typing MiniScript code here, not some other shell language, so string literals always need to be surrounded by double quotes. If you do it correctly, the contents of your text file or image should appear on the screen.

(You could also do <c>view findFile</c>, which would pop up the little file browser within the [[findFile]] command, and select your file that way.)

Note that the currently mounted disk is saved in preferences, so if you quit and relaunch Mini Micro, you generally won't need to do this step again; the previously mounted disks will still be there.

=== Method 2: Use command-line arguments ===

If you are unfortunate enough to hit that Linux bug which causes the file dialogs to crash, or for some other reason you want to launch Mini Micro from the command line (or a shell script) with the correct folder already mounted, then you can use [[Command-line arguments|command-line arguments]] instead. Open your favorite terminal program, and navigate to where the Mini Micro executable is located. The details vary by platform, so let's break it down:

'''Linux'''

In Linux, the executable is called '''MiniMicro.x86_64''', so you would type a command like this:

<ms>./MiniMicro.x86_64 -usr ~/mmdev</ms>

Replace <c>~/mmdev</c> with the path to your project folder.

'''Windows'''

In Windows, you can open the command prompt by pressing '''Win + R''' to open the Run dialog, and entering ''cmd''. (If you already have some other preferred terminal app, like PowerShell, that's fine too.) Then <c>cd</c> to the directory containing Mini Micro. The executable here is called '''Mini Micro.exe''', so you would use a command like:

<ms>"Mini Micro.exe" -usr "%HOMEPATH%\mmdev</ms>

Replace <c>%HOMEPATH%\mmdev</c> with the path to your project folder.

'''MacOS'''

On Mac, the actual executable is hidden inside the application bundle, specifically under Contents/MacOS. So if you've already launched Terminal and navigated to where '''MiniMicro.app''' is found, then you would do

<ms>Contents/MacOS/Mini\ Micro -usr ~/Documents/mmdev</ms>

Replace <c>~/Documents/mmdev</c> with the path to your project folder.

If successful (on any platform), you should be able to use the <c>dir</c> and <c>view</c> commands to view the file in your project folder within the Mini Micro environment.

== Create a sprite ==

Now let's get a sprite up on the screen. We're going to do this using the Mini Micro command line (or [[REPL]]), where you type a command and executes immediately. We'll get to writing real programs later, but the command-line is a powerful tool for learning and exploring, so let's use it.

=== 1. Make a sprite from the built-in images ===

At the orange blinking-cursor prompt in Mini Micro, carefully type the following:

<ms>clear
sp = new Sprite
sp.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push sp</ms>

You should see a furry purple Wumpus peeking out from the lower-left corner of the screen (which is the origin of Mini Micro's [[Screen coordinates|coordinate system]]).

[[File:ManualSprite.png|thumb]]

If you don't see this, go back and double-check your typing. Note that you can recall a previous command on the command line by pressing the '''up-arrow''' key, then just edit it and press Return to run the edited command.

How does this work? Let's break it down:

# <c>[[clear]]</c> clears the screen and resets all eight display layers to their default states. This includes setting display 4 to be a [[SpriteDisplay]]. (That's the default state when Mini Micro boots, but useful whenever your screen is cluttered anyway.)
# <c>sp = new Sprite</c> creates a new [[Sprite]] object, and assigns it to a variable called <c>sp</c>.
# <c>sp.image = file.loadImage("/sys/pics/Wumpus.png")</c> loads an image called "Wumpus.png" from the <c>/sys/pics</c> directory. (Notice that Mini Micro uses forward-slashes in file paths, even if the host system is Windows.)
# <c>display(4).sprites.push sp</c> pushes this new sprite onto the sprite list of display 4, so it can be seen.

Once you have the Wumpus peeking out of the corner, let's move it and rotate it a bit. Notice how the sprite updates immediately after each command.

<ms>sp.x = 480
sp.y = 320
sp.rotation = 45</ms>

=== 2. Make a sprite from your own custom image ===

The Wumpus sprite above was created from one of the built-in images that comes with Mini Micro. There are hundreds of these, stored on a hidden, read-only disk mounted as <c>/sys</c>. Feel free to use the <c>findFile</c> command to explore what's there.

But for your own game, you're probably going to want to use your own custom sprites. So, put an image in PNG format into your project directory (the one you mounted as <c>/usr</c>). Use the <c>pwd</c> (print working directory) and <c>cd</c> (change directory) commands to be sure you are in your <c>/usr</c> directory. Then use the <c>dir</c> and <c>view</c> commands to ensure that you can see and load your user file.

Now, just repeat the commands you did to create a sprite above, but substitute the path to your custom image.

<ms>sp = new Sprite
sp.image = file.loadImage("myCustomImage.png")
display(4).sprites.push sp</ms>

If you haven't [[clear]]ed the display since step 1, then you'll see your new sprite ''and'' the Wumpus on screen at the same time. And if you now move (by assigning to <c>.x</c> and <c>.y</c>) your sprites so that they overlap, you'll see that your new sprite is drawn on top of the older one. That's because sprites are drawn in the order in which they appear in the [[SpriteDisplay.sprites|sprites list]] of the [[SpriteDisplay]].

=== 3. Extract an image from a sprite sheet ===

Often you have multiple sprite images arranged in one bigger image file, called a '''sprite sheet''' or '''sprite atlas'''. You can pull apart such a sprite sheet by using the [[Image.getImage]] function. Let's try:

<ms>enemies = file.loadImage("/sys/pics/Enemies.png")
view enemies</ms>

This loads and displays [https://github.com/JoeStrout/minimicro-sysdisk/blob/master/sys/pics/Enemies.png?raw=true this big image], which contains a number of platformer enemies, in a 128x128 pixel grid. Let's make a sprite out of the top-left image. Keep in mind that coordinates in Mini Micro go from the bottom-left corner, so that top image starts at 128 * 3 = 384.

<ms>goob = new Sprite
goob.image = enemies.getImage(0, 384, 128, 128)
display(4).sprites.push goob</ms>

This creates a new sprite called <c>goob</c>, assigns it an image from our <c>enemies</c> sprite sheet, and pushes it onto the display. As always, it starts out in the bottom-left corner, but you know how to adjust that by now. Since this sprite is a bit bigger than it probably needs to be, also try <c>goob.scale = 0.5</c> to shrink it down.

== Play a sound ==

Almost any game needs [[sound]] effects! Mini Micro supports playing both digitized sounds loaded from a file, and sounds synthesized at runtime. We'll focus here on playing sounds from a file, which can be in either WAV or OGG format.

=== 1. Play one of the built-in sounds ===

Enter <c>clear</c> to clear the screen, then try this:

<ms>snd = file.loadSound("/sys/sounds/twinkle.wav")
snd.play</ms>

You should hear a twinkle sound. The [[Sound.play]] method supports several optional parameters. A handy trick when you need a quick reminder of function parameters is to use [[@ operator|@]] (the at-sign) before a function reference, to return the function without invoking it. On the command line, that will print the function parameter names and default values. Try it:

<ms>@snd.play</ms>
which prints:
<ms>FUNCTION(self, volume=1, pan=0, speed=1)</ms>

So let's try some variations on the sound. (In the code below, we're using <c>//</c> to add a [[Comments|comment]] on each line; you don't have to type these, but you can if you like.)

<ms>snd.play 0.1 // play very quietly
snd.play 1, -1 // play out the left speaker only
snd.play 1, 0, 2 // play twice as fast (an octave higher)
snd.play 1, 0, 0.5 // play half as fast (an octave lower)</ms>

=== 2. Play your own custom sound ===

Put a sound file in WAV or OGG format into your project folder. (On some platforms you can also use MP3 format, but that doesn't work everywhere and so is best to avoid if you plan to distribute your game.) Let's suppose your file is called "bgm.ogg". Load and play it just as above:

<ms>snd2 = file.loadSound("bgm.ogg")
snd2.play</ms>

If your sound is very long, and you want to stop it, you can just do <c>snd2.stop</c>. Or you can use <c>Sound.stopAll</c> to stop all sounds.

Before we move on, let's make this sound loop forever, as you might want background music to do:

<ms>snd2.loop = true
snd2.play</ms>

Again, use <c>snd2.stop</c> to make it stop, or <c>Sound.stopAll</c> to stop all sounds. (The <c>reset</c> command will also do that, in addition to clearing the current program and variables.)

=== 3. About synthesized sounds ===

Mini Micro has a sophisticated API for creating sounds out of nothing but code. You can specify a base waveform, frequency, envelope, fade-in/fade-out, and even mix basic sounds together to create more sophisticated sounds. You can find a couple of simple examples on the [[Sound.init]] page, and some more complex ones by doing <c>run "/sys/lib/sounds"</c> (followed by <c>edit</c> to see how those examples were made). You can also <c>run "/sys/demo/soundLab"</c> for a graphical synthesizer, which can then output code you to recreate the sound.

== Write a program ==

Typing commands directly on the command line is a great way to learn, explore, and test things out. But to write more than a few lines, you'll want to use a code editor. Assuming you've mounted a folder (rather than a minidisk file), you have two options: the built-in code editor, or an external code editor.

=== Method 1: Use the built-in code editor ===

The [[Mini Micro code editor]] is invoked with the <c>edit</c> command. Just type <c>edit</c> by itself to edit the currently loaded program (or start a new program, if none is loaded). Or, you can add a filename argument, like <c>edit "myGame"</c>, to [[load]] a different program and open the editor in one step.

Note that once a program is loaded, if you want to start a new program, use [[reset]] to clear the current program and variables.

The built-in code editor is full-featured and powerful, including auto-indenting, code snippets, a color picker for color constants, and a sophisticated find/replace dialog. See [[Mini Micro code editor|this page]] for usage details.

=== Method 2: Use an external code editor ===

When you have mounted a real folder as your <c>/usr</c> (or <c>/usr2</c>) disk, then you can edit MiniScript files therein using your favorite code editor, outside of Mini Micro. On the [[Tools]] page you can even find language models for editors like VS Code or BBEdit, to provide MiniScript-savvy syntax coloring.

When you edit code in this way, you will need to reload the program from disk in Mini Micro to see your changes. It's also generally a good idea to <c>reset</c> the environment before running the new code, so that old function definitions or other variable values don't inadvertently change the behavior. So after externally editing a script called "myGame.ms", do:

<ms>reset; run "myGame"</ms>

in Mini Micro. (And once you've done this once, you can generally just up-arrow to recall and repeat this command again the next time.)

=== A simple game demo ===

Using either method above, create a new MiniScript program called "ufo.ms", and paste in the following. (Or to learn even faster, retype it instead of using copy & paste.)

<ms>// prepare displays
clear
sd = display(4) // sprite display

// prepare UFO sprite and other resources
ufo = new Sprite
ufo.image = file.loadImage("/sys/pics/UFO.png")
sd.sprites.push ufo
ufo.x = 480; ufo.y = 320

fireSound = file.loadSound("/sys/sounds/blam.wav")

// allow alternate "fire" buttons
fireButtons = ["space", "left shift", "right shift",
"joystick button 0", "joystick button 1"]
firePressed = function
for btn in fireButtons
if key.pressed(btn) then return true
end for
return false
end function

// function to "fire" (play a sound)
fire = function
fireSound.play
end function

// main loop
fireWasPressed = false
while true
yield // wait for next frame

// move the UFO
ufo.x += key.axis("Horizontal") * 20
ufo.y += key.axis("Vertical") * 20

// fire, when fire button goes down
fireNowPressed = firePressed
if fireNowPressed and not fireWasPressed then fire
fireWasPressed = fireNowPressed
end while</ms>

This creates a simple game demo which allows you to move a UFO around the screen using the arrow keys, WASD, or a game controller (which all feed into <c>[[key.axis]]</c>). And when you press any of several keys (including joystick/gamepad button 0 or 1), it plays a sound.

Try changing the UFO sprite to your own custom sprite, and changing the fire sound to your own sound. That will verify that you're able to get your own assets working in Mini Micro in a custom game program. Then start playing around with the code. Some things to try:

* Limit the sprite position so it can't go offscreen
* Add some sort of target, as in <c>/sys/demo/spriteDemo</c>
* Make the sprite drop/fire a second sprite when the fire button is pressed

== Package your game for the web ==

If you've come here because you want to make a Mini Micro game for a game jam, then you should almost certainly learn how to package your game for playing on the web, and upload it to a site like itch.io.

This process is described in detail on [[How to package a Mini Micro game]]. Focus on the general instructions at the top, and the "packaging for the web" instructions at the bottom.

== Where to learn more ==

Congratulations! You have learned how to set up a local Mini Micro environment for development, using your own game assets, and learned to use both the built-in and external code editors. You've made a very simple game demo, and know how to upload it to the web. All toolchain hurdles are behind you; now it's just a matter of designing a game, and writing the code!

If you are a Python or Lua programmer, see the [[Python]] or [[Lua]] page of this wiki to see how MiniScript compares to those.

When writing the code, you will probably lean most heavily on these resources:

* The [https://miniscript.org/files/MiniMicro-CheatSheet.pdf Mini Micro Cheat Sheet], a 4-page summary of the Mini Micro API and MiniScript language
* This wiki, especially the [[How To]] articles
* Sample code found in <c>/sys/demo</c>
* Various blog posts, perhaps found through the [[Bibliography]] page

Most important of all, rely on the '''community Discord server''', a link to which can be found at the bottom of the [https://miniscript.org/ MiniScript home page]. An active and friendly community hangs out on Discord, and you are encouraged to share screenshots, code snippets, and questions there.

[[Category:Mini Micro]]
[[Category:How To]]

How to get started with Mini Micro

2025-03-05T16:36:09Z

JoeStrout: /* Play a sound */ (fixed typo)

[https://miniscript.org/MiniMicro/ Mini Micro] is a popular environment for creating 2D games and demos in MiniScript. It is a retro-style virtual computer, which runs on most desktop platforms. Mini Micro games can be [[How to package a Mini Micro game|packaged]] as stand-alone games for desktop or the web.

This page is meant for people who have never used Mini Micro before, but want to make a Mini Micro game. It is a step-by-step guide to building your first simple demo involving a sprite, game input, and sound effects, including your own resources, as quickly as possible.

== Get Mini Micro ==

While you can run Mini Micro on the web, the web version has no ability to save files (nor does it support copy/paste). So it's not useful for developing your own Mini Micro games.

Go to the [https://miniscript.org/MiniMicro/#download Mini Micro download] page, click the button for your platform (Mac, Windows, or Linux), and save the resulting file to your local machine. (If you don't have a Mac, Windows, or Linux desktop machine, then unfortunately you can't use Mini Micro yet, though iOS and Android versions are under development.)

The downloaded file will be a .zip (Mac/Windows) or .tar.gz (Linux) file. ''Unpack this file completely.'' Don't try to run Mini Micro from ''within'' the archive; extract all files to a real folder on your hard drive.

Then, find the Mini Micro application in that folder. Double-click it to launch Mini Micro. The result should look like this.

[[File:MiniMicro.png|thumb|center]]

== Mount a folder as /usr ==

Mini Micro can access two virtual "disks" at once; within the Mini Micro environment, these are accessed as <c>/usr</c> and <c>/usr2</c>. Each of these can be either a '''.minidisk file''', or a '''real folder''' on the host (desktop) system. Out of the box, Mini Micro creates an empty .minidisk file for you, to keep things nice and neat. But for any serious development, you're going to want to mount a real folder instead, so that you can easily move files in and out of this folder, use your favorite external image/sound editors, etc.

Create a folder on your desktop system, wherever you normally keep your documents. This will be your project folder for your first Mini Micro game. Put a small text file, image (in PNG or JPEG format), or sound file (in WAV or OGG format) in there. Our goal now is to see and view this file (and any others in that folder or its subfolders) in Mini Micro.

=== Method 1: Use the disk slot menu ===

Those two thin dark rectangles in the bottom-left corner of the Mini Micro window are "disk slots." The top slot represents <c>/usr</c>, and the bottom slot represents <c>/usr2</c>. Click the top slot to pop open the menu, and select the "Mount Folder..." command.

[[File:MountFolder.png|frameless|center]]

Selecting that command should bring up the native file dialog for your platform, allowing you to select any folder you have access to. Pick the project folder you created above. (Note: some Linux platforms have a bug which crashes Mini Micro at this point; if that happens to you, go on to Method 2.)

Now, in the Mini Micro display, at the blinking orange prompt, type:

<ms>dir</ms>

and press Return or Enter. You should see your file listed. Now try:

<ms>view "myfile.txt"</ms>

but replace ''myfile.txt'' with the name of whatever file you placed in your project folder. Be sure to include the quotation marks; you're typing MiniScript code here, not some other shell language, so string literals always need to be surrounded by double quotes. If you do it correctly, the contents of your text file or image should appear on the screen.

(You could also do <c>view findFile</c>, which would pop up the little file browser within the [[findFile]] command, and select your file that way.)

Note that the currently mounted disk is saved in preferences, so if you quit and relaunch Mini Micro, you generally won't need to do this step again; the previously mounted disks will still be there.

=== Method 2: Use command-line arguments ===

If you are unfortunate enough to hit that Linux bug which causes the file dialogs to crash, or for some other reason you want to launch Mini Micro from the command line (or a shell script) with the correct folder already mounted, then you can use [[Command-line arguments|command-line arguments]] instead. Open your favorite terminal program, and navigate to where the Mini Micro executable is located. The details vary by platform, so let's break it down:

'''Linux'''

In Linux, the executable is called '''MiniMicro.x86_64''', so you would type a command like this:

<ms>./MiniMicro.x86_64 -usr ~/mmdev</ms>

Replace <c>~/mmdev</c> with the path to your project folder.

'''Windows'''

In Windows, you can open the command prompt by pressing '''Win + R''' to open the Run dialog, and entering ''cmd''. (If you already have some other preferred terminal app, like PowerShell, that's fine too.) Then <c>cd</c> to the directory containing Mini Micro. The executable here is called '''Mini Micro.exe''', so you would use a command like:

<ms>"Mini Micro.exe" -usr "%HOMEPATH%\mmdev</ms>

Replace <c>%HOMEPATH%\mmdev</c> with the path to your project folder.

'''MacOS'''

On Mac, the actual executable is hidden inside the application bundle, specifically under Contents/MacOS. So if you've already launched Terminal and navigated to where '''MiniMicro.app''' is found, then you would do

<ms>Contents/MacOS/Mini\ Micro -usr ~/Documents/mmdev</ms>

Replace <c>~/Documents/mmdev</c> with the path to your project folder.

If successful (on any platform), you should be able to use the <c>dir</c> and <c>view</c> commands to view the file in your project folder within the Mini Micro environment.

== Create a sprite ==

Now let's get a sprite up on the screen. We're going to do this using the Mini Micro command line (or [[REPL]]), where you type a command and executes immediately. We'll get to writing real programs later, but the command-line is a powerful tool for learning and exploring, so let's use it.

=== 1. Make a sprite from the built-in images ===

At the orange blinking-cursor prompt in Mini Micro, carefully type the following:

<ms>clear
sp = new Sprite
sp.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push sp</ms>

You should see a furry purple Wumpus peeking out from the lower-left corner of the screen (which is the origin of Mini Micro's [[Screen coordinates|coordinate system]]).

[[File:ManualSprite.png|thumb]]

If you don't see this, go back and double-check your typing. Note that you can recall a previous command on the command line by pressing the '''up-arrow''' key, then just edit it and press Return to run the edited command.

How does this work? Let's break it down:

# <c>[[clear]]</c> clears the screen and resets all eight display layers to their default states. This includes setting display 4 to be a [[SpriteDisplay]]. (That's the default state when Mini Micro boots, but useful whenever your screen is cluttered anyway.)
# <c>sp = new Sprite</c> creates a new [[Sprite]] object, and assigns it to a variable called <c>sp</c>.
# <c>sp.image = file.loadImage("/sys/pics/Wumpus.png")</c> loads an image called "Wumpus.png" from the <c>/sys/pics</c> directory. (Notice that Mini Micro uses forward-slashes in file paths, even if the host system is Windows.)
# <c>display(4).sprites.push sp</c> pushes this new sprite onto the sprite list of display 4, so it can be seen.

Once you have the Wumpus peeking out of the corner, let's move it and rotate it a bit. Notice how the sprite updates immediately after each command.

<ms>sp.x = 480
sp.y = 320
sp.rotation = 45</ms>

=== 2. Make a sprite from your own custom image ===

The Wumpus sprite above was created from one of the built-in images that comes with Mini Micro. There are hundreds of these, stored on a hidden, read-only disk mounted as <c>/sys</c>. Feel free to use the <c>findFile</c> command to explore what's there.

But for your own game, you're probably going to want to use your own custom sprites. So, put an image in PNG format into your project directory (the one you mounted as <c>/usr</c>). Use the <c>pwd</c> (print working directory) and <c>cd</c> (change directory) commands to be sure you are in your <c>/usr</c> directory. Then use the <c>dir</c> and <c>view</c> commands to ensure that you can see and load your user file.

Now, just repeat the commands you did to create a sprite above, but substitute the path to your custom image.

<ms>sp = new Sprite
sp.image = file.loadImage("myCustomImage.png")
display(4).sprites.push sp</ms>

If you haven't [[clear]]ed the display since step 1, then you'll see your new sprite ''and'' the Wumpus on screen at the same time. And if you now move (by assigning to <c>.x</c> and <c>.y</c>) your sprites so that they overlap, you'll see that your new sprite is drawn on top of the older one. That's because sprites are drawn in the order in which they appear in the [[SpriteDisplay.sprites|sprites list]] of the [[SpriteDisplay]].

=== 3. Extract an image from a sprite sheet ===

Often you have multiple sprite images arranged in one bigger image file, called a '''sprite sheet''' or '''sprite atlas'''. You can pull apart such a sprite sheet by using the [[Image.getImage]] function. Let's try:

<ms>enemies = file.loadImage("/sys/pics/Enemies.png")
view enemies</ms>

This loads and displays [https://github.com/JoeStrout/minimicro-sysdisk/blob/master/sys/pics/Enemies.png?raw=true this big image], which contains a number of platformer enemies, in a 128x128 pixel grid. Let's make a sprite out of the top-left image. Keep in mind that coordinates in Mini Micro go from the bottom-left corner, so that top image starts at 128 * 3 = 384.

<ms>goob = new Sprite
goob.image = enemies.getImage(0, 384, 128, 128)
display(4).sprites.push goob</ms>

This creates a new sprite called <c>goob</c>, assigns it an image from our <c>enemies</c> sprite sheet, and pushes it onto the display. As always, it starts out in the bottom-left corner, but you know how to adjust that by now. Since this sprite is a bit bigger than it probably needs to be, also try <c>goob.scale = 0.5</c> to shrink it down.

== Play a sound ==

Almost any game needs [[sound]] effects! Mini Micro supports playing both digitized sounds loaded from a file, and sounds synthesized at runtime. We'll focus here on playing sounds from a file, which can be in either WAV or OGG format.

=== 1. Play one of the built-in sounds ===

Enter <c>clear</c> to clear the screen, then try this:

<ms>snd = file.loadSound("/sys/sounds/twinkle.wav")
snd.play</ms>

You should hear a twinkle sound. The [[Sound.play]] method supports several optional parameters. A handy trick when you need a quick reminder of function parameters is to use [[@ operator|@]] (the at-sign) before a function reference, to return the function without invoking it. On the command line, that will print the function parameter names and default values. Try it:

<ms>@snd.play</ms>
which prints:
<ms>FUNCTION(self, volume=1, pan=0, speed=1)</ms>

So let's try some variations on the sound. (In the code below, we're using <c>//</c> to add a [[Comments|comment]] on each line; you don't have to type these, but you can if you like.)

<ms>snd.play 0.1 // play very quietly
snd.play 1, -1 // play out the left speaker only
snd.play 1, 0, 2 // play twice as fast (an octave higher)
snd.play 1, 0, 0.5 // play half as fast (an octave lower)</ms>

=== 2. Play your own custom sound ===

Put a sound file in WAV or OGG format into your project folder. (On some platforms you can also use MP3 format, but that doesn't work everywhere and so is best to avoid if you plan to distribute your game.) Let's suppose your file is called "bgm.ogg". Load and play it just as above:

<ms>snd2 = file.loadSound("bgm.ogg")
snd2.play</ms>

If your sound is very long, and you want to stop it, you can just do <c>snd2.stop</c>. Or you can use <c>Sound.stopAll</c> to stop all sounds.

Before we move on, let's make this sound loop forever, as you might want background music to do:

<ms>snd2.loop = true
snd2.play</ms>

Again, use <c>snd2.stop</c> to make it stop, or <c>Sound.stopAll</c> to stop all sounds. (The <c>reset</c> command will also do that, in addition to clearing the current program and variables.)

=== 3. About synthesized sounds ===

Mini Micro has a sophisticated API for creating sounds out of nothing but code. You can specify a base waveform, frequency, envelope, fade-in/fade-out, and even mix basic sounds together to create more sophisticated sounds. You can find a couple of simple examples on the [[Sound.init]] page, and some more complex ones by doing <c>run "/sys/lib/sounds"</c> (followed by <c>edit</c> to see how those examples were made).

== Write a program ==

Typing commands directly on the command line is a great way to learn, explore, and test things out. But to write more than a few lines, you'll want to use a code editor. Assuming you've mounted a folder (rather than a minidisk file), you have two options: the built-in code editor, or an external code editor.

=== Method 1: Use the built-in code editor ===

The [[Mini Micro code editor]] is invoked with the <c>edit</c> command. Just type <c>edit</c> by itself to edit the currently loaded program (or start a new program, if none is loaded). Or, you can add a filename argument, like <c>edit "myGame"</c>, to [[load]] a different program and open the editor in one step.

Note that once a program is loaded, if you want to start a new program, use [[reset]] to clear the current program and variables.

The built-in code editor is full-featured and powerful, including auto-indenting, code snippets, a color picker for color constants, and a sophisticated find/replace dialog. See [[Mini Micro code editor|this page]] for usage details.

=== Method 2: Use an external code editor ===

When you have mounted a real folder as your <c>/usr</c> (or <c>/usr2</c>) disk, then you can edit MiniScript files therein using your favorite code editor, outside of Mini Micro. On the [[Tools]] page you can even find language models for editors like VS Code or BBEdit, to provide MiniScript-savvy syntax coloring.

When you edit code in this way, you will need to reload the program from disk in Mini Micro to see your changes. It's also generally a good idea to <c>reset</c> the environment before running the new code, so that old function definitions or other variable values don't inadvertently change the behavior. So after externally editing a script called "myGame.ms", do:

<ms>reset; run "myGame"</ms>

in Mini Micro. (And once you've done this once, you can generally just up-arrow to recall and repeat this command again the next time.)

=== A simple game demo ===

Using either method above, create a new MiniScript program called "ufo.ms", and paste in the following. (Or to learn even faster, retype it instead of using copy & paste.)

<ms>// prepare displays
clear
sd = display(4) // sprite display

// prepare UFO sprite and other resources
ufo = new Sprite
ufo.image = file.loadImage("/sys/pics/UFO.png")
sd.sprites.push ufo
ufo.x = 480; ufo.y = 320

fireSound = file.loadSound("/sys/sounds/blam.wav")

// allow alternate "fire" buttons
fireButtons = ["space", "left shift", "right shift",
"joystick button 0", "joystick button 1"]
firePressed = function
for btn in fireButtons
if key.pressed(btn) then return true
end for
return false
end function

// function to "fire" (play a sound)
fire = function
fireSound.play
end function

// main loop
fireWasPressed = false
while true
yield // wait for next frame

// move the UFO
ufo.x += key.axis("Horizontal") * 20
ufo.y += key.axis("Vertical") * 20

// fire, when fire button goes down
fireNowPressed = firePressed
if fireNowPressed and not fireWasPressed then fire
fireWasPressed = fireNowPressed
end while</ms>

This creates a simple game demo which allows you to move a UFO around the screen using the arrow keys, WASD, or a game controller (which all feed into <c>[[key.axis]]</c>). And when you press any of several keys (including joystick/gamepad button 0 or 1), it plays a sound.

Try changing the UFO sprite to your own custom sprite, and changing the fire sound to your own sound. That will verify that you're able to get your own assets working in Mini Micro in a custom game program. Then start playing around with the code. Some things to try:

* Limit the sprite position so it can't go offscreen
* Add some sort of target, as in <c>/sys/demo/spriteDemo</c>
* Make the sprite drop/fire a second sprite when the fire button is pressed

== Package your game for the web ==

If you've come here because you want to make a Mini Micro game for a game jam, then you should almost certainly learn how to package your game for playing on the web, and upload it to a site like itch.io.

This process is described in detail on [[How to package a Mini Micro game]]. Focus on the general instructions at the top, and the "packaging for the web" instructions at the bottom.

== Where to learn more ==

Congratulations! You have learned how to set up a local Mini Micro environment for development, using your own game assets, and learned to use both the built-in and external code editors. You've made a very simple game demo, and know how to upload it to the web. All toolchain hurdles are behind you; now it's just a matter of designing a game, and writing the code!

If you are a Python or Lua programmer, see the [[Python]] or [[Lua]] page of this wiki to see how MiniScript compares to those.

When writing the code, you will probably lean most heavily on these resources:

* The [https://miniscript.org/files/MiniMicro-CheatSheet.pdf Mini Micro Cheat Sheet], a 4-page summary of the Mini Micro API and MiniScript language
* This wiki, especially the [[How To]] articles
* Sample code found in <c>/sys/demo</c>
* Various blog posts, perhaps found through the [[Bibliography]] page

Most important of all, rely on the '''community Discord server''', a link to which can be found at the bottom of the [https://miniscript.org/ MiniScript home page]. An active and friendly community hangs out on Discord, and you are encouraged to share screenshots, code snippets, and questions there.

[[Category:Mini Micro]]
[[Category:How To]]

TileDisplay.setCellTransform

2025-02-22T15:27:48Z

JoeStrout:

The <c>[[TileDisplay]].setCellTransform</c> method in [[Mini Micro]] (version 1.2.2 and later) introduced the ability to transform (flip and/or rotate) individual tiles in a TileDisplay. Give this method an integer from 0-7. Values 0-3 rotate the tile in 90° increments. Values 4-7 first flip the tile horizontally, and then rotate it in 90° increments.

[[File:CellTransform.png|frameless|center]]
See also: [[TileDisplay.cellTransform]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''x'' || number || 0 || column (or list of columns) of cell to change
|-
| ''y'' || number || 0 || row (or list of rows) of cell to change
|-
| ''transform'' || number || <c>[[null]]</c> || transform (0-7) to apply to the given cell
|}

== Example ==

This example configures display 4 to be a [[TileDisplay]], loads a tile set, and then sets the cell at column 5, row 5 to be tile index 70 (a green key in this tile set). It then cycles through all 8 transforms, one per half second.

<ms>clear
display(4).mode = displayMode.tile
td = display(4)
td.tileSet = file.loadImage("/sys/pics/SimplePlatformTiles.png")
td.tileSetTileSize = 64
td.cellSize = 64
td.clear

td.setCell 5, 5, 70 // green key

while true
td.setCellTransform 5, 5, (td.cellTransform(5,5)+1) % 8
text.row = 12; text.column = 25
print td.cellTransform(5,5)
wait 0.5
end while</ms>

[[File:setCellTransform.gif|frameless|center]]

[[Category:Mini Micro]]

TileDisplay.setCellTransform

2025-02-22T15:27:17Z

JoeStrout:

The <c>[[TileDisplay]].setCellTransform</c> method in [[Mini Micro]] (version 1.2.2 and later) introduced the ability to transform (flip and/or rotate) individual tiles in a TileDisplay. Give this method an integer from 0-7. Values 0-3 rotate the tile in 90° increments. Values 4-7 first flip the tile horizontally, and then rotate it in 90° increments.

[[File:CellTransform.png|frameless|center]]
See also: [[TileDisplay.cellTransfrom]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''x'' || number || 0 || column (or list of columns) of cell to change
|-
| ''y'' || number || 0 || row (or list of rows) of cell to change
|-
| ''transform'' || number || <c>[[null]]</c> || transform (0-7) to apply to the given cell
|}

== Example ==

This example configures display 4 to be a [[TileDisplay]], loads a tile set, and then sets the cell at column 5, row 5 to be tile index 70 (a green key in this tile set). It then cycles through all 8 transforms, one per half second.

<ms>clear
display(4).mode = displayMode.tile
td = display(4)
td.tileSet = file.loadImage("/sys/pics/SimplePlatformTiles.png")
td.tileSetTileSize = 64
td.cellSize = 64
td.clear

td.setCell 5, 5, 70 // green key

while true
td.setCellTransform 5, 5, (td.cellTransform(5,5)+1) % 8
text.row = 12; text.column = 25
print td.cellTransform(5,5)
wait 0.5
end while</ms>

[[File:setCellTransform.gif|frameless|center]]

[[Category:Mini Micro]]

File:SetCellTransform.gif

2025-02-22T15:25:55Z

JoeStrout: Output (animated screenshot) of example on TileDisplay.setCellTransform

== Summary ==
Output (animated screenshot) of example on [[TileDisplay.setCellTransform]]

TileDisplay.setCellTransform

2025-02-22T15:24:51Z

JoeStrout: Created page with "The <c>TileDisplay.setCellTransform</c> method in Mini Micro (version 1.2.2 and later) introduced the ability to transform (flip and/or rotate) individual tiles in a TileD..."

The <c>TileDisplay.setCellTransform</c> method in [[Mini Micro]] (version 1.2.2 and later) introduced the ability to transform (flip and/or rotate) individual tiles in a TileDisplay. Give this method an integer from 0-7. Values 0-3 rotate the tile in 90° increments. Values 4-7 first flip the tile horizontally, and then rotate it in 90° increments.

[[File:CellTransform.png|frameless|center]]
See also: [[TileDisplay.cellTransfrom]]

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''x'' || number || 0 || column (or list of columns) of cell to change
|-
| ''y'' || number || 0 || row (or list of rows) of cell to change
|-
| ''transform'' || number || <c>[[null]]</c> || transform (0-7) to apply to the given cell
|}

== Example ==

This example configures display 4 to be a [[TileDisplay]], loads a tile set, and then sets the cell at column 5, row 5 to be tile index 70 (a green key in this tile set). It then cycles through all 8 transforms, one per half second.

<ms>clear
display(4).mode = displayMode.tile
td = display(4)
td.tileSet = file.loadImage("/sys/pics/SimplePlatformTiles.png")
td.tileSetTileSize = 64
td.cellSize = 64
td.clear

td.setCell 5, 5, 70 // green key

while true
td.setCellTransform 5, 5, (td.cellTransform(5,5)+1) % 8
text.row = 12; text.column = 25
print td.cellTransform(5,5)
wait 0.5
end while</ms>

[[File:setCellTransform.gif|frameless|center]]

[[Category:Mini Micro]]

TileDisplay.cellTransform

2025-02-22T15:10:43Z

JoeStrout:

[[Mini Micro]] version 1.2.2 introduced the ability to transform (flip and/or rotate) individual tiles in a TileDisplay. The value returned by <c>TileDisplay.cellTransform</c>, or given to <c>[[TileDisplay.setCellTransform]]</c>, is an integer from 0-7. Values 0-3 rotate the tile in 90° increments. Values 4-7 first flip the tile horizontally, and then rotate it in 90° increments.

[[File:CellTransform.png|frameless|center]]

[[Category:Mini Micro]]

TileDisplay

2025-02-22T15:09:39Z

JoeStrout: add new cellTransform methods

The <c>TileDisplay</c> class in [[Mini Micro]] is a display type that holds and draws a grid of tiles, small images taken from a larger image called a ''tile set''.

No display is configured as a tile display by default. But you can make any display layer a tile display by setting its [[Display.mode|mode]] to <c>displayMode.tile</c>.

== Tile Indexing ==

The tiles within the tile-set are referred to by index.

Note that in contrast to all other Mini Micro coordinates (which originate bottom-left) the tiles in a tile-set file are indexed from '''top-left to bottom-right'''.

The tile with index 0 will refer to the leftmost image in the first row, index 1 to the one to its right, and so on, until the last image in the row. The next index number will refer to the first / leftmost image in the second row, and so on. The last image in the tile set will be the rightmost of the last row.

== Methods and Properties ==

{| class="wikitable"
|-
! Method or Property !! Purpose
|-
|-
| [[TileDisplay.extent]] ''[columns, rows]'' || display size
|-
| [[TileDisplay.tileSet]] || [[Image]] containing tiles to draw from
|-
| [[TileDisplay.tileSetTileSize]] || size of tiles in `tileSet`
|-
| [[TileDisplay.cellSize]] || size of tiles on screen
|-
| [[TileDisplay.overlap]] || cell overlap, in pixels
|-
| [[TileDisplay.oddRowOffset]] || amount to shift odd rows horizontally; use 0.5 for hex rows
|-
| [[TileDisplay.oddColOffset]] || amount to shift odd columns vertically; use 0.5 for hex columns
|-
| [[TileDisplay.scrollX]] || horizontal scroll amount, in pixels
|-
| [[TileDisplay.scrollY]] || vertical scroll amount, in pixels
|-
| [[TileDisplay.clear]] ''toIndex'' || set all tiles to null (the default) or the given index
|-
| [[TileDisplay.cell]](''x'', ''y'') || get the tile index of cell ''x'', ''y''
|-
| [[TileDisplay.setCell]] ''x'', ''y'', ''idx'' || set the tile index of cell ''x'', ''y'' to ''idx''
|-
| [[TileDisplay.cellTint]](''x'', ''y'') || get the tint color of cell ''x'', ''y''
|-
| [[TileDisplay.setCellTint]] ''x'', ''y'', ''c'' || set the tint of cell ''x'', ''y'' to color ''c''
|-
| [[TileDisplay.cellTransform]](''x'', ''y'') || get the transform (0-7) of cell at ''x'', ''y''
|-
| [[TileDisplay.setCellTransform]] ''x'', ''y'', ''t'' || set the transform of cell ''x'', ''y'' to value ''t''
|}

== Example ==

The following example shows how to set up a TileDisplay, load an initial pattern tiles, and then dynamically change the tiles shown over time. (The main loop cycles through all 64 tiles in the demo tile set, changing the tile shown in the center of the display every 0.1 seconds.)

<ms>// prepare the display
clear
display(5).mode = displayMode.tile
td = display(5)
td.tileSet = file.loadImage("/sys/pics/TileShapes.png")
td.tileSetTileSize = 64 // size of each tile in the image
td.extent = [15, 10] // columns, rows on screen

// set up the initial tile pattern
td.clear 20 // clear to tile 20 (dark blue circle)
for row in range(0, 9)
td.setCell 0, row, 6 // tile 6 is a yellow square
td.setCell 14, row, 6
end for
for col in range(0, 14)
td.setCell col, 0, 1 // tile 1 is a gray square
td.setCell col, 9, 1
end for

// main loop
cellIdx = 0
while true
td.setCell 7, 5, cellIdx
cellIdx = (cellIdx + 1) % 64
wait 0.1
end while</ms>

[[File:TileDisplayExample.png|frameless|center]]

[[Category:Mini Micro]]

Naming Conventions

2025-02-15T23:26:46Z

JoeStrout: /* Capitalization */

The MiniScript [[:Category:Intrinsic Functions|intrinsic functions]] and [[Mini Micro]] API have established the following conventions with regard to naming variables.

== Capitalization ==
* classes (maps intended to be used with [[new]]) use captialized CamelCase: <c>Monster</c>, <c>RigidBody</c>, <c>InventoryItem</c>
* method names use camelCase, starting with lower-case, e.g.: <c>[[print]]</c>, <c>calcTotal</c>
* variables follow the same convention: <c>x</c>, <c>totalIncome</c>

UPDATE: Recent discussion has led to also capitalizing "static" class members, i.e., methods and properties which are intended to be called directly on a class rather than on some instance of the class. For example, <c>Monster.Instances</c> might be a list on the <c>Monster</c> class that keeps track of all the instances of that class. This convention is not yet consistently used, but it is recommended and catching on.

== Nouns vs. Verbs ==

In general, methods that perform some operation should be active verbs, e.g. <c>[[print]]</c>, <c>[[wait]]</c>, <c>applyDiscount</c>. Clear abbreviations are acceptable when a name would otherwise be unwieldy, e.g. <c>calcTotal</c> instead of <c>calculateTotal</c>. Methods that merely return an attribute (whether stored or calculated) should be named for what they return, e.g. <c>[[abs]]</c>, <c>average</c>. (The line between these two cases can be fuzzy; favor a simple attribute name if the calculation is quick and has no side effects, but an active verb if the calculation may take some time or has any effects beyond returning the answer.)

Object references should be descriptive nouns, e.g. <c>player</c>, <c>annualIncome</c>.

== Avoid Starting With an Underscore ==

Per the MiniScript manual, in most cases you should avoid starting any global variables or function names with an underscore. Identifiers starting with an underscore are often used by the host environment for special “under the hood” code, and name collisions there could cause problems.

== Short Names ==

Very short variable names should be used only for fleeting purposes, such as loop counters in small loops, or parameter names in small functions. They are also often used when experimenting in a [[REPL]]. The following names are generally understood:

* <c>i</c>, <c>j</c>: loop counters (usually numbers)
* <c>c</c>: character (e.g. while looping over a string)
* <c>x</c>, <c>y</c>: 2D coordinates
* <c>dx</c>, <c>dy</c>: 2D offset
* <c>vx</c>, <c>vy</c>: 2D velocity
* <c>t</c>: time
* <c>dt</c>: time step or offset
* <c>s</c>: a string, or any sequence
* <c>m</c>, <c>d</c>: a map (<c>d</c> is short for "dictionary")
* <c>l</c>, <c>a</c>: a list (<c>a</c> is short for "array"; and note that <c>l</c> looks very similar to <c>1</c>, and so should probably be avoided)

[[Category:Conventions]]

Naming Conventions

2025-02-15T23:25:13Z

JoeStrout: /* Capitalization */

The MiniScript [[:Category:Intrinsic Functions|intrinsic functions]] and [[Mini Micro]] API have established the following conventions with regard to naming variables.

== Capitalization ==
* classes (maps intended to be used with [[new]]) use captialized CamelCase: <c>Monster</c>, <c>RigidBody</c>, <c>InventoryItem</c>
* method names use camelCase, starting with lower-case, e.g.: <c>[[print]]</c>, <c>calcTotal</c>
* variables follow the same convention: <c>x</c>, <c>totalIncome</c>

UPDATE: Recent discussion has led to also capitalizing "static" class members, i.e., methods and properties which are intended to be called directly on a class rather than on some instance of the class.

== Nouns vs. Verbs ==

In general, methods that perform some operation should be active verbs, e.g. <c>[[print]]</c>, <c>[[wait]]</c>, <c>applyDiscount</c>. Clear abbreviations are acceptable when a name would otherwise be unwieldy, e.g. <c>calcTotal</c> instead of <c>calculateTotal</c>. Methods that merely return an attribute (whether stored or calculated) should be named for what they return, e.g. <c>[[abs]]</c>, <c>average</c>. (The line between these two cases can be fuzzy; favor a simple attribute name if the calculation is quick and has no side effects, but an active verb if the calculation may take some time or has any effects beyond returning the answer.)

Object references should be descriptive nouns, e.g. <c>player</c>, <c>annualIncome</c>.

== Avoid Starting With an Underscore ==

Per the MiniScript manual, in most cases you should avoid starting any global variables or function names with an underscore. Identifiers starting with an underscore are often used by the host environment for special “under the hood” code, and name collisions there could cause problems.

== Short Names ==

Very short variable names should be used only for fleeting purposes, such as loop counters in small loops, or parameter names in small functions. They are also often used when experimenting in a [[REPL]]. The following names are generally understood:

* <c>i</c>, <c>j</c>: loop counters (usually numbers)
* <c>c</c>: character (e.g. while looping over a string)
* <c>x</c>, <c>y</c>: 2D coordinates
* <c>dx</c>, <c>dy</c>: 2D offset
* <c>vx</c>, <c>vy</c>: 2D velocity
* <c>t</c>: time
* <c>dt</c>: time step or offset
* <c>s</c>: a string, or any sequence
* <c>m</c>, <c>d</c>: a map (<c>d</c> is short for "dictionary")
* <c>l</c>, <c>a</c>: a list (<c>a</c> is short for "array"; and note that <c>l</c> looks very similar to <c>1</c>, and so should probably be avoided)

[[Category:Conventions]]

SolidColorDisplay

2025-02-10T17:15:33Z

JoeStrout: Added fade out/in example

The <c>SolidColorDisplay</c> class in [[Mini Micro]] is a display type that represents a single color over the entire screen. It is often used to control overall background color of the screen, or as an overlay to fade the rest of the displays in or out.

Note that "solid" here refers to the entire display layer being one color. It does ''not'' imply that this color must be opaque; translucent colors work perfectly well.

By default, [[display]] 7 is configured as a solid black display (by the [[clear]] command).

== Methods and Properties ==

{| class="wikitable"
|-
! Method or Property !! Purpose
|-
| [[SolidColorDisplay.color]] || get or set the color of the display layer
|}

== Examples ==

The following example sets the background (display 7) to blue, and also clears the pixel display (layer 5) to clear so that the background can be seen.

<ms>clear
display(7).color = color.blue
display(5).clear color.clear</ms>

The next example does a "fade to black" by setting display 0 (the topmost layer) to solid color, and gradually changing it from completely transparent to solid black. Then, after waiting for the user to press a key, it fades back to transparent, making everything behind it appear to "fade in."

<ms>display(0).mode = displayMode.solidColor
fader = display(0)
for alpha in range(0, 255, 3)
fader.color = color.rgba(0,0,0, alpha)
yield
end for

key.get // wait for a keypress

for alpha in range(255, 0, -3)
fader.color = color.rgba(0,0,0, alpha)
yield
end for
display(0).mode = displayMode.off</ms>

[[Category:Mini Micro]]

If

2025-02-06T15:22:14Z

JoeStrout: Added indentation

<c>if</c> is the [[:Category:Keywords|keyword]] that begins an ''if block''. Use an <c>if…then</c> statement to specify some condition under which the following statements should be executed. The basic syntax is:

:'''if''' ''condition'' '''then'''
:…
:'''end if'''

When the condition is not true, MiniScript will jump directly to the <c>end if</c> statement.

<ms>if x == 42 then
print "I have found the Ultimate Answer!"
end if</ms>

The whole set of lines, from <c>if…then</c> to <c>end if</c>, is known as an ''if block''.
Sometimes you want to do something else when the specified condition is not true. You can
specify this with an ''else block'' before the <c>end if</c>.

<ms>if x == 42 then
print "I have found the Ultimate Answer!"
else
print "I am still searching."
end if</ms>

Finally, you can check for additional conditions by adding ''else-if blocks'' as needed. Here's a
slightly more practical example that converts a number to words.

<ms>if apples == 0 then
print "You have no apples."
else if apples == 1 then
print "You have one apple."
else if apples > 10 then
print "You have a lot of apples!"
else
print "You have " + apples + " apples."
end if</ms>

In this case, the first condition that matches will execute its block of lines. If none of the
conditions match, then the <c>else</c> block will run instead.

Note that for all these forms, the <c>if</c>, <c>else if</c>, <c>else</c>, and <c>end if</c> statements must each be
on its own line. However, there is also a "short form" <c>if</c> statement that allows you to write
an <c>if</c> or <c>if/else</c> on a single line, provided you have only a single statement for the then
block, and a single statement for the <c>else</c> block (if you have an <c>else</c> block at all). A shortform
if looks like this:

<ms>if x == null then x = 1</ms>

…while a short-form if/else looks like this:

<ms>if x >= 0 then print "positive" else print "negative"</ms>

Notice that <c>end if</c> is not used with a short-form <c>if</c> or <c>if/else</c>. Moreover, there is no
way to put more than one statement into the <c>then</c> or <c>else</c> block. If you need more than
one statement, then use the standard multi-line form.

[[Category:Language]]
[[Category:Keywords]]

Category:Sys Modules

2025-01-31T14:31:52Z

JoeStrout:

System modules are libraries of classes and functions that expand and build on [[Mini Micro]]'s native classes. These modules add more features to aid in game development. Some of these libraries are also available in [[Farmtronics]], [[command-line MiniScript]], and [[Soda]]. Source for these libraries can be found under the [[/sys]]/lib folder of [[Mini Micro]] or on [https://github.com/JoeStrout/minimicro-sysdisk/tree/master/sys/lib Github].

Key.put

2025-01-29T20:42:06Z

JoeStrout:

<c>[[key]].put</c> allows you to enqueue a string, or single character by code point, into the keyboard buffer used by both the command line and the [[input]] function.

== Example ==
<ms>
// Put MiniScript code for a countdown from 10 to 1, then print "BOOM!"
key.put "for i in range(10, 1); clear; print i; wait; end for; clear; print ""BOOM!"""
key.put 13 // carriage return

// Put MiniScript code to print "Hello, World!"
key.put "print ""Hello, World!"""
key.put 13 // carriage return

key.put 99 // c
key.put 108 // l
key.put 101 // e
key.put 97 // a
key.put 114 // r
</ms>

[[Category:Mini Micro]]

Or

2025-01-29T20:40:08Z

JoeStrout:

<c>or</c> is a [[:Category:Keywords|keyword]] for logical binary operator of disjunction (or) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra] and [[Fuzzy Logic]]. It evaluates two operands and returns <c>true</c> when at least one of the operands is <c>true</c>, else it returns <c>false</c>.

More specifically, <c>a or b</c> (where ''a'' and ''b'' are numbers) evaluates to the absolute value of the expression <c>a + b - (a * b)</c>, clamped to the range 0 - 1.

== Examples ==
<ms>
print false or false // output : 0
print false or true // output : 1
print true or false // output : 1
print true or true // output : 1
print 0.8 or 0.5 // output : 0.9

a = false
b = true
c = false
print a or b // output : 1
print b or c // output : 1
print a or c // output : 0

minimum = 3
maximum = 7
A = 4
B = 9
print A > minimum or B < maximum // output : 1
print A < minimum or B < maximum // output : 0
</ms>

See also: [[and]], [[not]], [[Fuzzy Logic]].

[[Category:Language]]
[[Category:Keywords]]

And

2025-01-29T20:39:48Z

JoeStrout:

<c>and</c> is a [[:Category:Keywords|keyword]] for logical binary operator of conjunction (and) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra] and [[Fuzzy Logic]]. It evaluates two operands and returns <c>true</c> only when both operands are <c>true</c>, else it returns <c>false</c>.

More specifically, <c>a and b</c>, where ''a'' and ''b'' are numbers, evaluates to the absolute value of the product <c>a * b</c>, clamped to the range 0 - 1.

== Examples ==
<ms>
print false and false // output : 0
print false and true // output : 0
print true and false // output : 0
print true and true // output : 1
print 0.8 and 0.5 // output : 0.4

a = true
b = false
c = true
print a and b // output : 0
print b and c // output : 0
print a and c // output : 1

minimum = 3
maximum = 7
A = 4
B = 9
print A > minimum and A < maximum // output : 1
print B > minimum and B < maximum // output : 0
</ms>

See also: [[or]], [[not]], [[Fuzzy Logic]].

[[Category:Language]]
[[Category:Keywords]]

And

2025-01-29T20:38:45Z

JoeStrout:

<c>and</c> is a [[:Category:Keywords|keyword]] for logical binary operator of conjunction (and) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra] and [[Fuzzy Logic]]. It evaluates two operands and returns <c>true</c> only when both operands are <c>true</c>, else it returns <c>false</c>.

More specifically, <c>a and b</c>, where ''a'' and ''b'' are numbers, evaluates to the absolute value of the product <c>a * b</c>, clamped to the range 0 - 1.

== Examples ==
<ms>
print false and false // output : 0
print false and true // output : 0
print true and false // output : 0
print true and true // output : 1
print 0.8 and 0.5 // output : 0.4

a = true
b = false
c = true
print a and b // output : 0
print b and c // output : 0
print a and c // output : 1

minimum = 3
maximum = 7
A = 4
B = 9
print A > minimum and A < maximum // output : 1
print B > minimum and B < maximum // output : 0
</ms>

See also [[Fuzzy Logic]].

[[Category:Language]]
[[Category:Keywords]]

Or

2025-01-29T20:38:10Z

JoeStrout:

And

2025-01-29T20:35:51Z

JoeStrout:

<c>and</c> is a [[:Category:Keywords|keyword]] for logical binary operator of conjunction (and) of [https://en.wikipedia.org/wiki/Boolean_algebra boolean algebra] and [[Fuzzy Logic]]. It evaluates two operands and returns <c>true</c> only when both operands are <c>true</c>, else it returns <c>false</c>.

More specifically, <c>a and b</c>, where ''a'' and ''b'' are numbers, evaluates to the absolute value of the product <c>a * b</c>, clamped to the range 0 - 1.

== Examples ==
<ms>
print false and false // output : 0
print false and true // output : 0
print true and false // output : 0
print true and true // output : 1

a = true
b = false
c = true
print a and b // output : 0
print b and c // output : 0
print a and c // output : 1

minimum = 3
maximum = 7
A = 4
B = 9
print A > minimum and A < maximum // output : 1
print B > minimum and B < maximum // output : 0
</ms>

See also [[Fuzzy Logic]].

[[Category:Language]]
[[Category:Keywords]]

PixelDisplay.getImage

2025-01-29T15:18:24Z

JoeStrout: fixed typo

<c>[[PixelDisplay]].getImage</c> returns a portion of the pixel display as an [[Image]].

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''left'' || number || 0 || left side of display area to get
|-
| ''bottom'' || number || 0 || bottom side of display area to get
|-
| ''width'' || number || 960 || width side of display area to get
|-
| ''height'' || number || 640 || height side of display area to get
|}

=== Usage Notes ===
Note that this works even for a display that is not visible (because it is covered by another
display, or has been turned [[DisplayMode|off]]). This allows you to use
a PixelDisplay as an area to create images at runtime, using any combination
of drawing methods, and then capture the result for use as a [[Sprite]], or
to [[File.saveImage|save]] to disk, etc.

Another way to create an [[Image]] at runtime is to use [[Image.create]].

[[Category:Mini Micro]]

Image.flip

2025-01-18T14:22:17Z

JoeStrout: Fix minor formatting error

<c>[[Image]].flip</c> flips an image in memory, either vertically or horizontally.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''vertical'' || boolean || false || flips the image vertically when true and horizontally when false
|}

== Example ==

<ms>img = file.loadImage("/sys/pics/Wumpus.png")
img.flip false
view img</ms>

After running the above code, <c>img</c> refers to a horizontally-flipped version of the standard Wumpus image.

[[Category:Mini Micro]]
[[Category:Soda]]

Image.rotate

2025-01-18T14:21:47Z

JoeStrout:

<c>[[Image]].rotate</c> rotates an image in memory, in 90 degree increments. All other degree values will print an error and have no effect on the image. Values that fall outside of 0 to 360 are valid so long as they are increments of 90 degrees.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''degrees'' || number || 90 || amount of counter-clockwise rotation to apply
|}

== Example ==

<ms>img = file.loadImage("/sys/pics/Wumpus.png")
img.rotate -90
view img</ms>

After running the above code, <c>img</c> refers to a version of the standard Wumpus image that has been rotated 90° to the right.

[[Category:Mini Micro]]
[[Category:Soda]]

Image.flip

2025-01-18T14:19:04Z

JoeStrout:

<c>[[Image]].flip</c> flips an image in memory, either vertically or horizontally.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''vertical'' || boolean || false || flips the image vertically when true and horizontally when false
|}

== Example ==

<ms>img = file.loadImage("/sys/pics/Wumpus.png")
img.flip false
view img</ms>

After running the above code, `img` refers to a horizontally-flipped version of the standard Wumpus image.

[[Category:Mini Micro]]
[[Category:Soda]]

File.setdir

2025-01-18T14:15:31Z

JoeStrout: included Farmtronics and note about quotes

The <c>[[file]].setdir</c> method sets the current working directory in [[Mini Micro]], [[Farmtronics]], or [[command-line MiniScript]].

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Type !! Default Value !! Meaning
|-
| ''path'' || string || || the relative or absolute location of the folder to set as the working directory
|}

In [[Mini Micro]] and [[Farmtronics]], <c>[[cd]]</c> is standard shorthand for <c>[[file]].setdir</c>. Note that you still need quotation marks around the path.

[[Category:Mini Micro]]
[[Category:Command-Line MiniScript]]
[[Category:Farmtronics]]

How to get started with Mini Micro

2024-12-19T14:06:38Z

JoeStrout: /* Create a sprite */

[https://miniscript.org/MiniMicro/ Mini Micro] is a popular environment for creating 2D games and demos in MiniScript. It is a retro-style virtual computer, which runs on most desktop platforms. Mini Micro games can be [[How to package a Mini Micro game|packaged]] as stand-alone games for desktop or the web.

This page is meant for people who have never used Mini Micro before, but want to make a Mini Micro game. It is a step-by-step guide to building your first simple demo involving a sprite, game input, and sound effects, including your own resources, as quickly as possible.

== Get Mini Micro ==

While you can run Mini Micro on the web, the web version has no ability to save files (nor does it support copy/paste). So it's not useful for developing your own Mini Micro games.

Go to the [https://miniscript.org/MiniMicro/#download Mini Micro download] page, click the button for your platform (Mac, Windows, or Linux), and save the resulting file to your local machine. (If you don't have a Mac, Windows, or Linux desktop machine, then unfortunately you can't use Mini Micro yet, though iOS and Android versions are under development.)

The downloaded file will be a .zip (Mac/Windows) or .tar.gz (Linux) file. ''Unpack this file completely.'' Don't try to run Mini Micro from ''within'' the archive; extract all files to a real folder on your hard drive.

Then, find the Mini Micro application in that folder. Double-click it to launch Mini Micro. The result should look like this.

[[File:MiniMicro.png|thumb|center]]

== Mount a folder as /usr ==

Mini Micro can access two virtual "disks" at once; within the Mini Micro environment, these are accessed as <c>/usr</c> and <c>/usr2</c>. Each of these can be either a '''.minidisk file''', or a '''real folder''' on the host (desktop) system. Out of the box, Mini Micro creates an empty .minidisk file for you, to keep things nice and neat. But for any serious development, you're going to want to mount a real folder instead, so that you can easily move files in and out of this folder, use your favorite external image/sound editors, etc.

Create a folder on your desktop system, wherever you normally keep your documents. This will be your project folder for your first Mini Micro game. Put a small text file, image (in PNG or JPEG format), or sound file (in WAV or OGG format) in there. Our goal now is to see and view this file (and any others in that folder or its subfolders) in Mini Micro.

=== Method 1: Use the disk slot menu ===

Those two thin dark rectangles in the bottom-left corner of the Mini Micro window are "disk slots." The top slot represents <c>/usr</c>, and the bottom slot represents <c>/usr2</c>. Click the top slot to pop open the menu, and select the "Mount Folder..." command.

[[File:MountFolder.png|frameless|center]]

Selecting that command should bring up the native file dialog for your platform, allowing you to select any folder you have access to. Pick the project folder you created above. (Note: some Linux platforms have a bug which crashes Mini Micro at this point; if that happens to you, go on to Method 2.)

Now, in the Mini Micro display, at the blinking orange prompt, type:

<ms>dir</ms>

and press Return or Enter. You should see your file listed. Now try:

<ms>view "myfile.txt"</ms>

but replace ''myfile.txt'' with the name of whatever file you placed in your project folder. Be sure to include the quotation marks; you're typing MiniScript code here, not some other shell language, so string literals always need to be surrounded by double quotes. If you do it correctly, the contents of your text file or image should appear on the screen.

(You could also do <c>view findFile</c>, which would pop up the little file browser within the [[findFile]] command, and select your file that way.)

Note that the currently mounted disk is saved in preferences, so if you quit and relaunch Mini Micro, you generally won't need to do this step again; the previously mounted disks will still be there.

=== Method 2: Use command-line arguments ===

If you are unfortunate enough to hit that Linux bug which causes the file dialogs to crash, or for some other reason you want to launch Mini Micro from the command line (or a shell script) with the correct folder already mounted, then you can use [[Command-line arguments|command-line arguments]] instead. Open your favorite terminal program, and navigate to where the Mini Micro executable is located. The details vary by platform, so let's break it down:

'''Linux'''

In Linux, the executable is called '''MiniMicro.x86_64''', so you would type a command like this:

<ms>./MiniMicro.x86_64 -usr ~/mmdev</ms>

Replace <c>~/mmdev</c> with the path to your project folder.

'''Windows'''

In Windows, you can open the command prompt by pressing '''Win + R''' to open the Run dialog, and entering ''cmd''. (If you already have some other preferred terminal app, like PowerShell, that's fine too.) Then <c>cd</c> to the directory containing Mini Micro. The executable here is called '''Mini Micro.exe''', so you would use a command like:

<ms>"Mini Micro.exe" -usr "%HOMEPATH%\mmdev</ms>

Replace <c>%HOMEPATH%\mmdev</c> with the path to your project folder.

'''MacOS'''

On Mac, the actual executable is hidden inside the application bundle, specifically under Contents/MacOS. So if you've already launched Terminal and navigated to where '''MiniMicro.app''' is found, then you would do

<ms>Contents/MacOS/Mini\ Micro -usr ~/Documents/mmdev</ms>

Replace <c>~/Documents/mmdev</c> with the path to your project folder.

If successful (on any platform), you should be able to use the <c>dir</c> and <c>view</c> commands to view the file in your project folder within the Mini Micro environment.

== Create a sprite ==

Now let's get a sprite up on the screen. We're going to do this using the Mini Micro command line (or [[REPL]]), where you type a command and executes immediately. We'll get to writing real programs later, but the command-line is a powerful tool for learning and exploring, so let's use it.

=== 1. Make a sprite from the built-in images ===

At the orange blinking-cursor prompt in Mini Micro, carefully type the following:

<ms>clear
sp = new Sprite
sp.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push sp</ms>

You should see a furry purple Wumpus peeking out from the lower-left corner of the screen (which is the origin of Mini Micro's [[Screen coordinates|coordinate system]]).

[[File:ManualSprite.png|thumb]]

If you don't see this, go back and double-check your typing. Note that you can recall a previous command on the command line by pressing the '''up-arrow''' key, then just edit it and press Return to run the edited command.

How does this work? Let's break it down:

# <c>[[clear]]</c> clears the screen and resets all eight display layers to their default states. This includes setting display 4 to be a [[SpriteDisplay]]. (That's the default state when Mini Micro boots, but useful whenever your screen is cluttered anyway.)
# <c>sp = new Sprite</c> creates a new [[Sprite]] object, and assigns it to a variable called <c>sp</c>.
# <c>sp.image = file.loadImage("/sys/pics/Wumpus.png")</c> loads an image called "Wumpus.png" from the <c>/sys/pics</c> directory. (Notice that Mini Micro uses forward-slashes in file paths, even if the host system is Windows.)
# <c>display(4).sprites.push sp</c> pushes this new sprite onto the sprite list of display 4, so it can be seen.

Once you have the Wumpus peeking out of the corner, let's move it and rotate it a bit. Notice how the sprite updates immediately after each command.

<ms>sp.x = 480
sp.y = 320
sp.rotation = 45</ms>

=== 2. Make a sprite from your own custom image ===

The Wumpus sprite above was created from one of the built-in images that comes with Mini Micro. There are hundreds of these, stored on a hidden, read-only disk mounted as <c>/sys</c>. Feel free to use the <c>findFile</c> command to explore what's there.

But for your own game, you're probably going to want to use your own custom sprites. So, put an image in PNG format into your project directory (the one you mounted as <c>/usr</c>). Use the <c>pwd</c> (print working directory) and <c>cd</c> (change directory) commands to be sure you are in your <c>/usr</c> directory. Then use the <c>dir</c> and <c>view</c> commands to ensure that you can see and load your user file.

Now, just repeat the commands you did to create a sprite above, but substitute the path to your custom image.

<ms>sp = new Sprite
sp.image = file.loadImage("myCustomImage.png")
display(4).sprites.push sp</ms>

If you haven't [[clear]]ed the display since step 1, then you'll see your new sprite ''and'' the Wumpus on screen at the same time. And if you now move (by assigning to <c>.x</c> and <c>.y</c>) your sprites so that they overlap, you'll see that your new sprite is drawn on top of the older one. That's because sprites are drawn in the order in which they appear in the [[SpriteDisplay.sprites|sprites list]] of the [[SpriteDisplay]].

=== 3. Extract an image from a sprite sheet ===

Often you have multiple sprite images arranged in one bigger image file, called a '''sprite sheet''' or '''sprite atlas'''. You can pull apart such a sprite sheet by using the [[Image.getImage]] function. Let's try:

<ms>enemies = file.loadImage("/sys/pics/Enemies.png")
view enemies</ms>

This loads and displays [https://github.com/JoeStrout/minimicro-sysdisk/blob/master/sys/pics/Enemies.png?raw=true this big image], which contains a number of platformer enemies, in a 128x128 pixel grid. Let's make a sprite out of the top-left image. Keep in mind that coordinates in Mini Micro go from the bottom-left corner, so that top image starts at 128 * 3 = 384.

<ms>goob = new Sprite
goob.image = enemies.getImage(0, 384, 128, 128)
display(4).sprites.push goob</ms>

This creates a new sprite called <c>goob</c>, assigns it an image from our <c>enemies</c> sprite sheet, and pushes it onto the display. As always, it starts out in the bottom-left corner, but you know how to adjust that by now. Since this sprite is a bit bigger than it probably needs to be, also try <c>goob.scale = 0.5</c> to shrink it down.

== Play a sound ==

Almost any game needs [[sound]] effects! Mini Micro supports both playing both digitized sounds loaded from a file, and sounds synthesized at runtime. We'll focus here on playing sounds from a file, which can be in either WAV or OGG format.

=== 1. Play one of the built-in sounds ===

Enter <c>clear</c> to clear the screen, then try this:

<ms>snd = file.loadSound("/sys/sounds/twinkle.wav")
snd.play</ms>

You should hear a twinkle sound. The [[Sound.play]] method supports several optional parameters. A handy trick when you need a quick reminder of function parameters is to use [[@]] (the at-sign) before a function reference, to return the function without invoking it. On the command line, that will print the function parameter names and default values. Try it:

<ms>@snd.play</ms>
which prints:
<ms>FUNCTION(self, volume=1, pan=0, speed=1)</ms>

So let's try some variations on the sound. (In the code below, we're using <c>//</c> to add a [[Comments|comment]] on each line; you don't have to type these, but you can if you like.)

<ms>snd.play 0.1 // play very quietly
snd.play 1, -1 // play out the left speaker only
snd.play 1, 0, 2 // play twice as fast (an octave higher)
snd.play 1, 0, 0.5 // play half as fast (an octave lower)</ms>

=== 2. Play your own custom sound ===

Put a sound file in WAV or OGG format into your project folder. (On some platforms you can also use MP3 format, but that doesn't work everywhere and so is best to avoid if you plan to distribute your game.) Let's suppose your file is called "bgm.ogg". Load and play it just as above:

<ms>snd2 = file.loadSound("bgm.ogg")
snd2.play</ms>

If your sound is very long, and you want to stop it, you can just do <c>snd2.stop</c>. Or you can use <c>Sound.stopAll</c> to stop all sounds.

Before we move on, let's make this sound loop forever, as you might want background music to do:

<ms>snd2.loop = true
snd2.play</ms>

Again, use <c>snd2.stop</c> to make it stop, or <c>Sound.stopAll</c> to stop all sounds. (The <c>reset</c> command will also do that, in addition to clearing the current program and variables.)

=== 3. About synthesized sounds ===

Mini Micro has a sophisticated API for creating sounds out of nothing but code. You can specify a base waveform, frequency, envelope, fade-in/fade-out, and even mix basic sounds together to create more sophisticated sounds. You can find a couple of simple examples on the [[Sound.init]] page, and some more complex ones by doing <c>run "/sys/lib/sounds"</c> (followed by <c>edit</c> to see how those examples were made).

== Write a program ==

Typing commands directly on the command line is a great way to learn, explore, and test things out. But to write more than a few lines, you'll want to use a code editor. Assuming you've mounted a folder (rather than a minidisk file), you have two options: the built-in code editor, or an external code editor.

=== Method 1: Use the built-in code editor ===

The [[Mini Micro code editor]] is invoked with the <c>edit</c> command. Just type <c>edit</c> by itself to edit the currently loaded program (or start a new program, if none is loaded). Or, you can add a filename argument, like <c>edit "myGame"</c>, to [[load]] a different program and open the editor in one step.

Note that once a program is loaded, if you want to start a new program, use [[reset]] to clear the current program and variables.

The built-in code editor is full-featured and powerful, including auto-indenting, code snippets, a color picker for color constants, and a sophisticated find/replace dialog. See [[Mini Micro code editor|this page]] for usage details.

=== Method 2: Use an external code editor ===

When you have mounted a real folder as your <c>/usr</c> (or <c>/usr2</c>) disk, then you can edit MiniScript files therein using your favorite code editor, outside of Mini Micro. On the [[Tools]] page you can even find language models for editors like VS Code or BBEdit, to provide MiniScript-savvy syntax coloring.

When you edit code in this way, you will need to reload the program from disk in Mini Micro to see your changes. It's also generally a good idea to <c>reset</c> the environment before running the new code, so that old function definitions or other variable values don't inadvertently change the behavior. So after externally editing a script called "myGame.ms", do:

<ms>reset; run "myGame"</ms>

in Mini Micro. (And once you've done this once, you can generally just up-arrow to recall and repeat this command again the next time.)

=== A simple game demo ===

Using either method above, create a new MiniScript program called "ufo.ms", and paste in the following. (Or to learn even faster, retype it instead of using copy & paste.)

<ms>// prepare displays
clear
sd = display(4) // sprite display

// prepare UFO sprite and other resources
ufo = new Sprite
ufo.image = file.loadImage("/sys/pics/UFO.png")
sd.sprites.push ufo
ufo.x = 480; ufo.y = 320

fireSound = file.loadSound("/sys/sounds/blam.wav")

// allow alternate "fire" buttons
fireButtons = ["space", "left shift", "right shift",
"joystick button 0", "joystick button 1"]
firePressed = function
for btn in fireButtons
if key.pressed(btn) then return true
end for
return false
end function

// function to "fire" (play a sound)
fire = function
fireSound.play
end function

// main loop
fireWasPressed = false
while true
yield // wait for next frame

// move the UFO
ufo.x += key.axis("Horizontal") * 20
ufo.y += key.axis("Vertical") * 20

// fire, when fire button goes down
fireNowPressed = firePressed
if fireNowPressed and not fireWasPressed then fire
fireWasPressed = fireNowPressed
end while</ms>

This creates a simple game demo which allows you to move a UFO around the screen using the arrow keys, WASD, or a game controller (which all feed into <c>[[key.axis]]</c>). And when you press any of several keys (including joystick/gamepad button 0 or 1), it plays a sound.

Try changing the UFO sprite to your own custom sprite, and changing the fire sound to your own sound. That will verify that you're able to get your own assets working in Mini Micro in a custom game program. Then start playing around with the code. Some things to try:

* Limit the sprite position so it can't go offscreen
* Add some sort of target, as in <c>/sys/demo/spriteDemo</c>
* Make the sprite drop/fire a second sprite when the fire button is pressed

== Package your game for the web ==

If you've come here because you want to make a Mini Micro game for a game jam, then you should almost certainly learn how to package your game for playing on the web, and upload it to a site like itch.io.

This process is described in detail on [[How to package a Mini Micro game]]. Focus on the general instructions at the top, and the "packaging for the web" instructions at the bottom.

== Where to learn more ==

Congratulations! You have learned how to set up a local Mini Micro environment for development, using your own game assets, and learned to use both the built-in and external code editors. You've made a very simple game demo, and know how to upload it to the web. All toolchain hurdles are behind you; now it's just a matter of designing a game, and writing the code!

If you are a Python or Lua programmer, see the [[Python]] or [[Lua]] page of this wiki to see how MiniScript compares to those.

When writing the code, you will probably lean most heavily on these resources:

* The [https://miniscript.org/files/MiniMicro-CheatSheet.pdf Mini Micro Cheat Sheet], a 4-page summary of the Mini Micro API and MiniScript language
* This wiki, especially the [[How To]] articles
* Sample code found in <c>/sys/demo</c>
* Various blog posts, perhaps found through the [[Bibliography]] page

Most important of all, rely on the '''community Discord server''', a link to which can be found at the bottom of the [https://miniscript.org/ MiniScript home page]. An active and friendly community hangs out on Discord, and you are encouraged to share screenshots, code snippets, and questions there.

[[Category:Mini Micro]]
[[Category:How To]]

TileDisplay.cellTransform

2024-11-25T02:56:20Z

JoeStrout: Created page with "Mini Micro version 1.2.2 introduced the ability to transform (flip and/or rotate) individual tiles in a TileDisplay. The value returned by <c>TileDisplay.cellTransform</c..."

[[Mini Micro]] version 1.2.2 introduced the ability to transform (flip and/or rotate) individual tiles in a TileDisplay. The value returned by <c>TileDisplay.cellTransform</c>, or given to <c>TileDisplay.setCellTransform</c>, is an integer from 0-7. Values 0-3 rotate the tile in 90° increments. Values 4-7 first flip the tile horizontally, and then rotate it in 90° increments.

[[File:CellTransform.png|frameless|center]]

[[Category:Mini Micro]]

File:CellTransform.png

2024-11-25T02:55:11Z

JoeStrout:

Diagram illustrating the eight transforms available via TileDisplay.setCellTransform.

Apps using MiniScript

2024-11-23T03:41:45Z

JoeStrout:

TextDisplay

2024-11-13T23:42:09Z

JoeStrout:

The <c>TextDisplay</c> class in [[Mini Micro]] is a display type that represents a 68-column, 26-row text character display. Each row/column position in this display is called a "cell" and may display one character, with any foreground and background color (including transparent colors).

[[File:TextDisplay.png|682px|frameless|center|Illustration of the Mini Micro text display: 26 rows by 68 columns.]]

By default, [[display]] 3 is configured as a text display, and is in fact the main text display on which [[print]] and [[input]] operate, and to which the [[text]] global refers (unless you change it). But you can make any display layer a text display by setting its [[Display.mode|mode]] to <c>displayMode.text</c>.

There are two ways to put text into a text display: use the [[TextDisplay.print]] method, which applies the current values of [[TextDisplay.color]], etc.; or set individual cells with [[TextDisplay.setCell]], [[TextDisplay.setCellColor]], etc.

== Methods and Properties ==

{| class="wikitable"
|-
! Method or Property !! Purpose
|-
| [[TextDisplay.color]] || get or set the text color (used on subsequent [[TextDisplay.print]])
|-
| [[TextDisplay.backColor]] || get or set the background color (used on subsequent [[TextDisplay.print]])
|-
| [[TextDisplay.column]] || get/set the cursor column, 0-67 (where subsequent [[TextDisplay.print]] begins)
|-
| [[TextDisplay.row]] || get or set the cursor row, 0-25 (used on subsequent [[TextDisplay.print]])
|-
| [[TextDisplay.inverse]] || when true, subsequent printing swaps text and background color
|-
| [[TextDisplay.delimiter]] || get/set the extra character output after every [[TextDisplay.print]])
|-
| [[TextDisplay.cell]](''x'', ''y'') || get the character at the given column and row
|-
| [[TextDisplay.setCell]] ''x'', ''y'', k || store character ''k'' into the given column and row
|-
| [[TextDisplay.cellColor]](''x'', ''y'') || get the text color at the given column and row
|-
| [[TextDisplay.setCellColor]] ''x'', ''y'', c || set the text color at the given column and row to ''c''
|-
| [[TextDisplay.cellBackColor]](''x'', ''y'') || get the background color at the given column and row
|-
| [[TextDisplay.setCellBackColor]] ''x'', ''y'', c || set the background color at the given column and row to ''c''
|-
| [[TextDisplay.print]] ''s'' || print string ''s'' (followed by the [[TextDisplay.delimiter|delimiter]])
|-
| [[TextDisplay.clear]] || clear the text display
|}

== TextDisplay in Farmtronics ==

The [[Farmtronics]] computer also has a TextDisplay, but it is only 20 rows by 40 columns. Moreover, there is only ''one'' TextDisplay, unlike Mini Micro, which can have any number of them.

[[Category:Mini Micro]]
[[Category:Farmtronics]]

How to get started with Mini Micro

2024-10-10T14:05:22Z

JoeStrout: /* Where to learn more */

[https://miniscript.org/MiniMicro/ Mini Micro] is a popular environment for creating 2D games and demos in MiniScript. It is a retro-style virtual computer, which runs on most desktop platforms. Mini Micro games can be [[How to package a Mini Micro game|packaged]] as stand-alone games for desktop or the web.

This page is meant for people who have never used Mini Micro before, but want to make a Mini Micro game. It is a step-by-step guide to building your first simple demo involving a sprite, game input, and sound effects, including your own resources, as quickly as possible.

== Get Mini Micro ==

While you can run Mini Micro on the web, the web version has no ability to save files (nor does it support copy/paste). So it's not useful for developing your own Mini Micro games.

Go to the [https://miniscript.org/MiniMicro/#download Mini Micro download] page, click the button for your platform (Mac, Windows, or Linux), and save the resulting file to your local machine. (If you don't have a Mac, Windows, or Linux desktop machine, then unfortunately you can't use Mini Micro yet, though iOS and Android versions are under development.)

The downloaded file will be a .zip (Mac/Windows) or .tar.gz (Linux) file. ''Unpack this file completely.'' Don't try to run Mini Micro from ''within'' the archive; extract all files to a real folder on your hard drive.

Then, find the Mini Micro application in that folder. Double-click it to launch Mini Micro. The result should look like this.

[[File:MiniMicro.png|thumb|center]]

== Mount a folder as /usr ==

Mini Micro can access two virtual "disks" at once; within the Mini Micro environment, these are accessed as <c>/usr</c> and <c>/usr2</c>. Each of these can be either a '''.minidisk file''', or a '''real folder''' on the host (desktop) system. Out of the box, Mini Micro creates an empty .minidisk file for you, to keep things nice and neat. But for any serious development, you're going to want to mount a real folder instead, so that you can easily move files in and out of this folder, use your favorite external image/sound editors, etc.

Create a folder on your desktop system, wherever you normally keep your documents. This will be your project folder for your first Mini Micro game. Put a small text file, image (in PNG or JPEG format), or sound file (in WAV or OGG format) in there. Our goal now is to see and view this file (and any others in that folder or its subfolders) in Mini Micro.

=== Method 1: Use the disk slot menu ===

Those two thin dark rectangles in the bottom-left corner of the Mini Micro window are "disk slots." The top slot represents <c>/usr</c>, and the bottom slot represents <c>/usr2</c>. Click the top slot to pop open the menu, and select the "Mount Folder..." command.

[[File:MountFolder.png|frameless|center]]

Selecting that command should bring up the native file dialog for your platform, allowing you to select any folder you have access to. Pick the project folder you created above. (Note: some Linux platforms have a bug which crashes Mini Micro at this point; if that happens to you, go on to Method 2.)

Now, in the Mini Micro display, at the blinking orange prompt, type:

<ms>dir</ms>

and press Return or Enter. You should see your file listed. Now try:

<ms>view "myfile.txt"</ms>

but replace ''myfile.txt'' with the name of whatever file you placed in your project folder. Be sure to include the quotation marks; you're typing MiniScript code here, not some other shell language, so string literals always need to be surrounded by double quotes. If you do it correctly, the contents of your text file or image should appear on the screen.

(You could also do <c>view findFile</c>, which would pop up the little file browser within the [[findFile]] command, and select your file that way.)

Note that the currently mounted disk is saved in preferences, so if you quit and relaunch Mini Micro, you generally won't need to do this step again; the previously mounted disks will still be there.

=== Method 2: Use command-line arguments ===

If you are unfortunate enough to hit that Linux bug which causes the file dialogs to crash, or for some other reason you want to launch Mini Micro from the command line (or a shell script) with the correct folder already mounted, then you can use [[Command-line arguments|command-line arguments]] instead. Open your favorite terminal program, and navigate to where the Mini Micro executable is located. The details vary by platform, so let's break it down:

'''Linux'''

In Linux, the executable is called '''MiniMicro.x86_64''', so you would type a command like this:

<ms>./MiniMicro.x86_64 -usr ~/mmdev</ms>

Replace <c>~/mmdev</c> with the path to your project folder.

'''Windows'''

In Windows, you can open the command prompt by pressing '''Win + R''' to open the Run dialog, and entering ''cmd''. (If you already have some other preferred terminal app, like PowerShell, that's fine too.) Then <c>cd</c> to the directory containing Mini Micro. The executable here is called '''Mini Micro.exe''', so you would use a command like:

<ms>"Mini Micro.exe" -usr "%HOMEPATH%\mmdev</ms>

Replace <c>%HOMEPATH%\mmdev</c> with the path to your project folder.

'''MacOS'''

On Mac, the actual executable is hidden inside the application bundle, specifically under Contents/MacOS. So if you've already launched Terminal and navigated to where '''MiniMicro.app''' is found, then you would do

<ms>Contents/MacOS/Mini\ Micro -usr ~/Documents/mmdev</ms>

Replace <c>~/Documents/mmdev</c> with the path to your project folder.

If successful (on any platform), you should be able to use the <c>dir</c> and <c>view</c> commands to view the file in your project folder within the Mini Micro environment.

== Create a sprite ==

Now let's get a sprite up on the screen. We're going to do this using the Mini Micro command line (or [[REPL]]), where you type a command and executes immediately. We'll get to writing real programs later, but the command-line is a powerful tool for learning and exploring, so let's use it.

=== 1. Make a sprite from the built-in images ===

At the orange blinking-cursor prompt in Mini Micro, carefully type the following:

<ms>clear
sp = new Sprite
sp.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push sp</ms>

You should see a furry purple Wumpus peeking out from the lower-left corner of the screen (which is the origin of Mini Micro's [[Screen coordinates|coordinate system]]).

[[File:ManualSprite.png|thumb]]

If you don't see this, go back and double-check your typing. Note that you can recall a previous command on the command line by pressing the '''up-arrow'' key, then just edit it and press Return to run the edited command.

How does this work? Let's break it down:

# <c>[[clear]]</c> clears the screen and resets all eight display layers to their default states. This includes setting display 4 to be a [[SpriteDisplay]]. (That's the default state when Mini Micro boots, but useful whenever your screen is cluttered anyway.)
# <c>sp = new Sprite</c> creates a new [[Sprite]] object, and assigns it to a variable called <c>sp</c>.
# <c>sp.image = file.loadImage("/sys/pics/Wumpus.png")</c> loads an image called "Wumpus.png" from the <c>/sys/pics</c> directory. (Notice that Mini Micro uses forward-slashes in file paths, even if the host system is Windows.)
# <c>display(4).sprites.push sp</c> pushes this new sprite onto the sprite list of display 4, so it can be seen.

Once you have the Wumpus peeking out of the corner, let's move it and rotate it a bit. Notice how the sprite updates immediately after each command.

<ms>sp.x = 480
sp.y = 320
sp.rotation = 45</ms>

=== 2. Make a sprite from your own custom image ===

The Wumpus sprite above was created from one of the built-in images that comes with Mini Micro. There are hundreds of these, stored on a hidden, read-only disk mounted as <c>/sys</c>. Feel free to use the <c>findFile</c> command to explore what's there.

But for your own game, you're probably going to want to use your own custom sprites. So, put an image in PNG format into your project directory (the one you mounted as <c>/usr</c>). Use the <c>pwd</c> (print working directory) and <c>cd</c> (change directory) commands to be sure you are in your <c>/usr</c> directory. Then use the <c>dir</c> and <c>view</c> commands to ensure that you can see and load your user file.

Now, just repeat the commands you did to create a sprite above, but substitute the path to your custom image.

<ms>sp = new Sprite
sp.image = file.loadImage("myCustomImage.png")
display(4).sprites.push sp</ms>

If you haven't [[clear]]ed the display since step 1, then you'll see your new sprite ''and'' the Wumpus on screen at the same time. And if you now move (by assigning to <c>.x</c> and <c>.y</c>) your sprites so that they overlap, you'll see that your new sprite is drawn on top of the older one. That's because sprites are drawn in the order in which they appear in the [[SpriteDisplay.sprites|sprites list]] of the [[SpriteDisplay]].

=== 3. Extract an image from a sprite sheet ===

Often you have multiple sprite images arranged in one bigger image file, called a '''sprite sheet''' or '''sprite atlas'''. You can pull apart such a sprite sheet by using the [[Image.getImage]] function. Let's try:

<ms>enemies = file.loadImage("/sys/pics/Enemies.png")
view enemies</ms>

This loads and displays [https://github.com/JoeStrout/minimicro-sysdisk/blob/master/sys/pics/Enemies.png?raw=true this big image], which contains a number of platformer enemies, in a 128x128 pixel grid. Let's make a sprite out of the top-left image. Keep in mind that coordinates in Mini Micro go from the bottom-left corner, so that top image starts at 128 * 3 = 384.

<ms>goob = new Sprite
goob.image = enemies.getImage(0, 384, 128, 128)
display(4).sprites.push goob</ms>

This creates a new sprite called <c>goob</c>, assigns it an image from our <c>enemies</c> sprite sheet, and pushes it onto the display. As always, it starts out in the bottom-left corner, but you know how to adjust that by now. Since this sprite is a bit bigger than it probably needs to be, also try <c>goob.scale = 0.5</c> to shrink it down.

== Play a sound ==

Almost any game needs [[sound]] effects! Mini Micro supports both playing both digitized sounds loaded from a file, and sounds synthesized at runtime. We'll focus here on playing sounds from a file, which can be in either WAV or OGG format.

=== 1. Play one of the built-in sounds ===

Enter <c>clear</c> to clear the screen, then try this:

<ms>snd = file.loadSound("/sys/sounds/twinkle.wav")
snd.play</ms>

You should hear a twinkle sound. The [[Sound.play]] method supports several optional parameters. A handy trick when you need a quick reminder of function parameters is to use [[@]] (the at-sign) before a function reference, to return the function without invoking it. On the command line, that will print the function parameter names and default values. Try it:

<ms>@snd.play</ms>
which prints:
<ms>FUNCTION(self, volume=1, pan=0, speed=1)</ms>

So let's try some variations on the sound. (In the code below, we're using <c>//</c> to add a [[Comments|comment]] on each line; you don't have to type these, but you can if you like.)

<ms>snd.play 0.1 // play very quietly
snd.play 1, -1 // play out the left speaker only
snd.play 1, 0, 2 // play twice as fast (an octave higher)
snd.play 1, 0, 0.5 // play half as fast (an octave lower)</ms>

=== 2. Play your own custom sound ===

Put a sound file in WAV or OGG format into your project folder. (On some platforms you can also use MP3 format, but that doesn't work everywhere and so is best to avoid if you plan to distribute your game.) Let's suppose your file is called "bgm.ogg". Load and play it just as above:

<ms>snd2 = file.loadSound("bgm.ogg")
snd2.play</ms>

If your sound is very long, and you want to stop it, you can just do <c>snd2.stop</c>. Or you can use <c>Sound.stopAll</c> to stop all sounds.

Before we move on, let's make this sound loop forever, as you might want background music to do:

<ms>snd2.loop = true
snd2.play</ms>

Again, use <c>snd2.stop</c> to make it stop, or <c>Sound.stopAll</c> to stop all sounds. (The <c>reset</c> command will also do that, in addition to clearing the current program and variables.)

=== 3. About synthesized sounds ===

Mini Micro has a sophisticated API for creating sounds out of nothing but code. You can specify a base waveform, frequency, envelope, fade-in/fade-out, and even mix basic sounds together to create more sophisticated sounds. You can find a couple of simple examples on the [[Sound.init]] page, and some more complex ones by doing <c>run "/sys/lib/sounds"</c> (followed by <c>edit</c> to see how those examples were made).

== Write a program ==

Typing commands directly on the command line is a great way to learn, explore, and test things out. But to write more than a few lines, you'll want to use a code editor. Assuming you've mounted a folder (rather than a minidisk file), you have two options: the built-in code editor, or an external code editor.

=== Method 1: Use the built-in code editor ===

The [[Mini Micro code editor]] is invoked with the <c>edit</c> command. Just type <c>edit</c> by itself to edit the currently loaded program (or start a new program, if none is loaded). Or, you can add a filename argument, like <c>edit "myGame"</c>, to [[load]] a different program and open the editor in one step.

Note that once a program is loaded, if you want to start a new program, use [[reset]] to clear the current program and variables.

The built-in code editor is full-featured and powerful, including auto-indenting, code snippets, a color picker for color constants, and a sophisticated find/replace dialog. See [[Mini Micro code editor|this page]] for usage details.

=== Method 2: Use an external code editor ===

When you have mounted a real folder as your <c>/usr</c> (or <c>/usr2</c>) disk, then you can edit MiniScript files therein using your favorite code editor, outside of Mini Micro. On the [[Tools]] page you can even find language models for editors like VS Code or BBEdit, to provide MiniScript-savvy syntax coloring.

When you edit code in this way, you will need to reload the program from disk in Mini Micro to see your changes. It's also generally a good idea to <c>reset</c> the environment before running the new code, so that old function definitions or other variable values don't inadvertently change the behavior. So after externally editing a script called "myGame.ms", do:

<ms>reset; run "myGame"</ms>

in Mini Micro. (And once you've done this once, you can generally just up-arrow to recall and repeat this command again the next time.)

=== A simple game demo ===

Using either method above, create a new MiniScript program called "ufo.ms", and paste in the following. (Or to learn even faster, retype it instead of using copy & paste.)

<ms>// prepare displays
clear
sd = display(4) // sprite display

// prepare UFO sprite and other resources
ufo = new Sprite
ufo.image = file.loadImage("/sys/pics/UFO.png")
sd.sprites.push ufo
ufo.x = 480; ufo.y = 320

fireSound = file.loadSound("/sys/sounds/blam.wav")

// allow alternate "fire" buttons
fireButtons = ["space", "left shift", "right shift",
"joystick button 0", "joystick button 1"]
firePressed = function
for btn in fireButtons
if key.pressed(btn) then return true
end for
return false
end function

// function to "fire" (play a sound)
fire = function
fireSound.play
end function

// main loop
fireWasPressed = false
while true
yield // wait for next frame

// move the UFO
ufo.x += key.axis("Horizontal") * 20
ufo.y += key.axis("Vertical") * 20

// fire, when fire button goes down
fireNowPressed = firePressed
if fireNowPressed and not fireWasPressed then fire
fireWasPressed = fireNowPressed
end while</ms>

This creates a simple game demo which allows you to move a UFO around the screen using the arrow keys, WASD, or a game controller (which all feed into <c>[[key.axis]]</c>). And when you press any of several keys (including joystick/gamepad button 0 or 1), it plays a sound.

Try changing the UFO sprite to your own custom sprite, and changing the fire sound to your own sound. That will verify that you're able to get your own assets working in Mini Micro in a custom game program. Then start playing around with the code. Some things to try:

* Limit the sprite position so it can't go offscreen
* Add some sort of target, as in <c>/sys/demo/spriteDemo</c>
* Make the sprite drop/fire a second sprite when the fire button is pressed

== Package your game for the web ==

If you've come here because you want to make a Mini Micro game for a game jam, then you should almost certainly learn how to package your game for playing on the web, and upload it to a site like itch.io.

This process is described in detail on [[How to package a Mini Micro game]]. Focus on the general instructions at the top, and the "packaging for the web" instructions at the bottom.

== Where to learn more ==

Congratulations! You have learned how to set up a local Mini Micro environment for development, using your own game assets, and learned to use both the built-in and external code editors. You've made a very simple game demo, and know how to upload it to the web. All toolchain hurdles are behind you; now it's just a matter of designing a game, and writing the code!

If you are a Python or Lua programmer, see the [[Python]] or [[Lua]] page of this wiki to see how MiniScript compares to those.

When writing the code, you will probably lean most heavily on these resources:

* The [https://miniscript.org/files/MiniMicro-CheatSheet.pdf Mini Micro Cheat Sheet], a 4-page summary of the Mini Micro API and MiniScript language
* This wiki, especially the [[How To]] articles
* Sample code found in <c>/sys/demo</c>
* Various blog posts, perhaps found through the [[Bibliography]] page

Most important of all, rely on the '''community Discord server''', a link to which can be found at the bottom of the [https://miniscript.org/ MiniScript home page]. An active and friendly community hangs out on Discord, and you are encouraged to share screenshots, code snippets, and questions there.

[[Category:Mini Micro]]
[[Category:How To]]

How to get started with Mini Micro

2024-10-10T14:03:26Z

JoeStrout: /* Play a sound */

[https://miniscript.org/MiniMicro/ Mini Micro] is a popular environment for creating 2D games and demos in MiniScript. It is a retro-style virtual computer, which runs on most desktop platforms. Mini Micro games can be [[How to package a Mini Micro game|packaged]] as stand-alone games for desktop or the web.

This page is meant for people who have never used Mini Micro before, but want to make a Mini Micro game. It is a step-by-step guide to building your first simple demo involving a sprite, game input, and sound effects, including your own resources, as quickly as possible.

== Get Mini Micro ==

While you can run Mini Micro on the web, the web version has no ability to save files (nor does it support copy/paste). So it's not useful for developing your own Mini Micro games.

Go to the [https://miniscript.org/MiniMicro/#download Mini Micro download] page, click the button for your platform (Mac, Windows, or Linux), and save the resulting file to your local machine. (If you don't have a Mac, Windows, or Linux desktop machine, then unfortunately you can't use Mini Micro yet, though iOS and Android versions are under development.)

The downloaded file will be a .zip (Mac/Windows) or .tar.gz (Linux) file. ''Unpack this file completely.'' Don't try to run Mini Micro from ''within'' the archive; extract all files to a real folder on your hard drive.

Then, find the Mini Micro application in that folder. Double-click it to launch Mini Micro. The result should look like this.

[[File:MiniMicro.png|thumb|center]]

== Mount a folder as /usr ==

Mini Micro can access two virtual "disks" at once; within the Mini Micro environment, these are accessed as <c>/usr</c> and <c>/usr2</c>. Each of these can be either a '''.minidisk file''', or a '''real folder''' on the host (desktop) system. Out of the box, Mini Micro creates an empty .minidisk file for you, to keep things nice and neat. But for any serious development, you're going to want to mount a real folder instead, so that you can easily move files in and out of this folder, use your favorite external image/sound editors, etc.

Create a folder on your desktop system, wherever you normally keep your documents. This will be your project folder for your first Mini Micro game. Put a small text file, image (in PNG or JPEG format), or sound file (in WAV or OGG format) in there. Our goal now is to see and view this file (and any others in that folder or its subfolders) in Mini Micro.

=== Method 1: Use the disk slot menu ===

Those two thin dark rectangles in the bottom-left corner of the Mini Micro window are "disk slots." The top slot represents <c>/usr</c>, and the bottom slot represents <c>/usr2</c>. Click the top slot to pop open the menu, and select the "Mount Folder..." command.

[[File:MountFolder.png|frameless|center]]

Selecting that command should bring up the native file dialog for your platform, allowing you to select any folder you have access to. Pick the project folder you created above. (Note: some Linux platforms have a bug which crashes Mini Micro at this point; if that happens to you, go on to Method 2.)

Now, in the Mini Micro display, at the blinking orange prompt, type:

<ms>dir</ms>

and press Return or Enter. You should see your file listed. Now try:

<ms>view "myfile.txt"</ms>

but replace ''myfile.txt'' with the name of whatever file you placed in your project folder. Be sure to include the quotation marks; you're typing MiniScript code here, not some other shell language, so string literals always need to be surrounded by double quotes. If you do it correctly, the contents of your text file or image should appear on the screen.

(You could also do <c>view findFile</c>, which would pop up the little file browser within the [[findFile]] command, and select your file that way.)

Note that the currently mounted disk is saved in preferences, so if you quit and relaunch Mini Micro, you generally won't need to do this step again; the previously mounted disks will still be there.

=== Method 2: Use command-line arguments ===

If you are unfortunate enough to hit that Linux bug which causes the file dialogs to crash, or for some other reason you want to launch Mini Micro from the command line (or a shell script) with the correct folder already mounted, then you can use [[Command-line arguments|command-line arguments]] instead. Open your favorite terminal program, and navigate to where the Mini Micro executable is located. The details vary by platform, so let's break it down:

'''Linux'''

In Linux, the executable is called '''MiniMicro.x86_64''', so you would type a command like this:

<ms>./MiniMicro.x86_64 -usr ~/mmdev</ms>

Replace <c>~/mmdev</c> with the path to your project folder.

'''Windows'''

In Windows, you can open the command prompt by pressing '''Win + R''' to open the Run dialog, and entering ''cmd''. (If you already have some other preferred terminal app, like PowerShell, that's fine too.) Then <c>cd</c> to the directory containing Mini Micro. The executable here is called '''Mini Micro.exe''', so you would use a command like:

<ms>"Mini Micro.exe" -usr "%HOMEPATH%\mmdev</ms>

Replace <c>%HOMEPATH%\mmdev</c> with the path to your project folder.

'''MacOS'''

On Mac, the actual executable is hidden inside the application bundle, specifically under Contents/MacOS. So if you've already launched Terminal and navigated to where '''MiniMicro.app''' is found, then you would do

<ms>Contents/MacOS/Mini\ Micro -usr ~/Documents/mmdev</ms>

Replace <c>~/Documents/mmdev</c> with the path to your project folder.

If successful (on any platform), you should be able to use the <c>dir</c> and <c>view</c> commands to view the file in your project folder within the Mini Micro environment.

== Create a sprite ==

Now let's get a sprite up on the screen. We're going to do this using the Mini Micro command line (or [[REPL]]), where you type a command and executes immediately. We'll get to writing real programs later, but the command-line is a powerful tool for learning and exploring, so let's use it.

=== 1. Make a sprite from the built-in images ===

At the orange blinking-cursor prompt in Mini Micro, carefully type the following:

<ms>clear
sp = new Sprite
sp.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push sp</ms>

You should see a furry purple Wumpus peeking out from the lower-left corner of the screen (which is the origin of Mini Micro's [[Screen coordinates|coordinate system]]).

[[File:ManualSprite.png|thumb]]

If you don't see this, go back and double-check your typing. Note that you can recall a previous command on the command line by pressing the '''up-arrow'' key, then just edit it and press Return to run the edited command.

How does this work? Let's break it down:

# <c>[[clear]]</c> clears the screen and resets all eight display layers to their default states. This includes setting display 4 to be a [[SpriteDisplay]]. (That's the default state when Mini Micro boots, but useful whenever your screen is cluttered anyway.)
# <c>sp = new Sprite</c> creates a new [[Sprite]] object, and assigns it to a variable called <c>sp</c>.
# <c>sp.image = file.loadImage("/sys/pics/Wumpus.png")</c> loads an image called "Wumpus.png" from the <c>/sys/pics</c> directory. (Notice that Mini Micro uses forward-slashes in file paths, even if the host system is Windows.)
# <c>display(4).sprites.push sp</c> pushes this new sprite onto the sprite list of display 4, so it can be seen.

Once you have the Wumpus peeking out of the corner, let's move it and rotate it a bit. Notice how the sprite updates immediately after each command.

<ms>sp.x = 480
sp.y = 320
sp.rotation = 45</ms>

=== 2. Make a sprite from your own custom image ===

The Wumpus sprite above was created from one of the built-in images that comes with Mini Micro. There are hundreds of these, stored on a hidden, read-only disk mounted as <c>/sys</c>. Feel free to use the <c>findFile</c> command to explore what's there.

But for your own game, you're probably going to want to use your own custom sprites. So, put an image in PNG format into your project directory (the one you mounted as <c>/usr</c>). Use the <c>pwd</c> (print working directory) and <c>cd</c> (change directory) commands to be sure you are in your <c>/usr</c> directory. Then use the <c>dir</c> and <c>view</c> commands to ensure that you can see and load your user file.

Now, just repeat the commands you did to create a sprite above, but substitute the path to your custom image.

<ms>sp = new Sprite
sp.image = file.loadImage("myCustomImage.png")
display(4).sprites.push sp</ms>

If you haven't [[clear]]ed the display since step 1, then you'll see your new sprite ''and'' the Wumpus on screen at the same time. And if you now move (by assigning to <c>.x</c> and <c>.y</c>) your sprites so that they overlap, you'll see that your new sprite is drawn on top of the older one. That's because sprites are drawn in the order in which they appear in the [[SpriteDisplay.sprites|sprites list]] of the [[SpriteDisplay]].

=== 3. Extract an image from a sprite sheet ===

Often you have multiple sprite images arranged in one bigger image file, called a '''sprite sheet''' or '''sprite atlas'''. You can pull apart such a sprite sheet by using the [[Image.getImage]] function. Let's try:

<ms>enemies = file.loadImage("/sys/pics/Enemies.png")
view enemies</ms>

This loads and displays [https://github.com/JoeStrout/minimicro-sysdisk/blob/master/sys/pics/Enemies.png?raw=true this big image], which contains a number of platformer enemies, in a 128x128 pixel grid. Let's make a sprite out of the top-left image. Keep in mind that coordinates in Mini Micro go from the bottom-left corner, so that top image starts at 128 * 3 = 384.

<ms>goob = new Sprite
goob.image = enemies.getImage(0, 384, 128, 128)
display(4).sprites.push goob</ms>

This creates a new sprite called <c>goob</c>, assigns it an image from our <c>enemies</c> sprite sheet, and pushes it onto the display. As always, it starts out in the bottom-left corner, but you know how to adjust that by now. Since this sprite is a bit bigger than it probably needs to be, also try <c>goob.scale = 0.5</c> to shrink it down.

== Play a sound ==

Almost any game needs [[sound]] effects! Mini Micro supports both playing both digitized sounds loaded from a file, and sounds synthesized at runtime. We'll focus here on playing sounds from a file, which can be in either WAV or OGG format.

=== 1. Play one of the built-in sounds ===

Enter <c>clear</c> to clear the screen, then try this:

<ms>snd = file.loadSound("/sys/sounds/twinkle.wav")
snd.play</ms>

You should hear a twinkle sound. The [[Sound.play]] method supports several optional parameters. A handy trick when you need a quick reminder of function parameters is to use [[@]] (the at-sign) before a function reference, to return the function without invoking it. On the command line, that will print the function parameter names and default values. Try it:

<ms>@snd.play</ms>
which prints:
<ms>FUNCTION(self, volume=1, pan=0, speed=1)</ms>

So let's try some variations on the sound. (In the code below, we're using <c>//</c> to add a [[Comments|comment]] on each line; you don't have to type these, but you can if you like.)

<ms>snd.play 0.1 // play very quietly
snd.play 1, -1 // play out the left speaker only
snd.play 1, 0, 2 // play twice as fast (an octave higher)
snd.play 1, 0, 0.5 // play half as fast (an octave lower)</ms>

=== 2. Play your own custom sound ===

Put a sound file in WAV or OGG format into your project folder. (On some platforms you can also use MP3 format, but that doesn't work everywhere and so is best to avoid if you plan to distribute your game.) Let's suppose your file is called "bgm.ogg". Load and play it just as above:

<ms>snd2 = file.loadSound("bgm.ogg")
snd2.play</ms>

If your sound is very long, and you want to stop it, you can just do <c>snd2.stop</c>. Or you can use <c>Sound.stopAll</c> to stop all sounds.

Before we move on, let's make this sound loop forever, as you might want background music to do:

<ms>snd2.loop = true
snd2.play</ms>

Again, use <c>snd2.stop</c> to make it stop, or <c>Sound.stopAll</c> to stop all sounds. (The <c>reset</c> command will also do that, in addition to clearing the current program and variables.)

=== 3. About synthesized sounds ===

Mini Micro has a sophisticated API for creating sounds out of nothing but code. You can specify a base waveform, frequency, envelope, fade-in/fade-out, and even mix basic sounds together to create more sophisticated sounds. You can find a couple of simple examples on the [[Sound.init]] page, and some more complex ones by doing <c>run "/sys/lib/sounds"</c> (followed by <c>edit</c> to see how those examples were made).

== Write a program ==

Typing commands directly on the command line is a great way to learn, explore, and test things out. But to write more than a few lines, you'll want to use a code editor. Assuming you've mounted a folder (rather than a minidisk file), you have two options: the built-in code editor, or an external code editor.

=== Method 1: Use the built-in code editor ===

The [[Mini Micro code editor]] is invoked with the <c>edit</c> command. Just type <c>edit</c> by itself to edit the currently loaded program (or start a new program, if none is loaded). Or, you can add a filename argument, like <c>edit "myGame"</c>, to [[load]] a different program and open the editor in one step.

Note that once a program is loaded, if you want to start a new program, use [[reset]] to clear the current program and variables.

The built-in code editor is full-featured and powerful, including auto-indenting, code snippets, a color picker for color constants, and a sophisticated find/replace dialog. See [[Mini Micro code editor|this page]] for usage details.

=== Method 2: Use an external code editor ===

When you have mounted a real folder as your <c>/usr</c> (or <c>/usr2</c>) disk, then you can edit MiniScript files therein using your favorite code editor, outside of Mini Micro. On the [[Tools]] page you can even find language models for editors like VS Code or BBEdit, to provide MiniScript-savvy syntax coloring.

When you edit code in this way, you will need to reload the program from disk in Mini Micro to see your changes. It's also generally a good idea to <c>reset</c> the environment before running the new code, so that old function definitions or other variable values don't inadvertently change the behavior. So after externally editing a script called "myGame.ms", do:

<ms>reset; run "myGame"</ms>

in Mini Micro. (And once you've done this once, you can generally just up-arrow to recall and repeat this command again the next time.)

=== A simple game demo ===

Using either method above, create a new MiniScript program called "ufo.ms", and paste in the following. (Or to learn even faster, retype it instead of using copy & paste.)

<ms>// prepare displays
clear
sd = display(4) // sprite display

// prepare UFO sprite and other resources
ufo = new Sprite
ufo.image = file.loadImage("/sys/pics/UFO.png")
sd.sprites.push ufo
ufo.x = 480; ufo.y = 320

fireSound = file.loadSound("/sys/sounds/blam.wav")

// allow alternate "fire" buttons
fireButtons = ["space", "left shift", "right shift",
"joystick button 0", "joystick button 1"]
firePressed = function
for btn in fireButtons
if key.pressed(btn) then return true
end for
return false
end function

// function to "fire" (play a sound)
fire = function
fireSound.play
end function

// main loop
fireWasPressed = false
while true
yield // wait for next frame

// move the UFO
ufo.x += key.axis("Horizontal") * 20
ufo.y += key.axis("Vertical") * 20

// fire, when fire button goes down
fireNowPressed = firePressed
if fireNowPressed and not fireWasPressed then fire
fireWasPressed = fireNowPressed
end while</ms>

This creates a simple game demo which allows you to move a UFO around the screen using the arrow keys, WASD, or a game controller (which all feed into <c>[[key.axis]]</c>). And when you press any of several keys (including joystick/gamepad button 0 or 1), it plays a sound.

Try changing the UFO sprite to your own custom sprite, and changing the fire sound to your own sound. That will verify that you're able to get your own assets working in Mini Micro in a custom game program. Then start playing around with the code. Some things to try:

* Limit the sprite position so it can't go offscreen
* Add some sort of target, as in <c>/sys/demo/spriteDemo</c>
* Make the sprite drop/fire a second sprite when the fire button is pressed

== Package your game for the web ==

If you've come here because you want to make a Mini Micro game for a game jam, then you should almost certainly learn how to package your game for playing on the web, and upload it to a site like itch.io.

This process is described in detail on [[How to package a Mini Micro game]]. Focus on the general instructions at the top, and the "packaging for the web" instructions at the bottom.

== Where to learn more ==

Congratulations! You have learned how to set up a local Mini Micro environment for development, using your own game assets, and learned to use both the built-in and external code editors. You've made a very simple game demo, and know how to upload it to the web. All toolchain hurdles are behind you; now it's just a matter of designing a game, and writing the code!

If you are a Python or Lua programmer, see the [[Python]] or [[Lua]] page of this wiki to see how MiniScript compares to those.

When writing the code, you will probably lean most heavily on these resources:

* The [https://miniscript.org/files/MiniMicro-CheatSheet.pdf Mini Micro Cheat Sheet], a 4-page summary of the Mini Micro API and MiniScript language
* This wiki, especially the [[How To]] articles
* Sample code found in <c>/sys/demo</c>
* Various blog posts, perhaps found through the [[Bibliography]] page

Most important of all, rely on the '''community Discord server''', a link to which can be found at the bottom of the [https://miniscript.org/ MiniScript home page]. An active and friendly community hangs out here, and you are encouraged to share screenshots, code snippets, and questions there.

[[Category:Mini Micro]]
[[Category:How To]]

Python

2024-09-19T23:20:46Z

JoeStrout: /* Data Types */

Python is a popular scripting language that was first released in 1991. This article compares Python to MiniScript, and may be useful to people coming to MiniScript with a background in Python.

For a side-by-side comparison on a collection of short programs, see [https://miniscript.org/compare/python.html here].

== Similarities ==

=== Data Types ===

MiniScript's six data types have direct analogs to common types in Python:

* '''Numbers''' in MiniScript are double-precision floating point numbers, equivalent to Python's <c>numbers.Real</c> (aka <c>float</c>) data type. Note that in MiniScript, False and True are represented directly by the numbers 0 and 1; there is no separate <c>bool</c> type.

* '''Strings''' in both languages are an immutable sequence of Unicode code points. String literals in both languages can be enclosed in double-quotes; MiniScript does not have the optional single-quote or triple-quote syntax. While Python uses backslash-escaping to include a quotation mark within a literal, in MiniScript you just write the quotation mark twice, as in SQL.

* '''Lists''' in both languages are a mutable sequence of arbitrary values; a list literal uses square brackets surrounding comma-delimited values (see List Syntax, below). Note that MiniScript does not have a <c>tuple</c> type, and uses a list in situations where Python might use a tuple.

* '''Maps''' in both languages are mutable, unordered set of key-value pairs, with the same literal syntax (see Map Syntax and Object-Oriented Programming, below).

* '''Function objects''' in both languages are similar: first-class, callable objects. However functions in MiniScript have no attributes, and the syntax for defining functions is somewhat different.

* '''<c>None</c>''' in Python is called '''<c>null</c>''' in MiniScript — a special datatype in both languages, representing a null reference.

=== List Syntax ===

The syntax for list literals is the same in Python and MiniScript: a series of arbitrary values, separated by commas and surrounded by square brackets.

<ms>myList = ["apple", "banana", "cherry", "date"]</ms>

Index and slice syntax is also the same in both, except that MiniScript slicing supports only two parameters; it does not support the third (IndexJump) parameter.

<ms>myList[0] // "apple"
myList[:2] // ["apple", "banana"]
myList[-3:] // ["banana", "cherry", "date"]
myList[1:-1] // ["banana", "cherry"]
myList[:] // independent copy of ["apple", "banana", "cherry", "date"]</ms>

Unlike Python, you cannot assign to a slice; you can only assign to a single index.

<ms>myList[1] = "orange" // myList is now: ["apple", "orange", "cherry", "date"]
myList[1:3] = ["lemon"] // DOES NOT WORK</ms>

Like Python, indexing and slicing in MiniScript also applies to strings (excluding assignment since strings in both languages are immutable).

=== Map (Dictionary) Syntax ===

The equivalent of a Python ''dict'' is called a ''map'' in MiniScript. The syntax for such literals, and indexing into them, is the same in Python and MiniScript:

<ms>m = {"one":1, "two":2, "three":3}
print m["two"] // 2
m["pi"] = 3.14</ms>

Unlike Python, in MiniScript when a key in a map happens to also be a valid literal, it can be accessed via [[dot syntax]].

<ms>print m.two // 2
m.pi = 3.14157</ms>

MiniScript does not have a concept of "attributes" as something separate from key/value pairs in a map.

=== Variable Scope ===

Variables in both Python and MiniScript are local by default. There are some subtle differences, however: in Python, an inner function can implicitly access the variables of an outer function, but ''can't'' implicitly access global variables, while in MiniScript, any function can implicitly read values from both the outer context and the global context. To update a global variable, where Python uses a special <c>global</c> statement, MiniScript uses a <c>globals</c> prefix in a manner similar to using <c>self</c> to access object data.

<ms>
x = 0
count = function
globals.x = x + 1
print "The new count is: " + x
end function

count // The new count is: 1
count // The new count is: 2
count // The new count is: 3
</ms>

=== Object-Oriented Programming ===

Both MiniScript and Python support object-oriented programming, with some similarities and some differences. MiniScript uses '''prototype-based inheritance''', where the difference between "class" and "instance" is mainly in the mind of the programmer. Classes/instances are just maps, with the inheritance chain stored in a special <c>__isa</c> entry that is automatically set by the [[new]] operator.

Similarities between MiniScript and Python:
* inheritance and polymorphism
* use of [[self]] and [[super]]

Differences in MiniScript, as compared to Python:
* prototype-based inheritance built on classes
* use of [[new]] to subclass or create an instance
* no constructors
* no operator overloading or other magic methods

This MiniScript example illustrates some of these similarities and differences:

<ms>Person = {} // any empty map can be considered a class
Person.init = function(name, age) // not a magic method; just an ordinary method
self.name = name // note use of self (an implicit parameter)
self.age = age
end function

Person.sayHello = function
print "Hello world!"
end function

Person.sayName = function
print "My name is " + self.name + "."
end function

CoolPerson = new Person // creating a "subclass" of Person
CoolPerson.sayHello = function // overriding a function
print "How you doin'?"
end function

Joey = new CoolPerson // creating an "instance" of CoolPerson
Joey.init "Joey", 28
Joey.sayHello // prints: How you doin'?
Joey.sayName // prints: My name is Joey.</ms>

== Differences ==

=== Language Scale ===

MiniScript is a considerably smaller language by any reasonable measure. For example, the following table compares Python and MiniScript on C/C++ source code lines, source code files, number of data types, and number of standard intrinsic functions, as of 2021 ([https://miniscript.org/files/Strout_iSTEM-Ed2021.pdf source]).
{| class="wikitable"
|-
!
! Python
! MiniScript
|-
| Source Lines
| 661,775
| 13,752
|-
| Source Files
| 718
| 46
|-
| Data Types
| 34
| 6
|-
| Intrinsics
| 69
| 53
|}

=== Block Syntax ===

The most obvious difference between Python and MiniScript is in block syntax. While Python defines blocks by ending the opening line with a colon, and indenting the body of the block, MiniScript uses keyword pairs like <c>if</c>/<c>end if</c>, <c>for</c>/<c>end for</c>, and <c>function</c>/<c>end function</c> (more similar to Visual Basic). Indentation in MiniScript is strictly cosmetic, and is ignored by the compiler; and tools can automatically standardize or re-indent based on the keywords.

{| class="wikitable"
|-
! Python
! MiniScript
|-
| <pre>def myfunc():
for i in range(1, 11):
if i == 9:
print("Almost done...")
else:
print(i)

myfunc()</pre>
| <ms>myFunc = function
for i in range(1, 10)
if i == 9 then
print "Almost done..."
else
print i
end if
end for
end function

myFunc</ms>
|}

=== Function Invocation ===

While functions in Python are always invoked by putting parentheses after a function reference, in MiniScript, such parentheses can be omitted when (1) the function call is the entire statement, or (2) there are no arguments.

{| class="wikitable"
|-
! Python
! MiniScript
|-
| <pre>import random
x = random.uniform(0,1)
print(x)</pre>
| <ms>x = rnd
print x</ms>
|}

=== Magic Methods and Attributes ===

Python uses a large number of "magic" (aka "dunder") methods and attributes which have special meaning to the interpreter. These support things like operator overloading (<c>__add__</c>, <c>__ne__</c>, etc.), class support (<c>__class__</c>, <c>__subclasshook__</c>), and documentation (<c>__doc__</c>). By implementing these methods or assigning to these attributes, you can substantially change the way instances of a class behave.

MiniScript has no such magic methods or attributes, with the exception of the <c>__isa</c> key used to track inheritance in maps. <c>__isa</c> is automatically set by [[new]] and used by the [[isa]] operator, so in most cases user code should not ever need to touch it.

MiniScript does not support any form of operator overloading, or hooks to intercept other aspects of object behavior; objects always behave the same way.

=== import ===

While not part of the core language, several MiniScript environments (including [[Mini Micro]], [[Soda]], [[command-line MiniScript]], and [[Farmtronics]]) support an [[import]] command. However the semantics are a bit different from Python.

In MiniScript, the module name must be a string (usually, a string literal). The [[import]] command searches for a corresponding script file, runs it in its own call context, and binds the result (as a map) to an identifier of the same name in the calling context.

<ms>import "mathUtil"
print mathUtil.dice(3,6) // rolls 3d6 and prints the result</ms>

Note that [[import]] always runs the code in the imported module, even if it was run before. See the Usage Notes under [[import]] for an <c>ensureImport</c> function that may be helpful to ensure a module is imported only once.

MiniScript does not support the ''from'' syntax (e.g. Python's <c>from math import pi</c> or <c>from math import *</c>).

=== range function ===

The very common built-in function <c>range</c> in both languages takes up to three arguments: ''start'', ''stop'', and ''step''. But there are a few differences to note:

* In Python, the ''stop'' value is not included in the resulting sequence, while in MiniScript it is (i.e., it is an inclusive bound).
* In Python, if ''stop'' is less than ''start'', the result is an empty list unless you also specify a negative ''step''. In MiniScript, if ''step'' is omitted in such a case, it defaults to -1 (and you get a list that counts down).
* In Python, if only one argument is given, it is considered ''stop'' and the resulting sequence counts from 0 up to (but not including) that value. In MiniScript, a single argument is ''start'' and the resulting sequence counts from that number down (or up) to 0.
* In Python, the result of <c>range</c> is a '''range''' object; in MiniScript it is an ordinary list.

How to get started with Mini Micro

2024-09-19T16:49:44Z

JoeStrout: /* Where to learn more */

[https://miniscript.org/MiniMicro/ Mini Micro] is a popular environment for creating 2D games and demos in MiniScript. It is a retro-style virtual computer, which runs on most desktop platforms. Mini Micro games can be [[How to package a Mini Micro game|packaged]] as stand-alone games for desktop or the web.

This page is meant for people who have never used Mini Micro before, but want to make a Mini Micro game. It is a step-by-step guide to building your first simple demo involving a sprite, game input, and sound effects, including your own resources, as quickly as possible.

== Get Mini Micro ==

While you can run Mini Micro on the web, the web version has no ability to save files (nor does it support copy/paste). So it's not useful for developing your own Mini Micro games.

Go to the [https://miniscript.org/MiniMicro/#download Mini Micro download] page, click the button for your platform (Mac, Windows, or Linux), and save the resulting file to your local machine. (If you don't have a Mac, Windows, or Linux desktop machine, then unfortunately you can't use Mini Micro yet, though iOS and Android versions are under development.)

The downloaded file will be a .zip (Mac/Windows) or .tar.gz (Linux) file. ''Unpack this file completely.'' Don't try to run Mini Micro from ''within'' the archive; extract all files to a real folder on your hard drive.

Then, find the Mini Micro application in that folder. Double-click it to launch Mini Micro. The result should look like this.

[[File:MiniMicro.png|thumb|center]]

== Mount a folder as /usr ==

Mini Micro can access two virtual "disks" at once; within the Mini Micro environment, these are accessed as <c>/usr</c> and <c>/usr2</c>. Each of these can be either a '''.minidisk file''', or a '''real folder''' on the host (desktop) system. Out of the box, Mini Micro creates an empty .minidisk file for you, to keep things nice and neat. But for any serious development, you're going to want to mount a real folder instead, so that you can easily move files in and out of this folder, use your favorite external image/sound editors, etc.

Create a folder on your desktop system, wherever you normally keep your documents. This will be your project folder for your first Mini Micro game. Put a small text file, image (in PNG or JPEG format), or sound file (in WAV or OGG format) in there. Our goal now is to see and view this file (and any others in that folder or its subfolders) in Mini Micro.

=== Method 1: Use the disk slot menu ===

Those two thin dark rectangles in the bottom-left corner of the Mini Micro window are "disk slots." The top slot represents <c>/usr</c>, and the bottom slot represents <c>/usr2</c>. Click the top slot to pop open the menu, and select the "Mount Folder..." command.

[[File:MountFolder.png|frameless|center]]

Selecting that command should bring up the native file dialog for your platform, allowing you to select any folder you have access to. Pick the project folder you created above. (Note: some Linux platforms have a bug which crashes Mini Micro at this point; if that happens to you, go on to Method 2.)

Now, in the Mini Micro display, at the blinking orange prompt, type:

<ms>dir</ms>

and press Return or Enter. You should see your file listed. Now try:

<ms>view "myfile.txt"</ms>

but replace ''myfile.txt'' with the name of whatever file you placed in your project folder. Be sure to include the quotation marks; you're typing MiniScript code here, not some other shell language, so string literals always need to be surrounded by double quotes. If you do it correctly, the contents of your text file or image should appear on the screen.

(You could also do <c>view findFile</c>, which would pop up the little file browser within the [[findFile]] command, and select your file that way.)

Note that the currently mounted disk is saved in preferences, so if you quit and relaunch Mini Micro, you generally won't need to do this step again; the previously mounted disks will still be there.

=== Method 2: Use command-line arguments ===

If you are unfortunate enough to hit that Linux bug which causes the file dialogs to crash, or for some other reason you want to launch Mini Micro from the command line (or a shell script) with the correct folder already mounted, then you can use [[Command-line arguments|command-line arguments]] instead. Open your favorite terminal program, and navigate to where the Mini Micro executable is located. The details vary by platform, so let's break it down:

'''Linux'''

In Linux, the executable is called '''MiniMicro.x86_64''', so you would type a command like this:

<ms>./MiniMicro.x86_64 -usr ~/mmdev</ms>

Replace <c>~/mmdev</c> with the path to your project folder.

'''Windows'''

In Windows, you can open the command prompt by pressing '''Win + R''' to open the Run dialog, and entering ''cmd''. (If you already have some other preferred terminal app, like PowerShell, that's fine too.) Then <c>cd</c> to the directory containing Mini Micro. The executable here is called '''Mini Micro.exe''', so you would use a command like:

<ms>"Mini Micro.exe" -usr "%HOMEPATH%\mmdev</ms>

Replace <c>%HOMEPATH%\mmdev</c> with the path to your project folder.

'''MacOS'''

On Mac, the actual executable is hidden inside the application bundle, specifically under Contents/MacOS. So if you've already launched Terminal and navigated to where '''MiniMicro.app''' is found, then you would do

<ms>Contents/MacOS/Mini\ Micro -usr ~/Documents/mmdev</ms>

Replace <c>~/Documents/mmdev</c> with the path to your project folder.

If successful (on any platform), you should be able to use the <c>dir</c> and <c>view</c> commands to view the file in your project folder within the Mini Micro environment.

== Create a sprite ==

Now let's get a sprite up on the screen. We're going to do this using the Mini Micro command line (or [[REPL]]), where you type a command and executes immediately. We'll get to writing real programs later, but the command-line is a powerful tool for learning and exploring, so let's use it.

=== 1. Make a sprite from the built-in images ===

At the orange blinking-cursor prompt in Mini Micro, carefully type the following:

<ms>clear
sp = new Sprite
sp.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push sp</ms>

You should see a furry purple Wumpus peeking out from the lower-left corner of the screen (which is the origin of Mini Micro's [[Screen coordinates|coordinate system]]).

[[File:ManualSprite.png|thumb]]

If you don't see this, go back and double-check your typing. Note that you can recall a previous command on the command line by pressing the '''up-arrow'' key, then just edit it and press Return to run the edited command.

How does this work? Let's break it down:

# <c>[[clear]]</c> clears the screen and resets all eight display layers to their default states. This includes setting display 4 to be a [[SpriteDisplay]]. (That's the default state when Mini Micro boots, but useful whenever your screen is cluttered anyway.)
# <c>sp = new Sprite</c> creates a new [[Sprite]] object, and assigns it to a variable called <c>sp</c>.
# <c>sp.image = file.loadImage("/sys/pics/Wumpus.png")</c> loads an image called "Wumpus.png" from the <c>/sys/pics</c> directory. (Notice that Mini Micro uses forward-slashes in file paths, even if the host system is Windows.)
# <c>display(4).sprites.push sp</c> pushes this new sprite onto the sprite list of display 4, so it can be seen.

Once you have the Wumpus peeking out of the corner, let's move it and rotate it a bit. Notice how the sprite updates immediately after each command.

<ms>sp.x = 480
sp.y = 320
sp.rotation = 45</ms>

=== 2. Make a sprite from your own custom image ===

The Wumpus sprite above was created from one of the built-in images that comes with Mini Micro. There are hundreds of these, stored on a hidden, read-only disk mounted as <c>/sys</c>. Feel free to use the <c>findFile</c> command to explore what's there.

But for your own game, you're probably going to want to use your own custom sprites. So, put an image in PNG format into your project directory (the one you mounted as <c>/usr</c>). Use the <c>pwd</c> (print working directory) and <c>cd</c> (change directory) commands to be sure you are in your <c>/usr</c> directory. Then use the <c>dir</c> and <c>view</c> commands to ensure that you can see and load your user file.

Now, just repeat the commands you did to create a sprite above, but substitute the path to your custom image.

<ms>sp = new Sprite
sp.image = file.loadImage("myCustomImage.png")
display(4).sprites.push sp</ms>

If you haven't [[clear]]ed the display since step 1, then you'll see your new sprite ''and'' the Wumpus on screen at the same time. And if you now move (by assigning to <c>.x</c> and <c>.y</c>) your sprites so that they overlap, you'll see that your new sprite is drawn on top of the older one. That's because sprites are drawn in the order in which they appear in the [[SpriteDisplay.sprites|sprites list]] of the [[SpriteDisplay]].

=== 3. Extract an image from a sprite sheet ===

Often you have multiple sprite images arranged in one bigger image file, called a '''sprite sheet''' or '''sprite atlas'''. You can pull apart such a sprite sheet by using the [[Image.getImage]] function. Let's try:

<ms>enemies = file.loadImage("/sys/pics/Enemies.png")
view enemies</ms>

This loads and displays [https://github.com/JoeStrout/minimicro-sysdisk/blob/master/sys/pics/Enemies.png?raw=true this big image], which contains a number of platformer enemies, in a 128x128 pixel grid. Let's make a sprite out of the top-left image. Keep in mind that coordinates in Mini Micro go from the bottom-left corner, so that top image starts at 128 * 3 = 384.

<ms>goob = new Sprite
goob.image = enemies.getImage(0, 384, 128, 128)
display(4).sprites.push goob</ms>

This creates a new sprite called <c>goob</c>, assigns it an image from our <c>enemies</c> sprite sheet, and pushes it onto the display. As always, it starts out in the bottom-left corner, but you know how to adjust that by now. Since this sprite is a bit bigger than it probably needs to be, also try <c>goob.scale = 0.5</c> to shrink it down.

== Play a sound ==

Almost any game needs [[sound]] effects! Mini Micro supports both playing both digitized sounds loaded from a file, and sounds synthesized at runtime. We'll focus here on playing sounds from a file, which can be in either WAV or OGG format.

=== 1. Play one of the built-in sounds ===

Enter <c>clear</c> to clear the screen, then try this:

<ms>snd = file.loadSound("/sys/sounds/twinkle.wav")
snd.play</ms>

You should hear a twinkle sound. The [[Sound.play]] method supports several optional parameters. A handy trick when you need a quick reminder of function parameters is to use [[@]] (the at-sign) before a function reference, to return the function without invoking it. On the command line, that will print the function parameter names and default values. Try it:

<ms>@snd.play</ms>
which prints:
<ms>FUNCTION(self, volume=1, pan=0, speed=1)</ms>

So let's try some variations on the sound. (In the code below, we're using <c>//</c> to add a [[Comments|comment]] on each line; you don't have to type these, but you can if you like.)

<ms>snd.play 0.1 // play very quietly
snd.play 1, -1 // play out the left speaker only
snd.play 1, 0, 2 // play twice as fast (an octave higher)
snd.play 1, 0, 0.5 // play half as fast (an octave lower)</ms>

=== 2. Play your own custom sound ===

Put a sound file in WAV or OGG format into your project folder. (On some platforms you can also use MP3 format, but that doesn't work everywhere and so is best to avoid if you plan to distribute your game.) Let's suppose your file is called "bgm.ogg". Load and play it just as above:

<ms>snd2 = file.loadSound("bgm.ogg")
snd2.play</ms>

If your sound is very long, and you want to stop it, you can just do <c>snd2.stop</c>. Or you can use <c>Sound.stopAll</c> to stop all sounds.

Before we move on, let's make this sound loop forever, as you might want background music to do:

<ms>snd2.loop = true
snd2.play</ms>

Again, use <c>snd2.stop</c>. Or you can use <c>Sound.stopAll</c> to make it stop.

=== 3. About synthesized sounds ===

Mini Micro has a sophisticated API for creating sounds out of nothing but code. You can specify a base waveform, frequency, envelope, fade-in/fade-out, and even mix basic sounds together to create more sophisticated sounds. You can find a couple of simple examples on the [[Sound.init]] page, and some more complex ones by doing <c>run "/sys/lib/sounds"</c> (followed by <c>edit</c> to see how those examples were made).

== Write a program ==

Typing commands directly on the command line is a great way to learn, explore, and test things out. But to write more than a few lines, you'll want to use a code editor. Assuming you've mounted a folder (rather than a minidisk file), you have two options: the built-in code editor, or an external code editor.

=== Method 1: Use the built-in code editor ===

The [[Mini Micro code editor]] is invoked with the <c>edit</c> command. Just type <c>edit</c> by itself to edit the currently loaded program (or start a new program, if none is loaded). Or, you can add a filename argument, like <c>edit "myGame"</c>, to [[load]] a different program and open the editor in one step.

Note that once a program is loaded, if you want to start a new program, use [[reset]] to clear the current program and variables.

The built-in code editor is full-featured and powerful, including auto-indenting, code snippets, a color picker for color constants, and a sophisticated find/replace dialog. See [[Mini Micro code editor|this page]] for usage details.

=== Method 2: Use an external code editor ===

When you have mounted a real folder as your <c>/usr</c> (or <c>/usr2</c>) disk, then you can edit MiniScript files therein using your favorite code editor, outside of Mini Micro. On the [[Tools]] page you can even find language models for editors like VS Code or BBEdit, to provide MiniScript-savvy syntax coloring.

When you edit code in this way, you will need to reload the program from disk in Mini Micro to see your changes. It's also generally a good idea to <c>reset</c> the environment before running the new code, so that old function definitions or other variable values don't inadvertently change the behavior. So after externally editing a script called "myGame.ms", do:

<ms>reset; run "myGame"</ms>

in Mini Micro. (And once you've done this once, you can generally just up-arrow to recall and repeat this command again the next time.)

=== A simple game demo ===

Using either method above, create a new MiniScript program called "ufo.ms", and paste in the following. (Or to learn even faster, retype it instead of using copy & paste.)

<ms>// prepare displays
clear
sd = display(4) // sprite display

// prepare UFO sprite and other resources
ufo = new Sprite
ufo.image = file.loadImage("/sys/pics/UFO.png")
sd.sprites.push ufo
ufo.x = 480; ufo.y = 320

fireSound = file.loadSound("/sys/sounds/blam.wav")

// allow alternate "fire" buttons
fireButtons = ["space", "left shift", "right shift",
"joystick button 0", "joystick button 1"]
firePressed = function
for btn in fireButtons
if key.pressed(btn) then return true
end for
return false
end function

// function to "fire" (play a sound)
fire = function
fireSound.play
end function

// main loop
fireWasPressed = false
while true
yield // wait for next frame

// move the UFO
ufo.x += key.axis("Horizontal") * 20
ufo.y += key.axis("Vertical") * 20

// fire, when fire button goes down
fireNowPressed = firePressed
if fireNowPressed and not fireWasPressed then fire
fireWasPressed = fireNowPressed
end while</ms>

This creates a simple game demo which allows you to move a UFO around the screen using the arrow keys, WASD, or a game controller (which all feed into <c>[[key.axis]]</c>). And when you press any of several keys (including joystick/gamepad button 0 or 1), it plays a sound.

Try changing the UFO sprite to your own custom sprite, and changing the fire sound to your own sound. That will verify that you're able to get your own assets working in Mini Micro in a custom game program. Then start playing around with the code. Some things to try:

* Limit the sprite position so it can't go offscreen
* Add some sort of target, as in <c>/sys/demo/spriteDemo</c>
* Make the sprite drop/fire a second sprite when the fire button is pressed

== Package your game for the web ==

If you've come here because you want to make a Mini Micro game for a game jam, then you should almost certainly learn how to package your game for playing on the web, and upload it to a site like itch.io.

This process is described in detail on [[How to package a Mini Micro game]]. Focus on the general instructions at the top, and the "packaging for the web" instructions at the bottom.

== Where to learn more ==

Congratulations! You have learned how to set up a local Mini Micro environment for development, using your own game assets, and learned to use both the built-in and external code editors. You've made a very simple game demo, and know how to upload it to the web. All toolchain hurdles are behind you; now it's just a matter of designing a game, and writing the code!

If you are a Python or Lua programmer, see the [[Python]] or [[Lua]] page of this wiki to see how MiniScript compares to those.

When writing the code, you will probably lean most heavily on these resources:

* The [https://miniscript.org/files/MiniMicro-CheatSheet.pdf Mini Micro Cheat Sheet], a 4-page summary of the Mini Micro API and MiniScript language
* This wiki, especially the [[How To]] articles
* Sample code found in <c>/sys/demo</c>
* Various blog posts, perhaps found through the [[Bibliography]] page

Most important of all, rely on the '''community Discord server''', a link to which can be found at the bottom of the [https://miniscript.org/ MiniScript home page]. An active and friendly community hangs out here, and you are encouraged to share screenshots, code snippets, and questions there.

[[Category:Mini Micro]]
[[Category:How To]]