MiniScript Wiki - User contributions [en]

Love for Mini

2025-12-26T20:03:25Z

Redspark: Initial Page

{| class="plainrowheaders" border="0" cellpadding="10"
| valign="top" | [[File: MiniLoveIcon.png |80px]]
| style="font-size: 150%;" valign="middle" | '''Have you been using MiniScript or Mini Micro and like them? Show your support by posting a like and even a review at any of the following websites:'''
|}

* '''[https://alternativeto.net/software/mini-micro/about/#post-165364 AlternativeTo.com]'''

File:MiniLoveIcon.png

2025-12-26T19:40:13Z

Redspark:

Mini Hugging a Heart

Sound

2025-12-25T14:27:53Z

Redspark: Added amp() method

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
|-
| [[Sound.amp]] || returns the current amplitude of the playing sound.
|}

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

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

BmfFonts

2025-11-22T15:02:56Z

Redspark: Updated URL

This module defines a Font class which can read fonts in [http://bmf.wz.cz:8080/?page=format BMF format] version 1.1 or 1.2. Version 1.2 is a recent but significant upgrade, adding support for non-ASCII Unicode characters, kerning, and an alpha channel for anti-aliased fonts.

If you run bmfFonts.demo (or load and run the module directly instead of using import), it will look for the fonts folder, and draw a string with each one. The final font will be drawn at 3X scale at the bottom of the screen.

== Classes ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[bmfFonts.Font|Font]] || Stores all data about a particular font.
|-
| [[bmfFonts.CharData|CharData]] || Stores all data about a single character in a specific font.
|}

=== Example ===
<ms>
import "bmfFonts"
clear
// Load a font
f = bmfFonts.Font.load("/sys/fonts/Arial14Bold.bmf")

// Print a string in that font to gfx
f.print "Hello world!", 20, 500

// Get a character image, and make a Sprite out of it
spr = new Sprite
spr.image = f.getCharImage("R")
spr.x = 600
spr.y = 500
spr.scale = 3
spr.rotation = 30
display(4).sprites.push spr
</ms>

[[Category:Mini Micro]]
[[Category:Sys Modules]]

File.open

2025-09-29T15:05:39Z

Redspark: Removed fopen() reference

In [[Mini Micro]] and [[command-line MiniScript]], the <c>[[file]].open</c> function returns a [[FileHandle]] object that enables further reads, writes, or updates of the file.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Default Value !! Meaning
|-
| path || "" || full or partial path to the file of interest
|-
| mode || "r+" || file mode (see below)
|}

=== File Modes ===

The second parameter to <c>[[file]].open</c> specifies whether the file is opened for reading, writing, or both.

{| class="wikitable"
|-
! Mode !! Description !! Starting Position
|-
|<tt>r</tt> || Opens an existing text file for reading. If the file does not exist, it returns null. || beginning
|-
|<tt>w</tt> || Opens a text file for writing. If the file exists, its contents are truncated (emptied). If the file does not exist, a new file is created. || beginning
|-
|<tt>a</tt> || Opens a text file for appending. Data is written to the end of the file. If the file does not exist, a new file is created. || end
|-
|<tt>r+</tt> || Opens an existing text file for both reading and writing. The file must exist.|| beginning
|-
|<tt>w+</tt> || Opens a text file for both writing and reading. If the file exists, its contents are truncated. If the file does not exist, a new file is created. || beginning
|-
|<tt>a+</tt> || Opens a text file for both appending and reading. Data is written to the end of the file. If the file does not exist, a new file is created. || end
|}

When a file is opened with update mode ( '<tt>+</tt>' as the second or third character in the mode argument), both input and output may be performed on the associated stream.

Writing and appending modes will attempt to create a file of the given name, if no such file already exists. If this operation fails, <c>[[file]].open</c> will return <c>[[null]]</c>.

== Example ==

This appends a new line to an existing text file (creating it if it does not already exist).

<ms>f = file.open("test.txt", "a")
f.write char(13) + "Hello world!"
f.close</ms>

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

File.open

2025-09-29T15:04:34Z

Redspark: Update file mode descriptions for clarification

In [[Mini Micro]] and [[command-line MiniScript]], the <c>[[file]].open</c> function returns a [[FileHandle]] object that enables further reads, writes, or updates of the file.

=== Arguments ===

{| class="wikitable"
|-
! Parameter Name !! Default Value !! Meaning
|-
| path || "" || full or partial path to the file of interest
|-
| mode || "r+" || file mode (see below)
|}

=== File Modes ===

The second parameter to <c>[[file]].open</c> specifies whether the file is opened for reading, writing, or both.

{| class="wikitable"
|-
! Mode !! Description !! Starting Position
|-
|<tt>r</tt> || Opens an existing text file for reading. If the file does not exist, fopen() returns NULL. || beginning
|-
|<tt>w</tt> || Opens a text file for writing. If the file exists, its contents are truncated (emptied). If the file does not exist, a new file is created. || beginning
|-
|<tt>a</tt> || Opens a text file for appending. Data is written to the end of the file. If the file does not exist, a new file is created. || end
|-
|<tt>r+</tt> || Opens an existing text file for both reading and writing. The file must exist.|| beginning
|-
|<tt>w+</tt> || Opens a text file for both writing and reading. If the file exists, its contents are truncated. If the file does not exist, a new file is created. || beginning
|-
|<tt>a+</tt> || Opens a text file for both appending and reading. Data is written to the end of the file. If the file does not exist, a new file is created. || end
|}

When a file is opened with update mode ( '<tt>+</tt>' as the second or third character in the mode argument), both input and output may be performed on the associated stream.

Writing and appending modes will attempt to create a file of the given name, if no such file already exists. If this operation fails, <c>[[file]].open</c> will return <c>[[null]]</c>.

== Example ==

This appends a new line to an existing text file (creating it if it does not already exist).

<ms>f = file.open("test.txt", "a")
f.write char(13) + "Hello world!"
f.close</ms>

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

Events

2025-09-05T12:40:10Z

Redspark:

This system module defines the EventSprite class which expands on the Sprite class to add definable event functions called handlers. These handlers are triggered under certain conditions such as a mouse being clicked. A special EventLoop is defined to act as a dedicated game loop that manages all of the event classes. Since the EventLoop is continuous until terminated by an eventLoop.stop call, you would have to design your game around using this module by making all Sprites in your game EventSprites.

== Classes ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[events.EventHandler|EventHandler]] || Stores information about the action to take when responding to an Event.
|-
| [[events.KeyHandler|KeyHandler]] || Stores the current state of a particular Key including whether it is Up, Down or being Held down.
|-
| [[events.EventSprite|EventSprite]] || Builds on the Sprite class to add event handlers that respond to events such as: onKey, onKeyDown, onKeyUp, onClick, etc.
|}

== Event Loop ==
Within the module, there is a special singleton class call eventLoop which is meant to only exist once. It governs the game loop and manages the responses to the triggered events. This is a dedicated game loop which will continue to execute until an event terminates the loop or program in some way.

=== Methods ===
{| class="wikitable"
|-
! Name !! Description
|-
| run || The main game loop. Continues to execute until stop is called or the program is interrupted.
|-
| stop || Terminates the main loop on the next frame.
|-
| update || Called from the main loop each frame. Responsible for maintaining state of all events.
|-
| doAfter || Schedules a function call to happen at a later physical time.
|-
| cancelDoAfter || Removes a previously scheduled call by doAfter.
|}

=== Example ===
<ms>
import "events"

clear
display(4).mode = displayMode.sprite
spr = new events.EventSprite
spr.image = file.loadImage("/sys/pics/Wumpus.png")
spr.onKey = new events.KeyHandler
spr.onKey["left"] = function
self.x = self.x - 10
if self.x < 50 then eventLoop.stop
end function
spr.onKey["right"] = function
self.x = self.x + 10
end function
events.eventLoop.onKey["escape"] = function
eventLoop.stop
end function
events.eventLoop.onKeyDown["space"] = function; print "space down"; end function
events.eventLoop.onKey["space"] = function; print "space held"; end function
events.eventLoop.onKeyUp["space"] = function; print "space up"; end function

spr.onClick = function
self.scale = 1.5
end function
spr.onDrag = function
self.x = mouse.x
self.y = mouse.y
end function
spr.onDragEnd = function
self.scale = 1
end function

spr.x = 480
spr.y = 320
spr.start

print "Click and drag, or press left/right."
print "All event-driven. (Esc to exit.)"

events.eventLoop.run
</ms>

[[Category:Mini Micro]]
[[Category:Sys Modules]]

Map

2025-09-02T07:31:36Z

Redspark: Adjusted Pop definition

<c>map</c> is one of the core [[:Category:Data Types|data types]] in MiniScript.

== Methods ==

