website/content/faq.md

---
title: "Frequently Asked Questions"
draft: false
toc: true
---
About Sketchy Maze.

# General

## What is _Sketchy Maze?_

It is a "drawing-based maze game" themed around hand-drawn maps on paper.
It's one part 'yet another 2D platformer game', one part 'Mario Maker but you can
make whatever you want', and part educational game in that it might help teach
someone to code so they can program their own custom doodads to use with their
levels.

With _Sketchy Maze_, you may draw your own levels and then play them as a
side-scrolling platformer game. You may draw maps freehand or with some basic
drawing tools (like rectangles and ellipses), specify which color lines are
"solid" and which behave like "fire" or "water," and then drag and drop various
"doodads" such as buttons and doors onto your map to add some interactive elements.

If you're not much of a level designer, fear not! The game will also feature some
built-in levels that you can play and get some inspiration from. You will
also be able to play custom maps created by others, which may come with their
own custom doodads attached ([details](/register)).

## What devices can I play it on?

_Sketchy Maze_ is first and foremost a videogame for **desktop operating systems.**
It should run on any GNU/Linux, Microsoft Windows or Apple macOS computer. It also
happens to run on Linux smartphones and is mostly playable at screen resolutions as
narrow as 375x750.

I currently package releases of the game for:

* **Windows** (64-bit and 32-bit)
* **Mac OS** (Intel 64-bit only for now!)
* **GNU/Linux**
  * Flatpak (x86_64 and aarch64) should work across all modern Linux distributions.
  * Native packages (x86_64, i386, and aarch64) for Fedora-likes (.rpm) and Debian-likes (.deb) and .tar.gz
  * Works on Linux smartphones like the Pinephone and Librem 5!

Some places I could see it going in the future:

