Workbench (REPL) widgets

// Simple Math

// Select some code using the mouse or keyboard
// (or just have the caret on the line) then press
// F4 to evaluate the code on the game runtime.
4 + 5

// The result will be printed in the IDE log window.

// Do the same with any of these:
3.0 + 4.5
6 < 4
7 = 9  // equal to (not == such as with C++)
7 ~= 8 // Not equal to (not != as in some languages)

// Use [square] brackets to group sub-expressions.
// SkookumScript has no operator precedence!
[2 + 2] = 4

42.negate()           // returns -42
42.negate             // brackets optional if no arguments
42.between?(-3, 100)  // true - call with arguments
42.between?(-3 100)   // comma between arguments optional

// The exclamation mark ! indicates that something *new* is being
// created. This creates variable 'bob' and binds it to the
// Integer 9 and bob has the type Integer
!bob : 9

// Assigns the value 7 to bob and bob stays an Integer
// (This is similar to = in some other languages)
// [Needs the variable declaration above also selected.]
bob := 7

// re-binds bob to "Hello World!" - bob type is now a String!
// [Needs the variable declaration above also selected.]
bob : "Hello World!"

// Conditional
if 6>9 [println("Six is greater than nine!")]

// if statement can be used as an expression
// (so can everything)
println(if 5>4 ["Correct"] else ["Not correct"])

// "elseif" is done by using a single if with
// multiple clauses
!a: 8
if a=7  [println("a is 7")]
   a=8  [println("a is 8")]
   else [println("a is neither 7 nor 8")]

// @@random is a class data member that is always available   
// to generate random values.

// Randomly print "heads" or "tails"
if @@random.coin_toss ["Heads!"] else ["Tails!"] 

// when is another way of expressing a conditional    
println("Tails!") when @@random.coin_toss 

// unless = "when not"
println("Heads!") unless @@random.coin_toss

// Repeat 10 times
10.do[println("Hello World!")]

// You can add line breaks and multiple expressions
10.do
  [
  println("Hello World!")
  // Integer.do() supplies an idx variable you can use
  println("On iteration #" idx)
  ]

// Iterate over a list of numbers  
{1 2 3 4}.do[println(item)]

// Iterate in reverse
{1 2 3 4}.do_reverse[println(item)]

// Lists of stuff - items separated by whitespace (comma optional)

// Reverses the order of this list's items
{1 2 3 4 5}.reverse

// Applies the method 'negate' to all items of the list,
// returns the result
{1 -2 3 -4}%negate

// Runs some code - a 'closure' - on each item of the list
{1 -2 3 -4}.do[item.negate]

// unless is short for 'if not'
{1 2 3}.do[item++ unless item = 2]

// Make new list based on a selection criteria (again that
// code in square brackets is a closure)
{3 4 5 8}.select[item.pow2?]

// Make new list by rejecting some items of the original list
{3 4 5 8}.reject[item.pow2?]

// Select random item from list
{"A" "B" "C" "D"}.any

// Test if _any_ item from list satisfies a condition
{3 4 5}.any?[item.pow2?]

// Test if _all_ items from list satisfies a condition,
// false here
{3 4 5}.all?[item.pow2?]

// Same, true in this case
{2 4 8}.all?[item.pow2?]

// Coroutines are the secret sauce of SkookumScript.

// Waits 2 seconds then returns
_wait(2)

// Waits 1 second four times and prints "Tick!"
// after each wait
4._do [_wait(1) println("Tick!")]

// Wait random time between .1 and 2 seconds
// Note that commas are not required between arguments
_wait(@@random.uniform_range(.1 2))

// Wait one simulation frame
_wait

// SkookumScript comes with built-in vector math types.
// Press Alt-G on when the SkookumIDE editor caret is on a class
// to jump to the class in the Classes Widget.
// Check out classes such as: Vector2, Vector3, Vector4, Rotation,
// RotationAngles, Transform, Color

// Creates a 3D vector with x=1,y=2,z=3
Vector3!xyz(1 2 3)

// Adds two vectors
Vector3!xyz(1 2 3) + Vector3!xyz(2 3 4)

// If the type is obvious it will be inferred
// - you don't have to supply it
Vector3!xyz(1 2 3) + !xyz(2 3 4)

// A handy constructor of Vector3 creating a vector
// facing up (positive z direction in UE4) 
Vector3!up

// Creates a set of Euler angles to specify a rotation
RotationAngles!yaw_pitch_roll(60 0 0)

// A transform has a position, a rotation and a scale:
// >> means convert to type
Transform!translation_rotation_scale(
  Vector3!xyz(1 2 3)
  RotationAngles!yaw_pitch_roll(60 0 0)>>Rotation 
  Vector3!xyz(1 1 1))