{| class="wikitable"
|-
! Method !! Description
|-
| hasIndex(''key'') || Returns true if the map contains ''key''
|-
| indexes || Returns a list of the map keys
|-
| indexOf(''value'', ''after'') || Returns the key of the first occurrence of ''value'' in the map, or <c>null</c> if not found. Does not search inheritance chain.
|-
| len || Returns the number of key/value pairs contained in the map
|-
| pop || Removes a key/value pair from the map and returns the key. There is no guarantee which pair gets removed.
|-
| push ''key'' || Adds the ''key'' to the map and assigns a value of 1
|-
| pull || Same as pop.
|-
| shuffle || Mutates the map by randomly re-ordering the values assigned to each key within the map
|-
| sum || Returns the sum of all numeric values in the map
|-
| remove ''key'' || Removes the key/value pair at ''key''
|-
| replace ''oldValue'', ''newValue'', ''maxCount'' || Mutates the map by replacing occurrences of ''oldValue'' with ''newValue'' at most ''maxCount'', if specified. If ''maxCount'' is omitted it replaces '''all''' occurrences.
|-
| values || Returns a list values within the map
|}

== See also ==
* [[mapUtil]] - for additional functions on a list

[[Category:Language]]
[[Category:Data Types]]

Map

2025-09-02T00:55:28Z

Redspark: Added base methods for the map class

<c>map</c> is one of the core [[:Category:Data Types|data types]] in MiniScript.

== Methods ==

{| class="wikitable"
|-
! Method !! Description
|-
| hasIndex(''key'') || Returns true if the map contains ''key''
|-
| indexes || Returns a list of the map keys
|-
| indexOf(''value'', ''after'') || Returns the key of the first occurrence of ''value'' in the map, or <c>null</c> if not found. Does not search inheritance chain.
|-
| len || Returns the number of key/value pairs contained in the map
|-
| pop || Removes the most recently added key/value pair and returns the key
|-
| push ''key'' || Adds the ''key'' to the map and assigns a value of 1
|-
| pull || Same as pop.
|-
| shuffle || Mutates the map by randomly re-ordering the values assigned to each key within the map
|-
| sum || Returns the sum of all numeric values in the map
|-
| remove ''key'' || Removes the key/value pair at ''key''
|-
| replace ''oldValue'', ''newValue'', ''maxCount'' || Mutates the map by replacing occurrences of ''oldValue'' with ''newValue'' at most ''maxCount'', if specified. If ''maxCount'' is omitted it replaces '''all''' occurrences.
|-
| values || Returns a list values within the map
|}

== See also ==
* [[mapUtil]] - for additional functions on a list

[[Category:Language]]
[[Category:Data Types]]

Bibliography

2025-08-30T01:39:36Z

Redspark: Added Joe's Dev.to articles until end of Aug 2025

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

* Strout, Joe. "The Making of Solitaire for Mini Micro", Dev.to, 10 Jul 2024, https://dev.to/joestrout/the-making-of-solitaire-for-mini-micro-19hf. Accessed 10 Jul 2024
* Strout, Joe. "if locals == globals", Dev.to, 24 Jul 2024, https://dev.to/joestrout/if-locals-globals-38bh. Accessed 24 Jul 2024
* Strout, Joe. "Creating a Level Editor for Sub-Optimal", Dev.to, 18 Aug 2024, https://dev.to/joestrout/creating-a-level-editor-for-sub-optimal-19hd. Accessed 18 Aug 2024
* Strout, Joe. "Best New Mini Micro Games", Dev.to, 27 Aug 2024, https://dev.to/joestrout/best-new-mini-micro-games-55gg. Accessed 27 Aug 2024
* Strout, Joe. "Oldest surviving sprite award: Ghost-tiny", Dev.to, 18 Sep 2024, https://dev.to/joestrout/oldest-surviving-sprite-award-ghost-tiny-2dba. Accessed 18 Sep 2024
* Strout, Joe. "Mini Micro has an "attract mode"!", Dev.to, 09 Oct 2024, https://dev.to/joestrout/mini-micro-has-an-attract-mode-i7j. Accessed 09 Oct 2024
* Strout, Joe. "Daily MiniScript mini-challenges", Dev.to, 16 Oct 2024, https://dev.to/joestrout/daily-miniscript-mini-challenges-3732. Accessed 16 Oct 2024
* Strout, Joe. "How displays work in Mini Micro", Dev.to, 24 Nov 2024, https://dev.to/joestrout/how-displays-work-in-mini-micro-21pp. Accessed 24 Nov 2024
* Strout, Joe. "MiniScript: Why "f = function"?", Dev.to, 26 Jan 2025, https://dev.to/joestrout/miniscript-why-f-function-fcp. Accessed 26 Jan 2025
* Strout, Joe. "Why Mini Micro's Screen is 960x640", Dev.to, 5 Feb 2025, https://dev.to/joestrout/why-mini-micros-screen-is-960x640-16d5. Accessed 5 Feb 2025
* Strout, Joe. "Optimizing Mini Micro for pixel-art games", Dev.to, 19 Feb 2025, https://dev.to/joestrout/optimizing-mini-micro-for-pixel-art-games-3mdf. Accessed 19 Feb 2025
* Strout, Joe. "Mini Micro speaks like a droid!", Dev.to, 28 Feb 2025, https://dev.to/joestrout/mini-micro-speaks-like-a-droid-2hdl. Accessed 28 Feb 2025
* Strout, Joe. "Announcing Mini Micro 1.2.4", Dev.to, 8 Mar 2025, https://dev.to/joestrout/announcing-mini-micro-124-28l1. Accessed 8 Mar 2025
* Strout, Joe. "Other MiniScript Bloggers to Follow", Dev.to, 14 Mar 2025, https://dev.to/joestrout/other-miniscript-bloggers-to-follow-19lf. Accessed 14 Mar 2025
* Strout, Joe. "Hexes and bricks in Mini Micro", Dev.to, 30 Mar 2025, https://dev.to/joestrout/hexes-and-bricks-in-mini-micro-e99. Accessed 30 Mar 2025
* Strout, Joe. "Taming local git branches", Dev.to, 7 Apr 2025, https://dev.to/joestrout/taming-local-git-branches-4nd9. Accessed 7 Apr 2025
* Strout, Joe. "Don't Abuse Lerp!", Dev.to, 11 Apr 2025, https://dev.to/joestrout/dont-abuse-lerp-4k6d. Accessed 11 Apr 2025
* Strout, Joe. "Fathom's Edge: Progress Report #1", Dev.to, 8 May 2025, https://dev.to/joestrout/fathoms-edge-progress-report-1-2llb. Accessed 8 May 2025
* Strout, Joe. "Proper setup for a MiniScript GitHub repo", Dev.to, 27 May 2025, https://dev.to/joestrout/proper-setup-for-a-miniscript-github-repo-4ian. Accessed 27 May 2025
* Strout, Joe. "Apple ][ Text on Mini Micro!", Dev.to, 02 Aug 2025, https://dev.to/joestrout/apple-text-on-mini-micro-337. Accessed 02 Aug, 2025
* Strout, Joe. "UV Mapping in Mini Micro", Dev.to, 05 Aug 2025, https://dev.to/joestrout/uv-mapping-in-mini-micro-2eoa. Accessed 05 Aug, 2025

== 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]]

Object-oriented programming

2025-06-08T21:37:46Z

Redspark: Changed create to Create

Object-oriented programming (OOP) is a way of organizing code and data using objects, which are essentially self-contained units of data and methods that operate on that data. OOP is a fundamental approach to software development in many languages like Java, C++, and Python.

OOP relies on certain key concepts:
* '''Classes and Objects''': A class is a blueprint for creating objects, which are instances of that class.
* '''Encapsulation''': Bundling data (fields) and methods (procedures) that operate on that data within a single unit (object).
* '''Inheritance''': Creating new classes (subclasses) based on existing classes (superclasses), inheriting their attributes and behaviors.
* '''Polymorphism''': Allowing objects of different classes to be treated as objects of a common superclass, enabling code reuse and flexibility.

== Classes and Objects ==
In their most straightforward form, classes act as blueprints for objects. It's like a how you can drive into a rural area of a city and find many new homes with the same design. The developers used one set of architectural blueprints to build all of those houses. In the same way, one class can be used to construct many objects.

An object, on the other hand, is an actual active instance of a built class in memory. In most languages, there is a keyword that tells the compiler to create an object from a class such as <c>[[new]]</c>.

Classes are mostly defined by their fields and methods. Fields are just like variables except they are tied to a class or object. Methods are similar to functions and they always have access to the fields within their class definition as if they those fields were passed as a parameter to the method. Sometimes a language will require the keyword prefix <c>[[self]]</c> when referencing a field or method within the class definition.

In C++, let's define an Animal class:

