F: Ich möchte die Camera um eine bestimmte Ziel Entity drehen, wenn ich nach links und rechts drücke. Oben und unten sollen mich näher oder weiter weg vom Ziel bewegen. Können Sie helfen?
A: Weisen Sie die folgende Action der Ziel Entity zu.

entity* mytarget;

action my_target // attach it to the target entity
{
   mytarget = my;
}

starter chase_target()
{
   var distance_to_target = 300; // initial distance to target
   var temp_angle = 50; // initial angle
   while (mytarget == null) {wait (1);}
   while (1)
   {
      camera.x = mytarget.x + distance_to_target * cos(temp_angle);
      camera.y = mytarget.y + distance_to_target * sin(temp_angle);
      camera.z = mytarget.z;
      vec_set (temp, mytarget.x);
      vec_sub (temp, camera.x);
      vec_to_angle (camera.pan, temp);
      if ((key_cuu == on) && (distance_to_target > 100))
      {
         distance_to_target -= 7 * time; // come closer to the target
      }
      if ((key_cud == on) && (distance_to_target < 500))
     {
        distance_to_target += 7 * time; // get away from the target
     }
     if (key_cul == on)
     {
        temp_angle -= 5 * time;
     }
     if (key_cur == on)
     {
         temp_angle += 5 * time;
      }
      wait (1);
   }
}

F: Wie kann ich Bewegungen wie in dem Spiel Prince of Persia vollbringen? Der Prinz greift eine Stange, und schwingt sich daran herum. Wie kann man sicher gehen das die Hand jederzeit perfekt an der Stange anliegt, auch wenn der Abstand, von dem man zur Stange springt nicht immer der gleiche ist?
A: Sie können mit einer einfachen Methode ein ähnliches Ergebnis erreichen: berechnen Sie den Abstand zwischen Spieler und Stange und passen Sie die Sprungstärke und die Animationsframes abhängig vom Abstand an. Zum Beispiel wenn die Distanz zwischen Spieler und Stange 100 Quants beträgt, bewegen Sie den Spieler mit 10*time und animieren mit 5*time. Bei 70 Quants bewegen Sie mit 7*time und animieren mit 5*(100/70)*time.

F: Wenn ich nach einer Box trete, wie kann ich sicher gehen, das diese zur gegenüberliegenden bewegt wird, ohne die ursprünglichen Pan und Tilt Winkel zu verlieren.
A: Verwenden sie den folgenden Code. Rennen Sie in die Box um diese zu bewegen.

function move_boxes()
{
    vec_rotate (vector(2 * (my.x - player.x) * time, 0, 0), player.pan);
    vec_add (my.x, vector(2 * (my.x - player.x) * time, 2 * (my.y - player.y) * time, 0));
}

action my_box
{
   while (player == null) {wait (1);}
   my.enable_impact = on;
   my.enable_entity = on;
   my.event = move_boxes;
}

F: Ich möchte ein Inventar-Panel mit vier Waffen erzeugen. Die PCX Bilder sollen erst erscheinen, wenn man die entsprechende Waffe aufgenommen hat. Können Sie helfen?
A: Werfen Sie einen Blick auf das folgende Beispiel und erweitern Sie es um so viele Waffen, wie Sie möchten.

bmap weapon1_pcx = <weapon1.pcx>;
bmap weapon2_pcx = <weapon2.pcx>;

var got_weapon1 = 0;
var got_weapon2 = 0;

panel weapon1_pan
{
   bmap = weapon1_pcx;
   layer = 20;
   pos_x = 0;
   pos_y = 0;
   flags = overlay, refresh;
}

panel weapon2_pan
{
   bmap = weapon2_pcx;
   layer = 20;
   pos_x = 50;
   pos_y = 0;
   flags = overlay, refresh;
}

starter check_weapon_status()
{
   while (1)
   {
      if (got_weapon1 == 1) // got weapon1?
      {
         weapon1_pan.visible = on;
      }
      else
      {
         weapon1_pan.visible = off;
      }
      if (got_weapon2 == 1) // got weapon2?
      {
         weapon2_pan.visible = on;
      }
      else
      {
         weapon2_pan.visible = off;
      }
      wait (1);
   }
}

action weapon_first // attach it to the first weapon
{
   my.passable = on;
   while (player == null) {wait (1);}
   while (vec_dist (player.x, my.x) > 50)
   {
      my.pan += 5 * time;
      wait (1);
   }
   got_weapon1 = 1;
   my.invisible = on;
   // put the rest of your weapon code here
}

action weapon_second // attach it to the second weapon
{
   my.passable = on;
   while (player == null) {wait (1);}
   while (vec_dist (player.x, my.x) > 50)
   {
      my.pan += 5 * time;
      wait (1);
   }
   got_weapon2 = 1;
   my.invisible = on;
   // put the rest of your weapon code here
}

F: Wie kann ich einen Splashscreen erstellen, der erscheint, bevor ein Level geladen wird, und nach Tastendruck verschwindet? Der Code sollte für mehrere Levels funktionieren.
A: Verwenden Sie den folgenden Code als Beispiel.

bmap splash_pcx = <splash.pcx>;

panel splash_pan
{
   bmap = splash_pcx;
   pos_x = 0;
   pos_y = 0;
   layer = 1;
   flags = overlay, refresh;
}