// Types can be inferred for arguments  
Transform!translation_rotation_scale(
  !xyz(1 2 3)
  RotationAngles!yaw_pitch_roll(60 0 0)>>
  !xyz(1 1 1))
  
// We've got colors, too
Color.@@yellow

// Ok now let's have some fun!
// NOTE: Make sure you have the project SkookumDemo running!

// Select the code below and press F4 multiple times!!!
// Gets list of all Pawns in the world, and runs the
// coroutine _boom on them
Pawn.instances%_boom

// Click on the word _boom and press Alt-G to see how it is
// implemented! Use your mouse previous and next buttons or
// Alt+<- Alt+-> to navigate back and fourth in the history.

// The currently active game world
// (or nil if the game is not running)
@@world

// Is the game running?
not @@world.nil?

// List of levels of the game world
@@world.@levels

// Get the player pawn
player_pawn

// Instruct RoboChar1 to path towards the player
Enemy@'RoboChar1'._path_to_actor(player_pawn)

// Get an actor by name, and find something out about it
// Note that if a class is not used before @ it assumes
// class Actor
@'RoboChar1'.transform

// Play explosion sound at a given actor location
@'TargetPoint1'._play_sound("/Game/ScriptLoaded/Audio/Explosion01.Explosion01")

// Draw text above player
player_pawn._draw_text("Play me!")

// Send random robot to player
Enemy.instances.any._path_to_actor(player_pawn)

// Play _boom effect on random enemy
Enemy.instances.any._boom

// Reset the robots to their corners
robo_reset  

// The secret sauce of SkookumScript - elegantly and
// concisely describe concurrent and sequential behavior

//------------------------------------------
// Time flow example 1: Sequential
// Have each robot path to player one after the
// other then have player go boom.
// Select and run the next four lines
Enemy@'RoboChar1'._path_to_actor(player_pawn)
Enemy@'RoboChar2'._path_to_actor(player_pawn)
Enemy@'RoboChar3'._path_to_actor(player_pawn)
player_pawn._boom

// Then select and reset when complete
robo_reset

  
//------------------------------------------
// Time flow example 2: Synchronize
// Have each robot path to player simultaneously
// then have player go boom after they *all* arrive.
// Select and run the next seven lines
sync
  [
  Enemy@'RoboChar1'._path_to_actor(player_pawn)
  Enemy@'RoboChar2'._path_to_actor(player_pawn)
  Enemy@'RoboChar3'._path_to_actor(player_pawn)
  ]
player_pawn._boom

robo_reset  // Reset the robots


//------------------------------------------
// Time flow example 3: Race
// Have each robot path to player simultaneously
// then have player go boom when the *first* arrives.
// Select and run the next eight lines
race
  [
  Enemy@'RoboChar1'._path_to_actor(player_pawn)
  Enemy@'RoboChar2'._path_to_actor(player_pawn)
  Enemy@'RoboChar3'._path_to_actor(player_pawn)
  ]
// Stop movement of other robots
Enemy.instances%path_stop
player_pawn._boom

robo_reset  // Reset the robots


//------------------------------------------
// Time flow example 4: Timeout
// Have each robot path to player simultaneously then
// have player go boom when the *first* arrives or when
// 1.5 seconds elapses.
// Select and run the next eight lines
race
  [
  _wait(1.5)
  Enemy@'RoboChar1'._path_to_actor(player_pawn)
  Enemy@'RoboChar2'._path_to_actor(player_pawn)
  Enemy@'RoboChar3'._path_to_actor(player_pawn)
  ]
// Stop movement of other robots  
Enemy.instances%path_stop
player_pawn._boom

robo_reset  // Reset the robots


//------------------------------------------
// Act on lists of objects using different timeflow

// Sequential: all robots boom one after the other
// then go to next line after the last completes
Enemy.instances._do[item._boom]

// Synchronize: All robots boom simultaneously then
// go to next line when *all* completed
Enemy.instances%_boom

// Race: All robots boom simultaneously then go to
// next line when *first* completed
Enemy.instances%>_boom


//------------------------------------------
// So here are the previous path commands rewritten
// using lists rather than specifying the robots
// individually.

// All robots path to player one after the other
// and boom player when last arrives
Enemy.instances._do[item._path_to_actor(player_pawn)]
player_pawn._boom

robo_reset  // Reset the robots


// All robots path to player simultaneously
// and boom player when the all arrive
Enemy.instances%_path_to_actor(player_pawn)
player_pawn._boom

robo_reset  // Reset the robots


// Have each robot path to player simultaneously
// and boom player when first arrives
Enemy.instances%>_path_to_actor(player_pawn)
player_pawn._boom

robo_reset  // Reset the robots

// Get averaged location of all enemies
GameLib.actor_array_average_location(Enemy.instances)

// Gets list of actors of class 'TargetPoint'
!actors: Actor{}
GameLib.all_actors_of_class(
  @@world TargetPoint.static_class actors)
actors