class Animal {
protected:
std::string name;
int age;
public:
Animal(const std::string& name, int age)
: name(name), age(age) {}
virtual ~Animal() {}
virtual void speak() const = 0; // Pure virtual function
virtual void info() const {
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
};

In MiniScript, the same class would be defined as:
<ms>
Animal = { name:"" }

Animal.Create = function(name, age)
a = new Animal
a.name = name
a.age = age
return a
end function

Animal.speak = function
end function

Animal.info = function
print "Name: " + self.name + ", Age: " + self.age
end function
</ms>

== Encapsulation ==
Encapsulation is more of a design technique to OOP programming and less of a technical aspect of any OOP language. When you code using this technique, it allows the programmer to organize their project by grouping all behaviour and related data into classes. When instantiated as an Object, this single container can be passed around in your code to "interact" with other objects.

When coding with encapsulation in mind, all behaviours (methods) and properties (fields) related to a class will be defined in that class. Knowing where to draw the line to include or exclude behaviour and properties tends to make or break an OOP design. Often it is better to define something using multiple classes rather than trying to make one monolithic class. A good rule of thumb is to dedicate a class to a single thing.

Looking back at our Animal class above, we can see that it has two fields (name and age) and essentially two methods (speak and info). Looking at <c>info()</c> we can see that it only uses <c>name</c> and <c>age</c>. As mentioned, that is what is defined in the class and so those are the only variables it has access to.

<blockquote> 📚 The other two methods in C++ are the constructor and destructor. In MiniScript, you are not required to have either of these. However, creating a constructor may help to declutter your code and make it easier to read.</blockquote>

== Inheritance ==
In the same way that humans inherit certain genetic traits from their parents, classes can inherit from a single parent classes (some languages support multiple inheritance as well). When a class inherits from another, all of the declared fields and methods of the parent class are automatically given to the child class. Only the inheritance has to be defined for this to work. For instance, in our Animal class, let's create two new children called Dog and Cat.

class Cat : public Animal {
private:
bool likesToClimb;
public:
Cat(const std::string& name, int age, bool likesToClimb)
: Animal(name, age), likesToClimb(likesToClimb) {}
void speak() const override {
std::cout << name << " says: Meow!" << std::endl;
}
void info() const override {
Animal::info();
std::cout << "Likes to climb: " << (likesToClimb ? "Yes" : "No") << std::endl;
}
};

class Dog : public Animal {
private:
std::string favoriteToy;
public:
Dog(const std::string& name, int age, const std::string& favoriteToy)
: Animal(name, age), favoriteToy(favoriteToy) {}
void speak() const override {
std::cout << name << " says: Woof!" << std::endl;
}
void info() const override {
Animal::info();
std::cout << "Favorite toy: " << favoriteToy << std::endl;
}
};

In MiniScript, these would be defined as:
<ms>
Cat = new Animal
Cat.likesToClimb = true
Cat.Create = function(name, age, likesToClimb)
c = new Cat
c.name = name
c.age = age
c.likesToClimb = likesToClimb
return c
end function

Cat.speak = function
print self.name + " says: Meow!"
end function

Cat.info = function
super
print "Likes to Climb: " + self.likesToClimb
end function

Dog = new Animal
Dog.favouriteToy = "None"
Dog.Create = function(name, age, favouriteToy)
d = new Dog
d.name = name
d.age = age
d.favouriteToy = self.favouriteToy
return d
end function

Dog.speak = function
print self.name + " says: Woof!"
end function

Dog.info = function
super
print "Favourite Toy: " + self.favouriteToy
end function
</ms>

MiniScript supports prototype-based OOP through <c>[[new]]</c>, <c>[[self]]</c>, <c>[[super]]</c>, and <c>[[isa|__isa]]</c>.

[[Category:Language]]

Object-oriented programming

2025-06-08T20:53:34Z

Redspark:

Object-oriented programming (OOP) is a way of organizing code and data using objects, which are essentially self-contained units of data and methods that operate on that data. OOP is a fundamental approach to software development in many languages like Java, C++, and Python.

OOP relies on certain key concepts:
* '''Classes and Objects''': A class is a blueprint for creating objects, which are instances of that class.
* '''Encapsulation''': Bundling data (fields) and methods (procedures) that operate on that data within a single unit (object).
* '''Inheritance''': Creating new classes (subclasses) based on existing classes (superclasses), inheriting their attributes and behaviors.
* '''Polymorphism''': Allowing objects of different classes to be treated as objects of a common superclass, enabling code reuse and flexibility.

== Classes and Objects ==
In their most straightforward form, classes act as blueprints for objects. It's like a how you can drive into a rural area of a city and find many new homes with the same design. The developers used one set of architectural blueprints to build all of those houses. In the same way, one class can be used to construct many objects.

An object, on the other hand, is an actual active instance of a built class in memory. In most languages, there is a keyword that tells the compiler to create an object from a class such as <c>[[new]]</c>.

Classes are mostly defined by their fields and methods. Fields are just like variables except they are tied to a class or object. Methods are similar to functions and they always have access to the fields within their class definition as if they those fields were passed as a parameter to the method. Sometimes a language will require the keyword prefix <c>[[self]]</c> when referencing a field or method within the class definition.

In C++, let's define an Animal class:

class Animal {
protected:
std::string name;
int age;
public:
Animal(const std::string& name, int age)
: name(name), age(age) {}
virtual ~Animal() {}
virtual void speak() const = 0; // Pure virtual function
virtual void info() const {
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
};

In MiniScript, the same class would be defined as:
<ms>
Animal = { name:"" }

Animal.create = function(name, age)
a = new Animal
a.name = name
a.age = age
return a
end function

Animal.speak = function
end function

Animal.info = function
print "Name: " + self.name + ", Age: " + self.age
end function
</ms>

== Encapsulation ==
Encapsulation is more of a design technique to OOP programming and less of a technical aspect of any OOP language. When you code using this technique, it allows the programmer to organize their project by grouping all behaviour and related data into classes. When instantiated as an Object, this single container can be passed around in your code to "interact" with other objects.

When coding with encapsulation in mind, all behaviours (methods) and properties (fields) related to a class will be defined in that class. Knowing where to draw the line to include or exclude behaviour and properties tends to make or break an OOP design. Often it is better to define something using multiple classes rather than trying to make one monolithic class. A good rule of thumb is to dedicate a class to a single thing.

Looking back at our Animal class above, we can see that it has two fields (name and age) and essentially two methods (speak and info). Looking at <c>info()</c> we can see that it only uses <c>name</c> and <c>age</c>. As mentioned, that is what is defined in the class and so those are the only variables it has access to.

<blockquote> 📚 The other two methods in C++ are the constructor and destructor. In MiniScript, you are not required to have either of these. However, creating a constructor may help to declutter your code and make it easier to read.</blockquote>

== Inheritance ==
In the same way that humans inherit certain genetic traits from their parents, classes can inherit from a single parent classes (some languages support multiple inheritance as well). When a class inherits from another, all of the declared fields and methods of the parent class are automatically given to the child class. Only the inheritance has to be defined for this to work. For instance, in our Animal class, let's create two new children called Dog and Cat.

class Cat : public Animal {
private:
bool likesToClimb;
public:
Cat(const std::string& name, int age, bool likesToClimb)
: Animal(name, age), likesToClimb(likesToClimb) {}
void speak() const override {
std::cout << name << " says: Meow!" << std::endl;
}
void info() const override {
Animal::info();
std::cout << "Likes to climb: " << (likesToClimb ? "Yes" : "No") << std::endl;
}
};

class Dog : public Animal {
private:
std::string favoriteToy;
public:
Dog(const std::string& name, int age, const std::string& favoriteToy)
: Animal(name, age), favoriteToy(favoriteToy) {}
void speak() const override {
std::cout << name << " says: Woof!" << std::endl;
}
void info() const override {
Animal::info();
std::cout << "Favorite toy: " << favoriteToy << std::endl;
}
};

In MiniScript, these would be defined as:
<ms>
Cat = new Animal
Cat.likesToClimb = true
Cat.create = function(name, age, likesToClimb)
c = new Cat
c.name = name
c.age = age
c.likesToClimb = likesToClimb
return c
end function

Cat.speak = function
print self.name + " says: Meow!"
end function

Cat.info = function
super
print "Likes to Climb: " + self.likesToClimb
end function

Dog = new Animal
Dog.favouriteToy = "None"
Dog.create = function(name, age, favouriteToy)
d = new Dog
d.name = name
d.age = age
d.favouriteToy = self.favouriteToy
return d
end function

Dog.speak = function
print self.name + " says: Meow!"
end function

Dog.info = function
super
print "Favourite Toy: " + self.favouriteToy
end function
</ms>

MiniScript supports prototype-based OOP through <c>[[new]]</c>, <c>[[self]]</c>, <c>[[super]]</c>, and <c>[[isa|__isa]]</c>.

[[Category:Language]]

Object-oriented programming

2025-06-05T20:42:22Z

Redspark:

Object-oriented programming

2025-06-05T20:09:06Z

Redspark: First draft not done yet.

BmfFonts.Font

2025-05-03T04:35:42Z

Redspark: Initial Page

The Font class is the one of two classes found in the [[bmfFonts]] module. It is able to load BMF font files into memory and print them to a [[PixelDisplay]].

== Methods ==
{| class="wikitable"
|-
! Method !! Description
|-
| [[bmfFonts.Font.setKern|setKern]](c1, c2, kern) || Takes two character values and records the kern spacing between them.
|-
| [[bmfFonts.Font.kern|kern]](c1, c2) || Returns the appropriate spacing between two characters. Defaults to 0 if there is no value for those two characters in the kernMap property.
|-
| [[bmfFonts.Font.load|load]](path) || Main entry point for reading a font from disk. Call this on the Font class itself (i.e. not an instance). Pass in the path to the font file and get back a new Font object.
|-
| [[bmfFonts.Font.save|save]](path) || Saves this font to disk, in either version 1.1 or version 1.2 format (depending on self.version). Note that this method ignores self.data, and creates new data from the current font attributes and character data.
|-
| [[bmfFonts.Font.charData|charData]](c) || Gets the character data for the given character. Returns null if not found. (But if it fails to find a lowercase letter, it automatically looks for the upper case version.
|-
| [[bmfFonts.Font.addChar|addChar]](c, image, relX=0, relY=0, shift=null) || Adds a new character to this font.
|-
| [[bmfFonts.Font.renderChar|renderChar]](c, g, destX=0, destY=0) || Render the given character into any drawing context 'g' which has a setPixel method.
|-
| [[bmfFonts.Font.getCharImage|getCharImage]](c) || Make and return an Image of the given character.
|-
| [[bmfFonts.Font.makeCharImage|makeCharImage]](c) || Get an Image that represents the given character. This method uses a cache, so is faster after the first call.
|-
| [[bmfFonts.Font.printChar|printChar]](c, x=480, y=320, scale=1, tint="#FFFFFF") || Render (draw) the given character to gfx, and return how far to shift the cursor. This uses the image cache, so it gets faster after the first drawing of each character.
|-
| [[bmfFonts.Font.print|print]](s, x=20, y=320, scale=1, tint="#FFFFFF") || Print the given string to gfx at the given location.
|-
| [[bmfFonts.Font.printCentered|printCentered]](s, x=20, y=320, scale=1, tint="#FFFFFF") || Print the given string to gfx at the given location.
|-
| [[bmfFonts.Font.printRight|printRight]](s, x=940, y=320, scale=1, tint="#FFFFFF") || Print the given string to gfx, right-aligned on x.
|-
| [[bmfFonts.Font.width|width]](s, scale=1) || Return the width of the given string in this font.
|-
| [[bmfFonts.Font.lenToFit|lenToFit]](s, width=100) || Return the number of characters of the given string that fit a given width.
|}

[[Category:Mini Micro]]

Import

2025-05-02T12:52:04Z

Redspark: Fixed qa page link. Removed Modules category since Import is a command and not a module. importUtil is the module and it is already under the category Sys Modules.

<c>import</c> is a function in [[Mini Micro]], [[Farmtronics]], [[command-line MiniScript]], and [[Soda]] that loads a MiniScript file from the current
directory, '''/sys/lib''', '''/usr/lib''', or some path defined in
[[env]].importPaths. <c>import</c> looks for a file with the module name plus ".ms".
Any values defined by that code then become available in a map of the same name.

== Usage Notes ==

<c>import</c> imports the named module into the current local variable space. Simple (and typical) usage is to do this at the top of your main program, where [[locals]] and [[globals]] are the same thing, which makes the imported module globally available.

However, if you have a large, complex project composed of many interdependent modules, '''and''' you want those various modules to be testable on their own, then those modules are likely to be importing other modules, in what can rapidly become a tangle of imports that leads to several problems:

# A recursive cycle of imports (e.g. A imports B which imports A) can result in an infinite loop.
# Importing a large module several times wastes time and makes your program take longer to load than necessary.
# If the module has any internal state, then you now have multiple separate copies of that internal state, which can lead to hard-to-find bugs.

The solution to all these problems is to make a function like the following:

<ms>// ensureImport: check whether the given module has been imported already
// (or is in the process of being imported). If so, return immediately.
// If not, then import that module into the global namespace.
globals.ensureImport = function(moduleName)
if globals.hasIndex(moduleName) then return
globals[moduleName] = "PENDING" // (module is being imported now)
import moduleName
globals[moduleName] = locals[moduleName]
end function</ms>

Put this in some tiny, stand-alone script that can be safely imported from anywhere. Import this with <c>import</c>, but then load all other modules with the <c>ensureImport</c> function it provides. For example, if the above function is in a script called "coreUtils":

<ms>import "coreUtils"
ensureImport "someModule"
ensureImport "someOtherOne"</ms>

This will ensure that no matter how your various files depend on each other, each one is only loaded once.

'''Note:''' This <c>ensureImport</c> function is available in the /sys/lib/importUtil standard library in Mini Micro.

== Alternate Return Value ==

Normally, all the file-scope variables (what would be <c>[[globals]]</c> if the module were loaded and run by itself) are gathered into the map referenced by the name of the module itself. However, it is possible to change this by executing a <c>[[return]]</c> statement inside the module. In this case, the name of the module will refer to whatever value you return. See [https://luminaryapps.com/blog/advanced-import/index.html this blog post] for more detail.

== Examples ==
The following example loads a script called "mathUtil.ms" (normally found in '''/sys/lib'''), and makes it available as a map called <c>mathUtil</c>.

<ms>import "mathUtil"
print mathUtil.radToDeg(2*pi) // prints 360</ms>

Some modules, like [[listUtil]], [[stringUtil]], and [[mapUtil]], extend these
built-in types with new methods. For example, the built-in [[list]]
type does not have a .reverse method, but it does once you import
"listUtil":

<ms>import "listUtil"
print [1,2,3].reverse // prints [3, 2, 1]</ms>

== Further Reading ==

* [https://luminaryapps.com/blog/advanced-import/index.html Advanced Tricks with Import] (blog post)

== See Also ==

{| class="wikitable"
|-
! Module name !! Contents
|-
| [[bmfFonts]] || BMF (bitmapped font) utilities
|-
| [[json]] || JSON utilities
|-
| [[QA|qa]] || Quality assurance (unit testing) utilities
|-
| [[listUtil]] || List utilities
|-
| [[mapUtil]] || Map (aka dictionary, hash table) utilities
|-
| [[mathUtil]] || Math utilities
|-
| [[stringUtil]] || String utilities
|-}

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

StringUtil

2025-04-05T04:58:53Z

Redspark:

In [[Mini Micro]], <c>stringUtil</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides various additional [[string]]-related functions, directly extending the [[string]] datatype.

Like all the modules in <c>/sys/lib</c>, the best documentation for stringUtil is the source code (<c>/sys/lib/stringUtil.ms</c>) itself. But this page summarizes the content in more concise form.

== Constants ==

The following values should be normally be prefixed with <c>stringUtil</c>, e.g., <c>stringUtil.smallWords</c>.

{| class="wikitable"
|-
! Name !! Value / Purpose
|-
| smallWords || list of words that should not be capitalized in a title, except as the first word
|-
| TAB || <c>char(9)</c>; tab character (advances to the next multiple of 4 spaces)
|-
| CR || <c>char(13)</c>; carriage return (moves the cursor to the start of the next line)
|-
| LF || <c>char(10)</c>; line feed (alternate line ending used in some files)
|-
| whitespace || common whitespace characters: space, TAB, CR, and LF
|}

== Added string methods ==

The following methods are added to the [[string]] type, and so are accessed using dot syntax after any string, for example: <c>"hello world".titleCase</c>

Note that because [[string]]s are immutable, none of these methods change the string they are called on; instead they return a new string (where applicable).

{| class="wikitable"
|-
! Method !! Returns
|-
| capitalized || capitalizes the first letter of the string
|-
| titleCase || capitalizes each word, except for small words
|-
| startsWith(''s'') || returns true if this string begins with ''s''
|-
| endsWith(''s'') || returns true if this string ends with ''s''
|-
| contains(''s'') || returns true if this string contains ''s''
|-
| isNumeric || returns true if this string is a valid number like "-3.1415". '''MiniMicro Only!'''
|-
| lastIndexOf(''substr'', ''beforeIdx''=null) || returns the *last* index of the given substring, optionally before a given index. Returns null if not found.
|-
| pad(''length'', ''padChar''=" ", ''cutIfTooLong''=true) || pads a string by appending the given pad char, optionally cutting it if too long
|-
| trim(''charsToRemove''=whitespace) || trims the given set of characters off both ends of the string
|-
| trimRight(''charsToRemove''=whitespace) || trims the given set of characters off the end of the string
|-
| trimLeft(''charsToRemove''=whitespace) || trims the given set of characters off the start of the string
|-
| compress(''charToCompress''=" ") || replaces any runs of a given character with a single instance of that character.
|-
| ellideEnd(''maxLength''=10) || shortens a string and appends an ellipsis if the string is too long
|-
| ellideMiddle(''maxLength''=10) || shortens a string in the middle, inserting an ellipsis
|-
| reverse || reverses the string (e.g. Hello -> olleH)
|-
| splitLines || splits a string into lines by CR, LF, or CR+LF
|-
| wrap(''width''=67) || splits the string on spaces so that each line fits within the given width
|-
| cipher(charMap) || applies a substitution cipher, using the given character map
|-
| rot13 || applies the classic [https://en.wikipedia.org/wiki/ROT13 ROT-13] substitution cipher
|-
| urlEncode || Encode a string so it can be used as a URL query parameter. '''MiniMicro Only!'''
|-
| urlDecode || convert a URL-encoded string back into plain text. '''MiniMicro Only!'''
|-
| between(''startTag'', ''endTag'', ''after''=null) || find a string between two substrings. This can be used, for example, to find text between two HTML tags.
|-
| editDistance(''s2'') || returns how many 1-character edits needed to transform this string into ''s2''
|-
| fill(''args'') || substitute values from ''args'' map into this string at places identified by "{key}". (See ''string.match'' for the inverse operation.)
|-
| match(''pattern'') || takes a ''pattern'' string that may contain fields to fill in, identified by "{key}". If the this string can be matched to that pattern, then it returns a map with the key-value pairs filled in with the corresponding parts of this string. If it can't match, then returns null. (See string.fill for the inverse operation.)
|}

== Example ==

<ms>import "stringUtil"
print "hello world".titleCase.reverse // prints: dlroW olleH</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

StringUtil

2025-04-05T04:52:35Z

Redspark: Added missing methods

In [[Mini Micro]], <c>stringUtil</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides various additional [[string]]-related functions, directly extending the [[string]] datatype.

Like all the modules in <c>/sys/lib</c>, the best documentation for stringUtil is the source code (<c>/sys/lib/stringUtil.ms</c>) itself. But this page summarizes the content in more concise form.

== Constants ==

The following values should be normally be prefixed with <c>stringUtil</c>, e.g., <c>stringUtil.smallWords</c>.

{| class="wikitable"
|-
! Name !! Value / Purpose
|-
| smallWords || list of words that should not be capitalized in a title, except as the first word
|-
| TAB || <c>char(9)</c>; tab character (advances to the next multiple of 4 spaces)
|-
| CR || <c>char(13)</c>; carriage return (moves the cursor to the start of the next line)
|-
| LF || <c>char(10)</c>; line feed (alternate line ending used in some files)
|-
| whitespace || common whitespace characters: space, TAB, CR, and LF
|}

== Added string methods ==

The following methods are added to the [[string]] type, and so are accessed using dot syntax after any string, for example: <c>"hello world".titleCase</c>

Note that because [[string]]s are immutable, none of these methods change the string they are called on; instead they return a new string (where applicable).

{| class="wikitable"
|-
! Method !! Returns
|-
| capitalized || capitalizes the first letter of the string
|-
| titleCase || capitalizes each word, except for small words
|-
| startsWith(''s'') || returns true if this string begins with ''s''
|-
| endsWith(''s'') || returns true if this string ends with ''s''
|-
| contains(''s'') || returns true if this string contains ''s''
|-
| isNumeric || returns true if this string is a valid number like "-3.1415". '''MiniMicro Only!'''
|-
| lastIndexOf(''substr'', ''beforeIdx''=null) || returns the *last* index of the given substring, optionally before a given index. Returns null if not found.
|-
| pad(''length'', ''padChar''=" ", ''cutIfTooLong''=true) || pads a string by appending the given pad char, optionally cutting it if too long
|-
| trim(''charsToRemove''=whitespace) || trims the given set of characters off both ends of the string
|-
| trimRight(''charsToRemove''=whitespace) || trims the given set of characters off the end of the string
|-
| trimLeft(''charsToRemove''=whitespace) || trims the given set of characters off the start of the string
|-
| compress(''charToCompress''=" ") || replaces any runs of a given character with a single instance of that character.
|-
| ellideEnd(''maxLength''=10) || shortens a string and appends an ellipsis if the string is too long
|-
| ellideMiddle(''maxLength''=10) || shortens a string in the middle, inserting an ellipsis
|-
| reverse || reverses the string (e.g. Hello -> olleH)
|-
| splitLines || splits a string into lines by CR, LF, or CR+LF
|-
| wrap(''width''=67) || splits the string on spaces so that each line fits within the given width
|-
| cipher(charMap) || applies a substitution cipher, using the given character map
|-
| rot13 || applies the classic [https://en.wikipedia.org/wiki/ROT13 ROT-13] substitution cipher
|-
| urlEncode || Encode a string so it can be used as a URL query parameter.
|-
| urlDecode || convert a URL-encoded string back into plain text.
|-
| between(''startTag'', ''endTag'', ''after''=null) || find a string between two substrings. This can be used, for example, to find text between two HTML tags.
|-
| editDistance(''s2'') || returns how many 1-character edits needed to transform this string into ''s2''
|-
| fill(''args'') || substitute values from ''args'' map into this string at places identified by "{key}". (See ''string.match'' for the inverse operation.)
|-
| match(''pattern'') || takes a ''pattern'' string that may contain fields to fill in, identified by "{key}". If the this string can be matched to that pattern, then it returns a map with the key-value pairs filled in with the corresponding parts of this string. If it can't match, then returns null. (See string.fill for the inverse operation.)
|}

== Example ==

<ms>import "stringUtil"
print "hello world".titleCase.reverse // prints: dlroW olleH</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

MathUtil

2025-04-05T04:23:10Z

Redspark: Added missing functions and marked some as MiniMicro only.

In [[Mini Micro]], <c>mathUtil</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides various additional math-related functions and constants.

Like all the modules in <c>/sys/lib</c>, the best documentation for mathUtil is the source code (<c>/sys/lib/mathUtil.ms</c>) itself. But this page summarizes the content in more concise form.

== Constant ==

{| class="wikitable"
|-
! Name !! Value / Purpose
|-
| mathUtil.e || [https://en.wikipedia.org/wiki/E_(mathematical_constant) Euler's number], roughly 2.718; base of natural logarithms
|}

== Methods ==

The following methods are normally accessed via the <c>mathUtil</c> prefix, e.g. <c>mathUtil.radToDeg(pi)</c>.

{| class="wikitable"
|-
! Method !! Returns
|-
| ln(''x'') || natural logarithm of ''x''
|-
| radToDeg(''radians'') || converts ''radians'' into degrees
|-
| degToRad(''degrees'') || converts ''degrees'' into radians
|-
| moveTowards(''num'', ''targetNum'', ''maxChange''=1) || returns a value closer to ''targetNum'' from ''num'', differing from ''num'' by no more than ''maxChange'')
|-
| moveTowardsXY(''mover'', ''target'', ''maxDist''=1) || like <c>moveTowards</c>, but mutates map ''mover'' to approach ''target'', each with ''x'' and ''y'' properties (e.g., a [[Sprite]])
|-
| distance(''p1'', ''p2'') || find the distance between two points; each may be a map containing ''x'' and ''y', or an [''x'', ''y''] list
|-
| lerp(''a'', ''b'', ''t'') || returns a value some portion ''t'' of the way from ''a'' to ''b''
|-
| lerp2d(''p1'', ''p2'', ''t'') || same as <c>lerp</c>, but on 2d points (maps or lists)
|-
| proportionAlongLine(''endA'', ''endB'', ''p'') || returns how far ''p'' is along the line from ''endA'' to ''endB''
|-
| nearestPointOnLine(''endA'', ''endB'', ''p'') || returns closest point to ''p'' on the line from ''endA'' to ''endB'' as an [''x'', ''y''] list
|-
| nearestPointOnLineSegment(''endA'', ''endB'', ''p'') || same as <c>nearestPointOnLine</c>, but limited to not go beyond the range from ''endA'' to ''endB''
|-
| distanceToLine(''endA'', ''endB'', ''p'') || returns distance from ''p'' to the line from ''endA'' to ''endB''
|-
| distanceToLineSegment(''endA'', ''endB'', ''p'') || same as <c>distanceToLine</c>, but limited to not go beyond the range from ''endA'' to ''endB''
|-
| lineIntersectProportion(''p1'', ''p2'', ''p3'', ''p4'') || look for an intersection between line p1-p2 and line p3-p4. Return null if none found.
|-
| lineSegmentsIntersect(''p1'', ''p2'', ''p3'', ''p4'') || return whether the line segment p1-p2 intersects segment p3-p4.
|-
| lineLineIntersection(''p1'', ''p2'', ''p3'', ''p4'') || return the point at which line p1-p2 intersects line p3-p4. If there is no intersection, this function returns null.
|-
| reflect(''vector'', ''normal'') || reflects a vector across a given normal. This does the classic "angle of incidence equals angle of reflection" thing, where the angle is measured relative to the given normal vector. '''MiniMicro Only!'''
|-
| bounceVelocity(''ball'', ''lineSeg'', ''friction''=0.1) || Calculates the new velocity of something like a ball, after colliding with a (possibly moving) line segment. '''MiniMicro Only!'''
|-
| bounceOffSegment(''ball'', ''segment'', ''friction''=0.1, ''fracBefore''=null) || Bounce a ball-like object -- which is attempting to move from ball.x-ball.vx, ball.y-ball.vy to ball.x, ball.y -- off of a line segment. '''MiniMicro Only!'''
|-
| bounceOffStaticPoly(''ball'', ''polyPts'', ''friction''=0.1) || Bounce a ball-like object -- which is attempting to move from ball.x-ball.vx, ball.y-ball.vy to ball.x, ball.y -- off of a stationary polygon with points defined by polyPts. Returns true if bounced, false if not. '''MiniMicro Only!'''
|-
| bounceOffPoly(''ball'', ''polyPts'', ''prevPolyPts''=null, ''friction''=0.1) || Bounce a ball-like object -- which is attempting to move from ball.x-ball.vx, ball.y-ball.vy to ball.x, ball.y -- off of a polygon with points defined by polyPts, possibly also moving from a previous position at prevPolyPts. Returns true if bounced, false if not. '''MiniMicro Only!'''
|-
| bounceOffMovingPoly(''ball'', ''polyPts'', ''prevPolyPts''=null, ''friction''=0.1) || Bounce a ball-like object -- which is attempting to move from ball.x-ball.vx, ball.y-ball.vy to ball.x, ball.y -- off of a polygon with points defined by polyPts, also moving from a previous position at prevPolyPts. Returns true if bounced, false if not. '''MiniMicro Only!'''
|-
| polyPerimeter(''polygon'') || returns total distance around ''polygon'' (given as list of [''x'', ''y'']] points)
|-
| polyArea(''polygon'') || returns area of ''polygon'' (given as list of [''x'', ''y'']] points)
|-
| pointInPoly(''point'', ''polygon'') || returns true if ''point'' (an [''x'', ''y''] point) is contained within ''polygon''; or if ''point'' is a list of ['x'', ''y''] points, returns true if any of those points are within ''polygon''
|-
| offsetPoly(''polygon'', ''delta'') || returns a new polygon by insetting/growing ''polygon'' by the given amount
|-
| shiftPoly(''polygon'', ''dx'', ''dy'') || returns a new polygon by translating ''polygon'' by the given amounts
|-
| rotatePoly(''polygon'', ''degrees'') || returns a new polygon by rotating ''polygon'' by ''degrees'' clockwise
|-
| randNormal(''mean''=0, ''stddev''=1) || returns a [https://en.wikipedia.org/wiki/Normal_distribution normally-distributed] random number
|-
| randRange(''min'', ''max'') || returns a random number between ''min'' and ''max''
|-
| dice(''numberOfDice''=1, ''sides''=6) || roll ''numberOfDice'' dice, each with values from 1 to ''sides'', and return the sum
|-
| clamp(''x'', ''minval''=0, ''maxval'=1) || return ''x'' limited to the range ''minval'' to ''maxval''
|-
| max(''a'', ''b'') || returns the greater of two values.
|-
| min(''a'', ''b'') || returns the lesser of two values.
|-
| numToStr(''n'', ''precision'') || convert ''n'' to a string, with a specified number of digits past the decimal place, with trailing zeros
|}

== Example ==

The following program creates a sprite, then uses <c>mathUtil.moveTowardsXY</c> to make it chase the mouse.

<ms>import "mathUtil"
s = new Sprite
s.image = file.loadImage("/sys/pics/Wumpus.png")
display(4).sprites.push s
while true
mathUtil.moveTowardsXY s, mouse, 10
yield
end while</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

ListUtil

2025-04-05T02:27:31Z

Redspark: Added missing methods

In [[Mini Micro]], <c>listUtil</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides various additional [[list]]-related functions, many of them directly extending the [[list]] datatype.

Like all the modules in <c>/sys/lib</c>, the best documentation for listUtil is the source code (<c>/sys/lib/listUtil.ms</c>) itself. But this page summarizes the content in more concise form.

== Added list methods ==

The following methods are added to the [[list]] type, and so are accessed using dot syntax after any list, for example: <c>[1, 2, 3].reverse</c>

Some of these methods mutate (modify) the list you call it on; others return a new list. See below, or the header comments in the source code, for details. Note that this is different from [[stringUtil]], where all methods return a new string (since [[string]]s are immutable).

{| class="wikitable"
|-
! Method !! Returns
|-
| contains(''item'') || true if this list contains the given ''item''
|-
| lastIndexOf(''element'', ''beforeIdx''=null) || returns the *last* index of the given element, optionally before a given index. Returns null if not found.
|-
| split(''delimiter'', ''maxCount''=null) || similar to string.split, this splits a list into sub-lists by where the given delimiter element is found.
|-
| deepCopy || returns a clone of this list, recursively cloning any sub-lists as well
|-
| add(''addend'') || mutates this list by adding elements of another list of the same size, or by adding ''addend'' to all elements
|-
| plus(''addend'') || same as <c>add</c>, but returns a new list, leaving this list unchanged
|-
| multiplyBy(''factor'') || mutates this list by multiplying elements of another list of the same size, or by multiplying all elements by ''factor''
|-
| times(''addend'') || same as <c>multiplyBy</c>, but returns a new list, leaving this list unchanged
|-
| dot(''other'') || returns sum of pairwise products of elements in this list and ''other''
|-
| reverse || mutates this list by reversing the order of its elements
|-
| reversed || returns a new list containing the elements of this one in reverse order, leaving this list unchanged
|-
| apply(''func'') || mutates this list by applying a function to every element, in place
|-
| apply1(''func'', ''arg'') || same as <c>apply</c>, but takes one extra argument
|-
| applied(''func'') || same as apply but returns a new list
|-
| applied1(''func'', ''arg'') || same as apply1 but returns a new list
|-
| mean || returns the average (sum divided by number of values) of this list
|-
| counts || returns a map that maps each unique element of this list, to the number of times that value occurs
|-
| distinct || returns a list of the unique values in this list (in arbitrary order)
|-
| product || returns the result of multiplying together all the elements in this list
|-
| min || returns the minimum value in this list
|-
| max || returns the maximum value in this list
|-
| reduce(''func'') || reduce the list to a single value by applying ''func'' to two values at a time
|-
| filter(''func'') || mutates this list by removing all elements ''x'' where ''func(x)'' is not true;
or where ''x.func'' is not true (if ''func'' is actually a string)
|-
| filter1(''func'', ''arg'') || same as ''filter'' but takes one extra argument.
|-
| filtered(''func'') || same as ''filter'', but returns a new list, leaving this list unchanged
|-
| filtered1(''func'', ''arg'') || same as ''filtered'' but takes one extra argument.
|-
| compress(''valueToCompress'') || replace each run of a given value with a single instance of that value (in place).
|-
| compressed(''valueToCompress'') || same as ''compress' but returns a new list.
|-
| valuesOf(''indexToExtract'') || returns a list containing ''elem[indexToExtract]'' for every element ''elem''
|-
| removeVal(''val'', ''removeAll''=false) || mutates this list, removing the first (or all) occurrence of ''val''
|-
| any || returns a random element of this list
|-
| swap(''index1'', ''index2'') || exchange two values in place, by their indexes
|}

== Factory methods ==

The following methods are also added to the [[list]] type, but are meant to be called as <c>list.init</c>, <c>list.init2d</c>, and <c>list.init3d</c> rather than being called on an existing list.

{| class="wikitable"
|-
! Method !! Returns
|-
| init(''size'', ''initialValue'') || list containing ''size'' elements with value ''initialValue''
|-
| init2d(''rows'', ''columns'', ''initialValue'') || 2D array containing ''rows'' rows, each with ''columns'' elements with value ''initialValue''
|-
| init3d(''sizeA'', ''sizeB'', ''sizeC'', ''initialValue'') || 3D array containing ''sizeA'' 2D arrays
|}

See also: [[matrixUtil]]

== Example ==

<ms>import "listUtil"
print [1, 2, 3].reversed // prints: [3, 2, 1]</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

Vt

2025-04-05T01:58:06Z

Redspark: Initial Page

This system module defines some special strings which, when printed on a VT100 or compatible terminal window, cause special things to happen: clear the screen, move the cursor, turn bold text on/off, etc.

== Functions ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[vt.textColor|textColor(color)]] || Sets the foreground color of the text. Specify a single number (index into the 256-color palette), or an [r,g,b] (each 255) list, or a RGB color string like "#FF8800". (In the latter two cases, we will automatically find as close match as we can in the color palette.)
|-
| [[vt.backColor|backColor(color)]] || Sets the background color of the text. Specify a single number (index into the 256-color palette), or an [r,g,b] (each 255) list, or a RGB color string like "#FF8800". (In the latter two cases, we will automatically find as close match as we can in the color palette.)
|-
|[[vt.ledOn|ledOn(n=1)]] || Turns on LEDs, if your terminal has these (most don't anymore)
|-
|[[vt.ledOff|ledOff]] || Turns off LEDS. Same as calling ledOn(0).
|}

== Properties ==

=== color ===
Map of color names (to palete index) for use with textColor and backColor. But note that you are not limited to these colors! See notes above.
{| class="wikitable"
|-
! Name !! Value
|-
| color.aqua || 51
|-
| color.black || 232
|-
| color.blue||21
|-
| color.brown||137
|-
| color.fuchsia||201
|-
| color.gray||244
|-
| color.green||34
|-
| color.lime||46
|-
| color.maroon||124
|-
| color.navy||19
|-
| color.olive||142
|-
| color.orange||214
|-
| color.pink||217
|-
| color.purple||127
|-
| color.red||196
|-
| color.silver||250
|-
| color.teal||37
|-
| color.white||255
|-
| color.yellow||226
|}

=== cursor ===
A map of cursor movement escape codes
{| class="wikitable"
|-
! Name !! Description
|-
| cursor.up(n=1) || Moves cursor up n lines
|-
| cursor.down(n=1) || Moves cursor down n lines
|-
| cursor.left(n=1) || Moves cursor left n characters
|-
| cursor.right(n=1) || Moves cursor right n characters
|-
| cursor.nextLine || Moves cursor to beginning of the next line of characters
|-
| cursor.home || Moves cursor to upper left
|-
| cursor.save || Saves cursor position and attributes
|-
| cursor.restore || Restores cursor position and attributes
|}

=== tab ===
A map of tab escape codes
{| class="wikitable"
|-
! Name !! Description
|-
| tab.set || Sets a tab stop at the current column
|-
| tab.clear || Clear a tab stop at the current column
|-
| tab.clearAll || Clears all tab stops
|}

=== text size ===
Escape codes for changing the text size
{| class="wikitable"
|-
! Name !! Description
|-
| bigTextTop || big text! Requires printing your message twice, once with the "top half" mode
|-
| bigTextBottom || and again with the "bottom half".
|-
| wide || or you can print double-wide, normal-height text.
|-
| normalSize || Turns off any of these size changes.
|}

=== clearing text ===
Escape codes to clear all or part of the screen
{| class="wikitable"
|-
! Name !! Description
|-
| clear || Clear entire screen
|-
| clearLineToRight|| Clear line from cursor right
|-
| clearLineToLeft || Clear line from cursor left
|-
| clearLine || Clear entire line
|-
| clearBelow || Clear screen from cursor down
|-
| clearAbove || Clear screen from cursor up
|-
| reset || Clears, plus also resets all state
|}

[[Category:Sys Modules]]
[[Category:Command-Line_MiniScript]]

Grfon

2025-04-05T01:12:59Z

Redspark:

GRFON is a simpler and gentler file format compared to JSON and was designed to be especially human-editable. For information on the GRFON file specification, see: https://github.com/JoeStrout/grfon/blob/main/docs/README.md

== Functions ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[grfon.parse|parse(string)]] || convert a GRFON string into a MiniScript value (which could include a list or map of other values). This is the main entry point for reading GRFON data and converting it to native form.
|-
| [[grfon.escape|escape(string)]] || Escape any special characters in the given string by preceding them with backslashes.
|-
| [[grfon.unescape|unescape(string)]] || Replaces backslash sequences in the given string with the appropriate character.
|-
| [[grfon.toGRFON| toGRFON((value, compact=false, indent=0, topLevel=true)]] || Converts a value to GRFON syntax.
|}

== Properties ==

{| class="wikitable"
|-
! Name !! Description
|-
| interpretTrueAndFalse || Flag to control whether strings "true" and "false" should be returned as 1 or 0, or left as strings.
|-
| interpretNull || Similar flag for string "null".
|}

=== Examples ===
<ms>
s = toGRFON([1, 2, "foo"], true)
</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

QA

2025-04-05T01:10:56Z

Redspark: Initial Page

This system module provides functions for helping assure the quality of your code: assert conditions that you think should always be true, or otherwise check your assumptions and report when they fail.

== Functions ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[qa.abort|abort(errMsg)]] || Prints a stack trace (optionally, after an error message), then exits the program.
|-
| [[qa.assert|assert(condition, desc)]] || Abort if the given condition is not true. Error message can include the given (optional) description.
|-
| [[qa.assertEqual|assertEqual(actual, expected, note)]] || Abort if the first two parameters are not equal. Additional descriptive note is optional.
|-
| [[qa.typeOf|typeOf(value)]] || Returns a the name of the data type as a String.
|-
| [[qa.assertType|assertType(value, type, note)]] || Abort if the first parameter is not of the specified type. Additional descriptive note is optional.
|}

=== Example ===
<ms>
import "qa"

test = function (data)
qa.assertType(data, map)
end function
</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

MatrixUtil

2025-04-05T00:52:22Z

Redspark:

This system module defines the Matrix class. A matrix is a 2D array of numbers. These have lots of uses in computer graphics. In keeping with standard programming convention, but NOT standard math convention, we use 0-base indexing. So the top-left element is 0,0.

== Class ==
{| class="wikitable"
|-
! Name !! Description
|-
|[[matrixUtil.Matrix|Matrix]] || Defines a Matrix class in global namespace.
|}

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

DateTime

2025-04-05T00:51:23Z

Redspark:

Mini Micro supports dates/times in two different formats: as a string (by default in SQL format), and as a number of seconds since a reference date (Jan 01, 2000). The numeric format is useful for doing date/time calculations, like finding the amount of time between two dates, or adding some amount of time to a starting date/time.

For details on the format specifiers: https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings .

== Functions ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[dateTime.nowVal|nowVal]] || Get the current date/time, as a number.
|-
| [[dateTime.now|now(format)]] || Return the current date/time as a string. By default, format = "yyyy-MM-dd HH:mm:ss".
|-
| [[dateTime.str|str(date, format)]] || Convert a date (string or number) to a string with the given format. By default, format = "yyyy-MM-dd HH:mm:ss".
|-
| [[dateTime.val|val(dateStr)]] || Convert a date string to a number. By default, format = "yyyy-MM-dd HH:mm:ss". If no date string is given, returns the current time (same as nowVal).
|-
| [[dateTime.year|year(date)]] || Get the year of the given date, as a number.
|-
| [[dateTime.month|month(date)]] || Get the month of the given date, as a number from 1 to 12.
|-
| [[dateTime.day|day(date)]] || Get the day of the given date, as a number from 1 to 31.
|-
| [[dateTime.hour|hour(date)]] || Get the hour of the given date/time, as a number from 0 to 23.
|-
| [[dateTime.minute|minute(date)]] || Get the minute of the given date/time, as a number from 0 to 59.
|-
| [[dateTime.second|second(date)]] || Get the second of the given date, as a number from 0 to 59.
|-
| [[dateTime.weekday|weekday(date)]] || Get the day of the week for the given date, from 0 (Sunday) to 6 (Saturday).
|}

== Properties ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[dateTime.weekdayNames | weekdayNames]] || Weekday name abbreviations, in the order returned by the weekday function. DO NOT CHANGE THESE, or the weekday function will no longer work.
|}

