But there is one omission that is sometimes a source of complaints: MiniScript, as of now, does not have math-assignment operators like += and -=. ]]> Sat, 22 Oct 2022 12:00:00 -0700 <>blog/retained-vs-immediate <>blog/retained-vs-immediate A Mini Micro user today asked me to explain why it was designed with sprites that are retained between frames, instead of having users explicitly draw them on each frame. This is an insightful question! It's the difference between retained mode and immediate mode graphics.

What ensued was an abnormally long debugging session. I tried confessional debugging; I tried walking through the code; I tried checking my assumptions by having the code print out what it was doing. After 20 minutes of this I was still stumped. In desperation, I reached for a tool I should have brought out much faster: the validate method.

The answer is, yes and no. There is no built-in API for it, but in most cases, it can be done with an ancient set of tricks known as VT100 escape codes.

It's a perfectly valid question, so in this post I will try to clarify. My purpose is not to convince anyone of anything, but to explain why, after years of using other scripting languages, I felt compelled to create something new. I'll do this without attacking other languages, since every language has its fans and I don't want to kick anybody's dog; instead I'll focus on what I think is really cool about MiniScript, and how it offers a collection of advantages that, taken together, can't be found anywhere else. ]]> Fri, 06 Sep 2019 12:00:00 -0700 <>blog/miniscript-open-source <>blog/miniscript-open-source MiniScript has been available as a Unity plugin since 2017. But it has been such a success with its users that it deserved wider distribution. MiniScript in Unreal games, MiniScript on the command line, MiniScript in your browser... why not? And while it was great to get a little financial support for working on MiniScript in the early days, in the long run keeping it commercial only slows down its adoption. That's why, as of today, MiniScript is open-source.

But at some point you may need to use some part of the extensive "Oculus Platform" SDK. This provides information about the current user, such as their Oculus username, and also provides all manner of match-making and social services, including efficient voice (VoIP) chat. Unfortunately, accessing this SDK isn't nearly as simple as you might expect. This post explains how to do it.

Then I made a DailyPurge folder, and my whole life changed.

But I recently discovered that this is not true! Making configurable, hot-swappable input in Unity can be done without any plug-ins, and it's not even all that difficult. Read on to see how.

Just sticking a music clip on an AudioSource in the scene would accomplish that, but the music would cut off abruptly when you change scenes, which is jarring and unprofessional.  Much better to fade it out over several seconds.  That requires not letting the object be destroyed when the scene changes, and handling the scene-change event — which thanks to recent changes in the Unity API, is not as easy as it used to be.

So, how do you actually implement them?  This post explains how we do it in our Unity games.

In this post, I'll give you well-encapsulated code for a PID controller in C#, and show how to use this in Unity to control the throttle of a hovercar.  The hovercar physics involves momentum, drag, and controls that don't respond instantly, just like a real hovercar!  But the PID controller doesn't care about any of that; once you have the three constants tuned, and hook up the error signal (in this case, the difference between the current altitude and the altitude you want), it does the rest.

You could certainly spread the code to do those things out into different classes or methods, triggered by events or other custom code.  I've certainly been known to do that; I love Unity Event, and most of my classes that do anything over time expose events for when they start and finish their work, making it easy to chain them together.

But sometimes, dividing up the logic that way makes the code less clear, not more.  There may be one place in the code that is handling everything related to this set of actions, and the only thing driving the code apart is that you want it to happen at different times.

CallLater was created to handle just this situation.  It lets you write some code, right there in the middle of a method, to actually be run later, after whatever delay you specify.

The big players in the serialization space are JSON and XML.  XML is, to be blunt, horrible.  It's fine for data that is only ever looked at by computer programs, but for anything that might be read or written by a human, it's just awful.  JSON is much better, and it's what we've often used in the past.  But it too has more syntax than feels necessary.  And at the same time, it lacks some features we really wanted, like comments.