* **Android:** I saw an [example app](https://github.com/veandco/go-sdl2-examples/tree/master/examples/android)
  how to run a Go SDL2 program like mine on Android but its documentation seems outdated and I haven't
  figured it out yet. I'm using my Pinephone to plan a mobile/touch friendly UI but Android is a
  likely target at some point.
* The **[Steam Deck](https://store.steampowered.com/steamdeck/):** _Sketchy Maze_ has some joystick
  control support and with a little more love this Nintendo Switch-like device could be an amazing
  host to my game! I don't own a Deck but try and see if my game can run on it,
  [let me know](https://www.kirsle.net/contact) how it goes!

## What are "doodads?"

![Bird](https://www.sketchymaze.com/guidebook/images/doodads/bird.gif)
![Snake](https://www.sketchymaze.com/guidebook/images/doodads/snake.gif)
![Button](https://www.sketchymaze.com/guidebook/images/doodads/button-a.gif)
  ![Electric Door](https://www.sketchymaze.com/guidebook/images/doodads/electric-door.gif)

Doodads are the dynamic objects you drag and drop into your level to make
it "do" things. They are the Buttons, Switches, Trapdoors, and other traps
and hazards to create puzzles and perilous platforming sections of your
level.

The game ships with a handful of [built-in doodads](/guidebook/doodads.html)
and players may also [create their own](/guidebook/custom-doodads/index.html),
and [program their behavior](/guidebook/custom-doodads/scripts.html) using
JavaScript.

## Do I need to learn how to program?

Nope! You can just draw some levels and use pre-made doodads in them. The "1.0"
version of the game is expected to include a proper set of single player levels
that can simply be _played_ so you don't even need to draw your own level if
you're not feeling creative.

You can also create some useful custom doodads in-game by selecting from a
"generic script" to drive its behavior. For example, you could draw a "spikes"
doodad and choose the "Generic Fire" script and it will act as a hazard to
the player in-game: "Watch out for spikes!"

## How do I program a custom doodad?

There are some [full example doodads](https://code.sketchymaze.com/declassified/doodads)
that you can learn from for creating your own custom Warp Doors or
playable characters similar to the ones the game ships with.

You may also peek at [the game's built-in doodad sources](https://code.sketchymaze.com/game/assets)
to see how they're programmed if you want to make something similar.

You may also pick from a built-in generic script for your doodad, and then
download the script out of your doodad to use as a starting place to
customize it.

See the [Doodad Scripts](/guidebook/custom-doodads/scripts.html) documentation
that came in the game's Guidebook and the
[full JavaScript reference](/guidebook/custom-doodads/api-reference.html)
for more information.

## The user interface is ugly!

I find the "Windows 95" look charming.

Along with this game I'm also developing my own user interface toolkit from
scratch, with a simple API inspired by the [Tk toolkit](https://www.tcl.tk/).
It happens that the "Windows 95" look is easy to draw programmatically, as
a button is just a few rectangles overlapped to draw shadows and highlights.

The user interface toolkit is released as a
[free and open source](#is-this-game-open-source) module that other Go
developers can use to draw buttons, menus and other UI controls into a
graphical application. One day, the UI toolkit will support fancy theming
of widgets, and _Sketchy Maze_ will very easily look better (or have
user-configurable themes available to choose from).

## Why does my launcher icon have an orange logo?

<img src="/images/pinephone-apps-crop.png"
    style="cursor: pointer"
    onClick="this.src = this.src.indexOf('crop') > -1 ? '/images/pinephone-apps.png' : '/images/pinephone-apps-crop.png'">

Since version 0.13.0, Flatpak builds for Linux are now using an orange
version of the launcher icon. This is mostly because I install both the
Flatpak and the native (rpm/deb) package simultaneously and it was hard to
tell which version is which!

---

# Known Issues

While the game is still in beta, it's bound to have some bugs. Tell me about
any you find at <a href="mailto:support@sketchymaze.com">support@sketchymaze.com</a>.

Some current known issues and work-arounds are as follows:

## Zoom in/out bugs

If you draw onto your level while zoomed in or out, the pixels that get committed
to the level may be offset from where the preview was on-screen. Draw some test
lines to find out the offset or else avoid drawing while zoomed. The 1 (one) key
restores the zoom level to default 100%.

# Pricing and Distribution

## Is this game free?

Yes!

While the game is in beta, all releases are **100% free and fully functional.**

After the game reaches "1.0" it will have a free version and a paid one
which unlocks additional modding capabilities, like the ability to embed
custom doodads in your levels. I like Minecraft's model of "buy the game
once, free updates forever" and will do similar.

The full version would mainly add quality-of-life improvements supporting
custom user content, such as the ability to play a custom level which
_comes with_ all of its custom doodads, wallpaper, and other assets
embedded directly inside the level file.

The free versions of the game would include:

* One chapter of built-in single player levels.
* The level editor where you can create and share your own custom maps, using
  the [built-in doodads](/guidebook/doodads.html) that the game shipped with.
  You can also play levels created by other players as long as they use the
  built-in doodads only, or uses custom doodads the player has installed
  locally.

Paid versions of the game will include _additional_ features such as:

* Additional chapters of built-in single player levels.
* Better support for **custom doodads**: when sharing your level with others,
  you may embed all custom doodads _inside_ of the level so that it can be
  easily played on a different computer, and the ability to play such
  levels (the free version won't use embedded custom doodads).
* Possibly some access to online account features (in-game UI to share and
  download levels and doodads made by others, etc.)

It is expected that the full set of built-in doodads will be equally available
in free versions of the game. And these doodads should be varied and featureful
enough to create all sorts of custom and creative levels, which can be shared
with other players.

## Will the game feature any form of Digital Rights Management (DRM)?

I hate DRM, so I don't expect so.

Likely, the same program .exe will use "free version" features by default
until registered as a paid version, with any of these options:

* With a license key file for offline activation.
* If it gets online services, by logging into an account associated with your
  purchased copy of the game (provable by the license key file).
* If released on Steam or other managed store, a check with the store's API
  following their standard procedure.

But the plan is that the "license key file for offline activation" _always_
be available. You get a proof file that you can keep forever and any version
of the game that accepted it before will always do so. That way even if I got
hit by a bus or you lost your Steam account, the game can still be played to
its full potential.

## What about piracy?

When I start to discover license keys which have leaked online to game piracy
websites, _future_ releases of Sketchy Maze will begin to include license
revocation lists and will cease honoring the compromised license key.

The compromised license key would still work on all _older_ versions of the game,
but would be barred from newer releases; and while the game is still being
actively worked on and gaining new features, these leaked keys would become less
interesting over time, as custom user content made for newer versions of the game
would become incompatible with the older versions.

If the game gets online services in the future (e.g. for seamless in-game
sharing of custom levels and doodads), players would need a valid signed
license key to log on and these leaked keys would be excluded.

---

# Level Creators

## Future planned features vs. levels created today

While in beta, this game is sort of evolving as it goes and some features added
later may break or affect custom levels created today. As a general rule of
thumb: the game's built-in levels are expected to _mostly_ keep working as the
game is developed further as I don't want to create too much more work for
myself revisiting old levels to fix them up.

Here are a few current quirks in the game and how they're going to be handled
in the future:

### Enemy mobs being invulnerable to fire pixels

Currently, fire pixels only kill the player character but enemy mobs can walk
through them unscathed.

Eventually, fire pixels will be able to destroy enemy mobs and the mobs will
_try_ and avoid walking into fire but if they fall into it on accident they'll
be destroyed.

Planned feature: a "Fireproof Mobs" Game Rule, so existing maps that have lava
pits and dumb mobs (like Azulian Tag, where the Azulians chase the player to
Hell and back) will be able to gain backwards compatibility by toggling a
game rule on.

### Jump height and reach

The platforming physics and player controls may be tweaked still but generally
the player's jump height and reach will be kept close to its current state.
Use the built-in levels for inspiration.

### Multiplayer features

The game may eventually have multiplayer features where you can design a map
meant to be played by two or more players. Doodad Script functions such as
`Actors.FindPlayer()` will operate on the _nearest_ player character and try
and maintain backwards compatibility for maps made today.

---

# Technicals

## What is this game built with?

_Sketchy Maze_ runs on a custom game engine, built from the ground up, in the
[Go](https://golang.org) programming language and using [SDL2](https://www.libsdl.org/)
for graphics, sound, gamepad and other basic features via the
[veandco/go-sdl2](https://github.com/veandco/go-sdl2) bindings for Go.

While the game itself is not open source (yet), some of its critical components are
released as free and open source projects that other developers can use in
their projects.

## Is this game open source?

Parts of it are!

_Sketchy Maze_ was built from the ground up using little more than
[SDL2](https://www.libsdl.org/) which lets you plot pixels on a screen. While
I was designing the game, I thought it'd be a good idea to write an abstraction
layer between low-level SDL2 functions and give me a clean, Go-like API to work
with that keeps my code from either _depending_ too much on SDL or for my Go
code to be written too much like C to work with its raw API.

So I built my own [render](https://git.kirsle.net/go/render) library that
abstracts around SDL2 for desktops (and HTML Canvas elements for WebAssembly),
and my game needed UI buttons so I wrote a [UI toolkit](https://git.kirsle.net/go/ui)
which provides Labels, Buttons, Menus, Windows, and all sorts of useful widgets
to draw my user interface with. The render engine can be extended to target
other APIs in the future, such as OpenGL or Vulkan, as needs arise.

Here are a list of open source projects released as a part of development of
_Sketchy Maze_ which should be generally useful to any Go developers for making
some simple graphical applications.

* [go/render](https://git.kirsle.net/go/render): Render engine supporting SDL2
  (native apps) and HTML Canvas (WebAssembly) targets.
* [go/ui](https://git.kirsle.net/go/ui): Go UI toolkit for adding labels, buttons,
  windows, menus, and more widgets and arranging them sanely in frames with an
  API like Tcl/Tk. It uses go/render so can also target WebAssembly.
* [go/audio](https://git.kirsle.net/go/audio): Simple audio abstraction which can load and play music or sound effects, currently only SDL2 supported.

GitHub mirrors of the above:

* [SketchyMaze/render](https://github.com/SketchyMaze/render)
* [SketchyMaze/ui](https://github.com/SketchyMaze/ui)

Also this website, the user guidebook, and other things with the game are
readable as open source code, at https://code.sketchymaze.com/

## Wait, does _Sketchy Maze_ have a WebAssembly port?

Sure does! But performance isn't great yet, and I'm not sure whether WebAssembly
support in web browsers needs to get better or if I need to tighten up my code.
There _is_ a lot of room for optimization in my UI toolkit, to minimize the number
of draw calls per tick.

One day I might have a "demo this game right in your web browser" feature with a
(probably stripped-down) version of the game built for WebAssembly. So far, though,
it just freezes web browsers frequently and I'm not letting you see it yet.

## Is it coming to Android or iOS?

An Android app is the most likely one of these, but it may be a while out (after the
"1.0" release). The game is primarily meant for desktop-sized displays, but it
also runs as-is on GNU/Linux smartphones like the Pinephone, so I am testing
the game on that to make sure it _mostly_ works on that size of screen, if only a
bit awkwardly.

I have some resources on how I might compile my game as an Android app, but I
haven't found any info on how one compiles a Go SDL2 app for iOS; and I don't
own any of the hardware needed to develop for iOS anyway.