=== Example ===
<ms>
import "dateTime"

print "It is now: " + dateTime.now
</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

StringUtil

2025-04-05T00:50:59Z

Redspark:

In [[Mini Micro]], <c>stringUtil</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides various additional [[string]]-related functions, directly extending the [[string]] datatype.

Like all the modules in <c>/sys/lib</c>, the best documentation for stringUtil is the source code (<c>/sys/lib/stringUtil.ms</c>) itself. But this page summarizes the content in more concise form.

== Constants ==

The following values should be normally be prefixed with <c>stringUtil</c>, e.g., <c>stringUtil.smallWords</c>.

{| class="wikitable"
|-
! Name !! Value / Purpose
|-
| smallWords || list of words that should not be capitalized in a title, except as the first word
|-
| TAB || <c>char(9)</c>; tab character (advances to the next multiple of 4 spaces)
|-
| CR || <c>char(13)</c>; carriage return (moves the cursor to the start of the next line)
|-
| LF || <c>char(10)</c>; line feed (alternate line ending used in some files)
|-
| whitespace || common whitespace characters: space, TAB, CR, and LF
|}

== Added string methods ==

The following methods are added to the [[string]] type, and so are accessed using dot syntax after any string, for example: <c>"hello world".titleCase</c>

Note that because [[string]]s are immutable, none of these methods change the string they are called on; instead they return a new string (where applicable).