So we have designed a new serialization format: GRFON (General Recursive Format Object Notation).  We've been using it for over a year now, and loving every minute of it.  And today, we are making it available for everyone else to use too, under the permissive MIT open-source license.

In C/C++, it's easy enough to use the standard __DATE__ macro, which the C preprocessor fills in with the actual build date.  You can just display this on the title screen or wherever, and testers can easily see whether they're running the latest build.  But, surprisingly, C# doesn't have any such feature.  This makes displaying the build date in a Unity app a bit harder.

Fortunately, it can be done.  Here is the arcane magic you need.

This turns out to be a surprisingly thorny problem in Unity.  There is a simple script on the Unity wiki called Triangulator, but it only works with Vector2D and doesn't support holes.  I found a blog post on Advanced Triangulation in Unity, but it was neither sufficiently advanced (only works in the XY plane) nor actually in Unity (it wrote each polygon out to a file, invoked an external command-line tool to do the triangulation, and then read the result back in).

The utility referenced in that blog post is called Triangle, which is widely regarded as a very good triangle library.  It's open-source C code, so one could make a Unity plugin out of it.  But it's not licensed for commercial use, which is a problem for this project.  Also, making a native plugin means setting up a build chain for every platform you want to support.  For both reasons, I kept looking — I really wanted something in pure C#.

To help clarify the pros and cons, I built a 2D game character using three different approaches:

1. A simple home-grown animation system that eschews Unity's built-in animation support completely.
2. Use of Unity animations, but without using the Animator state machine; instead each animation is invoked directly from code.
3. Full use of the built-in Unity components, with all game logic in the state machine, and only minimal supporting code.

For the rest of the story, see the full article on Gamasutra!

While this was a fun and educational video, it uses UnityEvents in a very odd way, wrapping them in a string-based notification system and hooking everything up in code. Honestly, you could have done exactly the same thing using standard C# events, and it wouldn't have made any difference. (Indeed, prior to UnityEvent, many Unity developers — myself included — did exactly that.)

So I decided to make my own video, accomplishing the same demo but using UnityEvent the way nature intended. The result is a lot less code, easier to maintain, and harder to screw up.

However, the code-run-test-debug cycle is slower in Unity than I would like for his purposes.  Learning a language is easier when you can play around with it interactively.  This is especially true when you're working through small programming problems like those at Project Euler.

The new version contains an important fix for problem on iOS 6 that would cause it to abruptly exit.

Also, if you're running on iOS 6, we now use Apple's new standard sharing dialog to share your drawings via Facebook, Twitter, email, etc., as well as copy them to the clipboard or send them to your network printer.

The new update is recommended for all InkPaint users.  And if you're not using InkPaint already, please check it out — we are sure you will love how easy and fast it is to create professional-quality drawings.

A common pattern for iPhone apps is a tab bar on the bottom, with a navigation stack on each tab. Today, we'll look at how to set up such a structure in code.  (And we'll do it in pure, unsweetened Cocoa for that nostalgic old-school feel.)

We expect this to be the most controversial feature of the whole BOSS design, so it's worth some time to explain all the considerations behind it, why we made this decision, and what the heck "lazy" and "greedy" mean when it comes to string searching anyway.

So, we at Luminary Apps have begun work on a string matching library that combines the best features of PEG and RegEx. This blog post is the first public discussion of that library. It's called BOSS, and I think you're going to love it.

Well, that was three weeks ago. I've had time to do some more serious research, and it turns out that there is some modern work that is very relevant. It almost fits exactly what we were looking for — but not quite. It's a new construct called Parsing Expression Grammar.

Today we released a new version of InkPaint for iPad.  We're very pleased with InkPaint 1.1, and glad to get it to our users, but behind its release is an interesting story — and a cautionary tale for other developers.

I know, these "welcome" posts aren't terribly useful, but they're customary.  So, since you're here, let me tell you a bit about who we are and what we do.