action level1_level2 // attach this action to any entity placed at the end of the first level
{
   while (player == null) {wait (1);}
   while (vec_dist (player.x, my.x) > 50) {wait (1);}
   while (key_any == on) {wait (1);} // wait until all the keys are released
   my = null;
   level_load(level2_wmb);
   freeze_mode = 1; // stop all the entities in the level
   splash_pan.visible = on;
   while (key_any == off) {wait (1);}
   splash_pan.visible = off;
   freeze_mode = 0; // resume the gameplay
}

action level2_level3 // attach this action to any entity placed at the end of the second level
{
   while (player == null) {wait (1);}
   while (vec_dist (player.x, my.x) > 50) {wait (1);}
   while (key_any == on) {wait (1);} // wait until all the keys are released
   my = null;
   level_load(level3_wmb);
   splash_pan.visible = on;
   while (key_any == off) {wait (1);}
   splash_pan.visible = off;
}

F: In einigen Spielen dreht sich der Kopf der Spielfigur zu einem Objekt das aufgenommen oder benutzt werden kann, wenn man in dessen Nähe kommt. Wie kann man das machen?
F: Kopieren sie den folgenden Code an das Ende des Hauptskripts.

entity* special;

function rotate_entity (active, passive, panspeed, tiltspeed);

function rotate_entity (active, passive, panspeed, tiltspeed)
{
   var target_pan;
   my = active;
   you = passive;
   vec_set (temp, your.x);
   vec_sub (temp, my.x);
   vec_to_angle (target_pan, temp);
   temp.pan = ang (target_pan - my.pan);
   target_pan = my.pan + temp.pan;
   if( my.pan < target_pan)
   {
      while(my.pan < target_pan)
      {
         my.pan += panspeed.pan * time;
         if (my.tilt > target_pan.tilt)
         {
             my.tilt -= tiltspeed * time;
         }
         if (my.tilt < target_pan.tilt)
         {
             my.tilt += tiltspeed * time;
         }
         wait(1);
      }
   }
   else
   {
      while(my.pan >= target_pan)
      {
         my.pan -= panspeed.pan * time;
         if (my.tilt > target_pan.tilt)
         {
             my.tilt -= tiltspeed * time;
         }
         if (my.tilt < target_pan.tilt)
         {
             my.tilt += tiltspeed * time;
         }
         wait(1);
      }
   }
}

action special_object
{
   special = my;
   while (player == null) {wait (1);}
   while (vec_dist (player.x, my.x) > 200) {wait (1);}
   while (vec_dist (player.x, my.x) <= 200)
   {
      rotate_entity (player, special, 0.1, 0);
      wait (1);
   }
}

Q: Wie kann man ein Raumschiff bewegen und man in einem 2D Spiel vorwärts bewegen und drehen kann. Das Schiff muss in die Drehung ‘sliden’ wie ein Auto, das auf Eis fährt. Wie kann man das machen?
A: Benutzen Sie diesen Schnipsel:

starter set_camera()
{
    sleep (1); // wait until the level is loaded
    camera.x = 0;
    camera.y = 0;
    camera.z = 1000;
    camera.tilt = -90;
}

action asteroids_ship
{
   var ship_speed;
   while (1)
   {
      if (key_cuu == on)
      {
         if (ship_speed.x < 2)
         {
             ship_speed.x += 0.3 * time;
         }
      }
      else
      {
         if (ship_speed.x >= 0)
         {
             ship_speed.x -= 0.05 * time;
         }
      }
      if (ship_speed.x < 0) {ship_speed.x = 0;}
      if (key_cul == on)
      {
         my.pan += 3 * time;
      }
      if (key_cur == on)
      {
         my.pan -= 3 * time;
      }
      ent_move (ship_speed.x, nullvector);
      wait (1);
   }
}

F: Ich verwende den "intelligent music" Schnipsel aus Aum38. Wie kann ich diese Action mehreren Entities zuweisen, ohne für jede eine eigene Instanz abzuspielen.
A: Verwenden Sie das folgende Beispiel: Es spielt “gentle.wav” wenn die Spielfigur der Entity sich auf 500 qunats nähert, “tense.wav” bei unter 100 Quants. Bei über 600 Quants wird die Musik ausgeblendet.

action music_trigger
{
    // my.invisible = on; // remove the comment when you've chosen the best position for the entity
    my.passable = on;
    while (player == null) {wait (1);}
    while (vec_dist (player.x, my.x) > 500) {wait (1);} // play with "500"
    music_handle = snd_loop (gentle_wav, 50, 0); // play the "gentle" sound track
    while (vec_dist (player.x, my.x) > 100) {wait (1);} // play with "100"
    temp_volume = 50; // put the same value that was used for snd_loop here
    while (temp_volume > 5) // decrease the volume slowly
    {
       snd_tune (music_handle, temp_volume, 0, 0);
       temp_volume -= 1 * time;
       wait (1);
    }
    snd_stop (music_handle); // stop "gentle.wav";
    music_handle = snd_loop (tense_wav, 50, 0); // play the "tense" sound track
    while (vec_dist (player.x, my.x) < 600) {wait (1);} // play with "600"
    temp_volume = 50;
    while (temp_volume > 5) // decrease the volume slowly
    {
       snd_tune (music_handle, temp_volume, 0, 0);
       temp_volume -= 1 * time;
       wait (1);
    }
    snd_stop (music_handle); // stop "tense.wav";
}

F: Kann man einen Tastenklick Sound währen der inkey Eingabe oder muss man dafür eine eigene Eingabe Funktion schreiben?
A: Alle key_... Funktionen (auch key_any und on_anykey) sind während er inkey deaktiviert. Mittels key_pressed und str_cat kann man aber eine eigene simple Eingabe Funktion schreiben.