{| class="wikitable"
|-
! Method !! Returns
|-
| capitalized || capitalizes the first letter of the string
|-
| titleCase || capitalizes each word, except for small words
|-
| startsWith(''s'') || returns true if this string begins with ''s''
|-
| endsWith(''s'') || returns true if this string ends with ''s''
|-
| contains(''s'') || returns true if this string contains ''s''
|-
| pad(''length'', ''padChar''=" ", ''cutIfTooLong''=true) || pads a string by appending the given pad char, optionally cutting it if too long
|-
| trim(''charsToRemove''=whitespace) || trims the given set of characters off both ends of the string
|-
| trimRight(''charsToRemove''=whitespace) || trims the given set of characters off the end of the string
|-
| trimLeft(''charsToRemove''=whitespace) || trims the given set of characters off the start of the string
|-
| ellideEnd(''maxLength''=10) || shortens a string and appends an ellipsis if the string is too long
|-
| ellideMiddle(''maxLength''=10) || shortens a string in the middle, inserting an ellipsis
|-
| reverse || reverses the string (e.g. Hello -> olleH)
|-
| splitLines || splits a string into lines by CR, LF, or CR+LF
|-
| wrap(''width''=67) || splits the string on spaces so that each line fits within the given width
|-
| cipher(charMap) || applies a substitution cipher, using the given character map
|-
| rot13 || applies the classic [https://en.wikipedia.org/wiki/ROT13 ROT-13] substitution cipher
|-
| editDistance = function(''s2'') || returns how many 1-character edits needed to transform this string into ''s2''
|}

== Example ==

<ms>import "stringUtil"
print "hello world".titleCase.reverse // prints: dlroW olleH</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

MapUtil

2025-04-05T00:50:13Z

Redspark:

In [[Mini Micro]], <c>mapUtil</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides various additional [[map]]-related functions, directly extending the [[map]] datatype.

Like all the modules in <c>/sys/lib</c>, the best documentation for mapUtil is the source code (<c>/sys/lib/mapUtil.ms</c>) itself. But this page summarizes the content in more concise form.

=== Constants ===
The following values should be normally be prefixed with <c>mapUtil</c>, e.g., <c>mapUtil.fromTo</c>.

{| class="wikitable"
|-
! Name !! Value / Purpose
|-
| fromTo || generate a map from one sequence (list or string) to another. The two sequences must be the same length.
|-
|}

=== Added map methods ===
The following methods are added to the [[map]] type, and so are accessed using dot syntax after any map, for example: <c>{"Hello": "World"}.inverse</c>

{| class="wikitable"
|-
! Method !! Returns
|-
| get(''key'', ''defaultValue=null'') || look up the value for an index in this map, but if the given index is not found, return a default value instead. Works with inherited values, too.
|-
| hasValue(''v'', ''includeInherited=false'') || return true if this map contains the given value as a value (compare with built-in function .hasIndex, which checks whether this map has a given value as a key). By default this
does not walk the inheritance chain (just like .hasIndex), but
if you pass ''true'' as the second parameter, then it does.
|-
| sortedIndexes || get the indexes of this map, but in sorted order (rather than undefined order as .indexes gives you).
|-
| inverse || return a new map that has the keys and values swapped (keys of this map become values of the result map, and vice versa).
|-
| filterIndexes(''func'') || remove any indexes for which the given function does not return true.
|-
| filterValues(''func'') || remove any key/value pairs for which the function, applied to the value, does not return true.
|-
| applyToValues(''func'') || apply the given function to all values.
|-
| pairs || get all key/value pairs as a list (in arbitrary order) of little maps with "key" and "value".
|-
| swap(''key1'', ''key2'') || swap the values of two keys. Note that this may be applied to locals (or globals), enabling you to swap the values of two variables.
|-
|}

=== Example ===

<ms>import "mapUtil"
print {"Hello": "World"}.inverse //prints {"World": "Hello"}
</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

ListUtil

2025-04-05T00:49:43Z

Redspark:

In [[Mini Micro]], <c>listUtil</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides various additional [[list]]-related functions, many of them directly extending the [[list]] datatype.

Like all the modules in <c>/sys/lib</c>, the best documentation for listUtil is the source code (<c>/sys/lib/listUtil.ms</c>) itself. But this page summarizes the content in more concise form.

== Added list methods ==

The following methods are added to the [[list]] type, and so are accessed using dot syntax after any list, for example: <c>[1, 2, 3].reverse</c>

Some of these methods mutate (modify) the list you call it on; others return a new list. See below, or the header comments in the source code, for details. Note that this is different from [[stringUtil]], where all methods return a new string (since [[string]]s are immutable).

{| class="wikitable"
|-
! Method !! Returns
|-
| contains(''item'') || true if this list contains the given ''item''
|-
| deepCopy || returns a clone of this list, recursively cloning any sub-lists as well
|-
| add(''addend'') || mutates this list by adding elements of another list of the same size, or by adding ''addend'' to all elements
|-
| plus(''addend'') || same as <c>add</c>, but returns a new list, leaving this list unchanged
|-
| multiplyBy(''factor'') || mutates this list by multiplying elements of another list of the same size, or by multiplying all elements by ''factor''
|-
| times(''addend'') || same as <c>multiplyBy</c>, but returns a new list, leaving this list unchanged
|-
| dot(''other'') || returns sum of pairwise products of elements in this list and ''other''
|-
| reverse || mutates this list by reversing the order of its elements
|-
| reversed || returns a new list containing the elements of this one in reverse order, leaving this list unchanged
|-
| apply(''func'') || mutates this list by applying a function to every element, in place
|-
| apply1(''func'', ''arg'') || same as <c>apply</c>, but takes one extra argument
|-
| mean || returns the average (sum divided by number of values) of this list
|-
| counts || returns a map that maps each unique element of this list, to the number of times that value occurs
|-
| distinct || returns a list of the unique values in this list (in arbitrary order)
|-
| product || returns the result of multiplying together all the elements in this list
|-
| min || returns the minimum value in this list
|-
| max || returns the maximum value in this list
|-
| reduce(''func'') || reduce the list to a single value by applying ''func'' to two values at a time
|-
| filter(''func'') || mutates this list by removing all elements ''x'' where ''func(x)'' is not true;
or where ''x.func'' is not true (if ''func'' is actually a string)
|-
| filtered(''func'') || same as ''filter'', but returns a new list, leaving this list unchanged
|-
| valuesOf(''indexToExtract'') || returns a list containing ''elem[indexToExtract]'' for every element ''elem''
|-
| removeVal(''val'', ''removeAll''=false) || mutates this list, removing the first (or all) occurrence of ''val''
|-
| any || returns a random element of this list
|}

== Factory methods ==

The following methods are also added to the [[list]] type, but are meant to be called as <c>list.init</c>, <c>list.init2d</c>, and <c>list.init3d</c> rather than being called on an existing list.

{| class="wikitable"
|-
! Method !! Returns
|-
| init(''size'', ''initialValue'') || list containing ''size'' elements with value ''initialValue''
|-
| init2d(''rows'', ''columns'', ''initialValue'') || 2D array containing ''rows'' rows, each with ''columns'' elements with value ''initialValue''
|-
| init3d(''sizeA'', ''sizeB'', ''sizeC'', ''initialValue'') || 3D array containing ''sizeA'' 2D arrays
|}

See also: [[matrixUtil]]

== Example ==

<ms>import "listUtil"
print [1, 2, 3].reversed // prints: [3, 2, 1]</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

Json

2025-04-05T00:49:07Z

Redspark:

In [[Mini Micro]], <c>json</c> is an [[import]] module in the <c>/sys/lib</c> directory. It provides conversion of MiniScript values to and from [https://www.json.org/ JSON] format, as well as some related utility functions.

Like all the modules in <c>/sys/lib</c>, the best documentation for the json module is the source code (<c>/sys/lib/json.ms</c>) itself. But this page summarizes the content in more concise form.

== Functions ==

After [[import|importing]] "json", the following methods may be accessed under the <c>json</c> map (e.g. as <c>json.parse</c>).

{| class="wikitable"
|-
! Method !! Purpose
|-
| parse(''jsonString'') || parses JSON data into native MiniScript values
|-
| toJSON(''value'', ''compact''=false, ''indent''=0) || converts MiniScript values into JSON format
|-
| hexToInt(''s'') || convert hexadecimal string (e.g. "002A") to the equivalent number (42)
|-
| escape(''s'') || change special characters into backslash sequences
|-
| unescape(''s'') || replace backslash sequences with normal characters
|}

== Examples ==

The following example builds a simple MiniScript data structure, then writes this out to a file in JSON format.

<ms>import "json"

data = {"name":"Alice", "job":"Engineer"}
data.kids = []
data.kids.push {"name":"Billy", "age":8}
data.kids.push {"name":"Mary", "age":12}

f = file.open("data.json")
f.write json.toJSON(data)
f.close</ms>

The example below reads and parses the JSON file created above, then prints out the age of the first child.

<ms>import "json"

data = json.parse(file.open("data.json").read)
print data.kids[0].age</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

ImportUtil

2025-04-05T00:48:33Z

Redspark:

This system module provides a single global function to help with importing other modules into larger programs. See [[Import]] for more information.

== Global Function ==
{| class="wikitable"
|-
! Name !! Description
|-
| [[ensureImport|ensureImport]] || Imports a module into the global scope. This ensures that the module is imported only once.
|}

=== Example ===
<ms>
import "importUtil"
ensureImport "events"
</ms>

[[Category:Sys Modules]]
[[Category:Mini Micro]]
[[Category:Command-Line_MiniScript]]

MathUtil

2025-04-05T00:46:55Z

Redspark:

MatrixUtil

2025-04-01T02:53:05Z

Redspark: Initial Page

This system module defines the Matrix class. A matrix is a 2D array of numbers. These have lots of uses in computer graphics. In keeping with standard programming convention, but NOT standard math convention, we use 0-base indexing. So the top-left element is 0,0.

== Class ==
{| class="wikitable"
|-
! Header text !! Header text
|-
|[[matrixUtil.Matrix|Matrix]] || Defines a Matrix class in global namespace.
|}

[[Category:Mini Micro]]
[[Category:Sys Modules]]

Json

2025-03-31T17:24:12Z