Explode() and Simple Scripting

The exciting-sounding explode() function you find in many languages is far more mundane than it sounds. explode() simply takes a string and a delimiter and breaks it up into a list of strings using the delimiter. In other words:

explode("abc,123",",") yields ["abc","123"]

There is no real equivalent to this in Lingo, although you can set the itemDelimiter and refer to and count the items of a string. Unfortunately, you can't just get a list that you can work with directly. Below is the code to do it for you which you can cut and paste:

on explode t, delimiter, terminator l = [] repeat while t <> "" o = offset(delimiter, t) if (o = 0) then -- not found additem = t else if (o = 1) then additem = "" else additem = t.char[1..(o-1)] end if if (additem starts terminator) then -- it's a comment; kill the rest -- delete char 1 to additem.length of t exit repeat else if additem = "" then -- it's empty else delete char 1 to additem.length of t if (addItem.char[1] = "!") then delete char 1 of addItem addItem = value(addItem) end if l.add(additem) end if delete char 1 to delimiter.length of t end repeat return l end explode

Here, t is the text string you want to explode, delimiter is the delimiter you want to split the text string using, and terminator is an optional line terminator, handy for stripping off comments and such at the ends of lines.

Note that this explode() routine strips out empty strings, so that if you have multiple delimiters in a row, or delimiters at the front or end of the string, you don't get empty strings in the returned list. This may be unexpected behavior if you're used to an implementation of explode() in another coding environment.

This code also has a handy feature in that if an item starts with a bang ("!"), it takes the value() of the item (sans the bang) and passes it back. If you don't want your explode() function to do that, just strip out that piece, or don't start items with a bang.

Simple Scripting with Explode()

I often use explode()-ed strings as the basis of a quick-and-dirty internal scripting language for games. Using a text member and the explode() function, you can quickly make a set of commands to follow that separate your code from higher-level scripts. This is especially handy if you want to just edit text files to change the game behavior, rather than recompiling.

For instance, you might want to have cutscenes in your game. If it's simple and doesn't require you to develop an editor for cutscenes, you may be able to get away with simple text scripts like so:

move barbarian south !2 speak barbarian Die, puny southlander! stance southlander afraid speak southlander Don't hurt me! speak barbarian Okay.

In this case, you can easily use explode() to convert each tab-delimited line into a command and its parameters. (Even if you don't use this technique in your final game, it's a handy thing to have around during development.) Here's code that will do this for you:

on explodeLines t finalLines = [] repeat while t <> "" tlstr = t.line[1] delete line 1 of t tl = explode(tlstr, tab, "--") if (tl.count = 0) then next repeat else tl[1] = symbol(tl[1]) finalLines.add(tl) end if end repeat return finalLines end explodeLines

If you were to pass the above script to explodeLines(), it would return a list of commands back to you. The commands would look like this:

[#move, "barbarian", "south", 2] [#speak, "barbarian", "Die, puny southlander!"] [#stance, "southlander", "afraid"] [#speak, "southlander", "Don't hurt me!"] [#speak, "barbarian", "Okay."]

You can now easily step through this script by checking the first element as the action to take, and the following elements as parameters for that action. Because of the "--" terminator and collapsing empty entries, you can also include as many tabs as you want and lingo-style comments at the end of lines or in their own lines.