Salet tutorial
+
+
+
+
+ Intro here.
+ + +
-
-
The game was written by Oreolek.
- -Approximate play time: five minutes.
-Written using Salet. +
The game was written by (you should put your name here)
+Approximate play time: not measured.
+Written using Salet.
+Betatesting credit: none yet
@@ -44,6 +70,27 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/lib/dialogue.coffee b/lib/dialogue.coffee
new file mode 100644
index 0000000..ae6c697
--- /dev/null
+++ b/lib/dialogue.coffee
@@ -0,0 +1,33 @@
+room = require("./room.coffee")
+
+randomid = () ->
+ alphabet = "abcdefghijklmnopqrstuvwxyz0123456789" # see the dreaded linkRe expression in Undum
+ rndstr = []
+ for i in [1..10]
+ rndstr.push alphabet.charAt(Math.floor(Math.random() * alphabet.length))
+ return rndstr.join('').toString()
+
+###
+A dialogue shortcut.
+Usage:
+
+ dialogue "Point out a thing in her purse (mildly)", "start", "mild", """
+ Point out a thing in her purse (mildly)
+ """, "character.sandbox.mild = true"
+###
+dialogue = (title, startTag, endTag, text, effect) ->
+ retval = room(randomid(), {
+ optionText: title
+ content: text
+ choices: "#"+endTag
+ })
+ if typeof(startTag) == "string"
+ retval.tags = [startTag]
+ else if typeof(startTag) == "object"
+ retval.tags = startTag
+ if effect?
+ retval.before = (character, system) ->
+ eval(effect)
+ return retval
+
+module.exports = dialogue
diff --git a/lib/interface.coffee b/lib/interface.coffee
new file mode 100644
index 0000000..bc58d84
--- /dev/null
+++ b/lib/interface.coffee
@@ -0,0 +1,14 @@
+###
+Salet interface configuration.
+###
+$ = require("jquery")
+
+$(document).ready(() ->
+ $("#ways").on("click", "a", (event) ->
+ event.preventDefault()
+ undum.processClick($(this).attr("href"))
+ )
+ $("#inventory").on("click", "a", (event) ->
+ event.preventDefault()
+ )
+)
diff --git a/lib/markdown.coffee b/lib/markdown.coffee
new file mode 100644
index 0000000..9b09980
--- /dev/null
+++ b/lib/markdown.coffee
@@ -0,0 +1,32 @@
+###
+Indent normalization. Removes tabs AND spaces from every line beginning.
+Implies that you don't mix up your tabs and spaces.
+Copyright 2015 Bruno Dias
+###
+normaliseTabs = (text) ->
+ lines = text.split('\n');
+ indents = lines
+ .filter((l) => l != '')
+ .map((l) => l.match(/^\s+/))
+ .map((m) ->
+ if (m == null)
+ return ''
+ return m[0]
+ )
+ smallestIndent = indents.reduce((max, curr) ->
+ if (curr.length < max.length)
+ return curr
+ return max
+ )
+ return lines.map((l) ->
+ return l.replace(new RegExp('^' + smallestIndent), '')
+ ).join('\n')
+
+markdown = (text) ->
+ if typeof text is Function
+ text = text()
+ return marked(normaliseTabs(text), {
+ smartypants: true
+ })
+
+module.exports = markdown
diff --git a/lib/obj.coffee b/lib/obj.coffee
new file mode 100644
index 0000000..febdb05
--- /dev/null
+++ b/lib/obj.coffee
@@ -0,0 +1,33 @@
+markdown = require('./markdown.coffee')
+undum = require('undum-commonjs')
+$ = require("jquery")
+objlink = (content, ref) ->
+ return "#{content}"
+
+class RaconteurObj
+ constructor: (spec) ->
+ for key, value of spec
+ this[key] ?= value
+ level: 0
+ look: (character, system, f) ->
+ if @dsc
+ text = markdown(@dsc.fcall(this, character, system, f))
+ text = "" + text + ""
+ window.name = @name
+ text = text.replace /([\s^])\{\{(\w+)\}\}([\s$])/g, (str, p1, p2, p3) ->
+ name = window.name
+ window.name = undefined
+ return p1+objlink(p2, name)+p3
+ return text
+ take: () -> "You take the #{@name}." # taking to inventory
+ act: () -> "You don't find anything extraordinary about the #{@name}." # object action
+ dsc: () -> "You see a {{#{@name}}} here." # object description
+ put: (room) ->
+ @level = 0 # this is scenery
+ undum.game.situations[room].objects[@name] = this
+
+obj = (name, spec) ->
+ spec ?= {}
+ spec.name = name
+ return new RaconteurObj(spec)
+module.exports = obj
diff --git a/lib/oneOf.coffee b/lib/oneOf.coffee
new file mode 100644
index 0000000..051e129
--- /dev/null
+++ b/lib/oneOf.coffee
@@ -0,0 +1,170 @@
+###
+oneOf.js
+
+Copyright (c) 2015 Bruno Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+###
+
+###
+ Undularity Tools
+
+ Those functions are not a core part of Undularity, but provide some
+ general functionality that relates to adaptive text generation.
+
+ This is provided partly as a helper to less technical users, and as
+ a convenience for authors.
+###
+
+# Monkey patching
+
+###
+ Shuffles an array. It can use Undum's random number generator implementation,
+ so it expects a System.rnd object to be passed into it. If one isn't
+ supplied, it will use Math.Random instead.
+
+ This is an implementation of the Fischer-Yates (Knuth) shuffle.
+
+ Returns the shuffled array.
+###
+
+Array.prototype.shuffle = (system) ->
+ rng = if system then system.rnd.random else Math.random
+ # slice() clones the array. Object members are copied by reference, beware.
+ newArr = this.slice()
+ m = newArr.length
+
+ while (m)
+ i = Math.floor(rng() * m--)
+ t = newArr[m]
+ newArr[m] = newArr[i]
+ newArr[i] = t
+
+ return newArr
+
+###
+ oneOf()
+
+ Takes an array and returns an object with several methods. Each method
+ returns an iterator which iterates over the array in a specific way:
+
+ inOrder()
+ Returns the array items in order.
+
+ cycling()
+ Returns the array items in order, cycling back to the first item when
+ it runs out.
+
+ stopping()
+ Returns the array items in order, then repeats the last item when it
+ runs out.
+
+ randomly()
+ Returns the array items at random. Takes a system object, for consistent
+ randomness. Will never return the same item twice in a row.
+
+ trulyAtRandom()
+ Returns the array items purely at random. Takes a system object, for
+ consistent randomness.
+
+ inRandomOrder()
+ Returns the array items in a random order. Takes a system object, for
+ consistent randomness.
+###
+
+###
+ Takes a function and gives it a toString() property that calls itself and
+ returns its value, allowing for ambiguous use of the closure object
+ as a text snippet.
+
+ Returns the modified function.
+###
+stringish = (callback) ->
+ callback.toString = () ->
+ return '' + this.call()
+ return callback
+
+oneOf = (ary...) ->
+ if ary.length == 0
+ throw new Error(
+ "tried to create a oneOf iterator with a 0-length array");
+
+ return {
+ inOrder: () ->
+ i = 0
+ return stringish(() ->
+ if i >= ary.length
+ return null
+ return ary[i++]
+ )
+
+ cycling: () ->
+ i = 0
+ return stringish(() ->
+ if (i >= ary.length)
+ i = 0
+ return ary[i++]
+ )
+
+ stopping: () ->
+ i = 0
+ return stringish(() ->
+ if (i >= ary.length)
+ i = ary.length - 1
+ return ary[i++]
+ )
+
+ randomly: (system) ->
+ rng = if system then system.rnd.random else Math.random
+ last = null
+
+ if (ary.length<2)
+ throw new Error("attempted to make randomly() iterator with a 1-length array")
+ return stringish( () ->
+ i = null
+ offset = null
+ if not last?
+ i = Math.floor(rng() * ary.length)
+ else
+ ###
+ Let offset be a random number between 1 and the length of the
+ array, minus one. We jump offset items ahead on the array,
+ wrapping around to the beginning. This gives us a random item
+ other than the one we just chose.
+ ###
+
+ offset = Math.floor(rng() * (ary.length -1) + 1);
+ i = (last + offset) % ary.length;
+
+ last = i
+ return ary[i]
+ )
+
+ trulyAtRandom: (system) ->
+ rng = if system then system.rnd.random else Math.random
+ return stringish(() ->
+ return ary[Math.floor(rng() * ary.length)];
+ )
+
+ inRandomOrder: (system) ->
+ shuffled = ary.shuffle(system)
+ i = 0
+ return stringish(() ->
+ if (i >= ary.length)
+ i = 0
+ return shuffled[i++]
+ )
+ }
+
+Array.prototype.oneOf = () ->
+ oneOf.apply(null, this)
+
+module.exports = oneOf;
diff --git a/lib/room.coffee b/lib/room.coffee
new file mode 100644
index 0000000..ddf9bba
--- /dev/null
+++ b/lib/room.coffee
@@ -0,0 +1,166 @@
+# I confess that this world model heavily borrows from INSTEAD engine. - A.Y.
+
+undum = require('undum-commonjs')
+RaconteurSituation = require('./situation.coffee')
+obj = require('./obj.coffee')
+markdown = require('./markdown.coffee')
+$ = require("jquery")
+
+way_to = (content, ref) ->
+ return "#{content}"
+
+# jQuery was confused by this point where's the context so I did it vanilla-way
+print = (content) ->
+ if typeof content == "function"
+ content = content()
+ block = document.getElementById("current-situation")
+ if block
+ block.innerHTML = block.innerHTML + markdown(content)
+ else #the game is not initialized yet. This is dangerous and will not augment any links.
+ block = document.getElementById("content")
+ block.innerHTML = markdown(content)
+
+Array::remove = (e) -> @[t..t] = [] if (t = @indexOf(e)) > -1
+
+addClass = (element, className) ->
+ if (element.classList)
+ element.classList.add(className)
+ else
+ element.className += ' ' + className
+
+# Function to return the current room.
+# Works because our `enter()` function sets the `data-situation` attribute.
+here = () ->
+ return undum.game.situations[document.getElementById("current-situation").getAttribute("data-situation")]
+
+update_ways = (ways) ->
+ content = ""
+ distances = []
+ if ways
+ for way in ways
+ if undum.game.situations[way]?
+ title = undum.game.situations[way].name
+ content += way_to(title, way)
+ distances.push({
+ key: way
+ distance: undum.game.situations[way].distance
+ })
+ document.getElementById("ways").innerHTML = content
+ min = Infinity
+ min_key = []
+ for node in distances
+ if node.distance < min
+ min = node.distance
+ min_key = [node.key]
+ if node.distance == min
+ min_key.push(node.key)
+ if min < Infinity
+ for node in min_key
+ addClass(document.getElementById("waylink-#{node}"), "destination")
+
+class SaletRoom extends RaconteurSituation
+ constructor: (spec) ->
+ RaconteurSituation.call(this, spec)
+ if spec.objects?
+ @objects = spec.objects
+ if spec.exit?
+ @exit = spec.exit
+ return this
+ objects: []
+ distance: Infinity # distance to the destination
+
+ ###
+ I call SaletRoom.exit every time the player exits to another room.
+ ###
+ exit: (character, system, to) ->
+ ###
+ Undum calls Situation.enter every time a situation is entered, and
+ passes it three arguments; The character object, the system object,
+ and a string referencing the previous situation, or null if there is
+ none (ie, for the starting situation).
+
+ My version of `enter` splits the location description from the effects.
+ Also if f == this.name (we're in the same location) the `before` and `after` callbacks are ignored.
+ ###
+ enter: (character, system, f) ->
+ #system.clearContent()
+ if f != @name and f?
+ @visited++
+ undum.game.situations[f].exit(character, system, @name)
+
+ if not @extendSection
+ classes = if @classes then ' ' + @classes.join(' ') else ''
+ situation = document.getElementById('current-situation')
+ if situation?
+ situation.setAttribute('id', undefined)
+ system.write("
+
+
+
+
+
+
+
+
+
+
+ +