F: Ich verwende das Waldskript aus AUM 12, aber ich würde die Bäume gern abseits der Straße plazieren. Ist das möglich?
A: Benutzen Sie für die Straße eine andere Textur und das veränderte Skript:

define num_trees = 100; // this forest will have 100 trees

var tree_index = 0;
var max_x = 1000;
var min_x = -1000;
var max_y = 1000;
var min_y = -1000;
var tree_pos;

string tree1_mdl = <tree1.mdl>;
string tree2_mdl = <tree2.mdl>;

function create_tree()
{
   wait (1);
   my.pan = random(360);
   vec_set (temp, my.x);
   temp.z -= 5000;
   trace_mode = ignore_me + ignore_passable + ignore_models + ignore_sprites + use_box;
   my.z -= trace (my.x, temp) + 20; // place the tree and stick its root in the ground (20 quants)
}

starter generate_forest()
{
   sleep (1); // wait until the level is loaded
   randomize(); // always generate a different forest
   while (tree_index < num_trees)
   {
      tree_pos.x = sign(min_x) * random(abs(min_x)) + sign(max_x) * random(abs(max_x));
      tree_pos.y = sign(min_y) * random(abs(min_y)) + sign(max_y) * random(abs(max_y));
      tree_pos.z = 1000; // 1000 quants above the floor level
      tree_index += 1;
      vec_set(temp.x, tree_pos.x);
      temp.z -= 5000;
      trace_mode = ignore_me + ignore_passable + ignore_models + ignore_sprites + scan_texture;
      trace (tree_pos.x, temp.x);
      if (str_cmpi ("grass1", tex_name)) // if the tree would be placed on the grass (and not on the road)
      {
          if (random(1) > 0.5)
          {
              ent_create (tree1_mdl, tree_pos, create_tree); // then create tree1_mdl
          }
          else
         {
             ent_create (tree2_mdl, tree_pos, create_tree); // or tree2_mdl
         }
      }
   }
}

F: Ich suche nach einer Möglichkeit, kleine Partikelfunken erscheinen zu lassen, wenn ein Objekt an einen Levelblock stößt. Können Sie helfen?
A: Verwenden Sie den Code unten als Ausgangspunkt; er setzt ein Sprite an die Wand, falls der Ball damit kollidiert.

action my_ball
{
    my.enable_block = on;
    my.enable_entity = on;
    my.event = ball_event;
    while (1)
    {
       // your ball code goes here
       ................
       wait (1);
    }
}

function particle_sparks()
{
   my.passable = on; // make sure that your ball ignores passable objects (move_mode = ignore_passable)
   // put your particle code here
}

function ball_event()
{
   vec_set (temp, my.x);
   temp.z -= 1000;
   trace_mode = ignore_me;
   trace (my.x, temp);
   ent_create(decal_bmp, target, particle_sparks); // place a decal sprite at the right position on the floor ("target" gives us the coordinates)
}

F: Ich habe mich gefragt, ob Sie vielleicht ein Skript für einen Gesundheitsbalken parat haben.
A: Hier ist der Code und eine Bitmap als Beispiel:

bmap health_pcx = <health.pcx>;

panel health_pan
{
   pos_x = 10;
   pos_y = 10;
   layer = 10;
   window = 20, 10, 20, 60, health_pcx, 0, player._health;
   flags = visible;
}

F: Ich weiß nicht, wie ich in die Richtung tracen kann, in die der Spieler blickt. Gibt es Code, der das leistet?
A: Benutzen Sie diesen Code:

string target_pcx = <target.pcx>;

function trace_forward()
{
   var trace_coords;
   vec_set(trace_coords.x, vector(1000, 0, 0)); // trace 1000 quants in front of the player
   vec_rotate(trace_coords.x, camera.pan); // rotate "temp" in the direction (angles) given by the camera (the player)
   vec_add(trace_coords.x, camera.x); // add the resulting vector to camera's (player's) position
   trace_mode = ignore_me + ignore_passable + ignore_models + ignore_sprites + use_box;
   if (trace(player.x, trace_coords.x) > 0) // hit something?
   {
      ent_create (target_pcx, target.x, nullvector); // put a small sprite where the trace hits something
      // you should replace the line of code above with your own code that is the result of the tracing operation
   }
}

on_t = trace_forward;

F: Wie kann ich meine View verschwommen gestalten ohne zuviele Ressourcen zu verbrauchen?
A: Hier ist ein Beispiel:

view second_camera
{
    pos_x = 0;
    pos_y = 0;
    alpha = 40; // play with this value
    flags = transparent, visible;
}

starter camera_blur()
{
   camera.transparent = on;
   camera.alpha = 30; // play with this value
   second_camera.size_x = screen_size.x;
   second_camera.size_y = screen_size.y;
   while (1)
   {
      wait (2);
      second_camera.x = camera.x;
      second_camera.y = camera.y;
      second_camera.z = camera.z;
      second_camera.pan = camera.pan;
      second_camera.tilt = camera.tilt;
      second_camera.roll = camera.roll;
   }
}

F: Ich kann die “sleep”-Funktion nicht für große Zeitabstände benutzen, weil sie zu unpräzise ist. Kann ich sys_seconds statt dessen benutzen?
A: Klar, hier ist ein Beispiel:

var second_counter = 0;

starter precision_timer()
{
   var temp_seconds;
   while (1)
   {
      temp_seconds = sys_seconds;
      wait (1);
      if (temp_seconds != sys_seconds) // sys_seconds has changed during the last frame
      {
          second_counter += 1; // increase second_counter; use this value for your high(er) precision counter
      }
   }
}

panel time_pan
{
   digits = 5, 15, 6, _a4font, 1, second_counter; // display the value that is stored in second_counter
   flags = refresh, visible;
}

F: Wie kann ich ein simples Login / Passwort System für mein Spiel erstellen?
A: Mit diesem Code:

bmap serial_pcx = <serial.pcx>;

string serial_str = "                    "; // the password can have up to 20 characters

panel serial_pan
{
   bmap = serial_pcx;
   flags = overlay, refresh;
   layer = 15;
}

text serial_txt
{
   layer = 25;
   pos_x = 300;
   pos_y = 275;
   font = _a4font;
   string = serial_str;
}

starter check_password()
{
   sleep (1);
   serial_pan.visible = on;
   serial_txt.visible = on;
   inkey(serial_str);
   if (str_cmpi(serial_str, "12345") == 0) // password = 12345
   {
      exit;
   }
   else
   {
      serial_pan.visible = off;
      serial_txt.visible = off;
      beep;
      // put the code that starts your game here
   }
}

F: Ich würde es gern einrichten, dass 3 Objekte zufällig an 3 von 9 vordefinierten Orten erscheinen. Wie kann ich das erreichen?
A: Plazieren Sie 9 Objekte im Level und geben Sie ihnen die folgende Action:

var score = 0;
var objects_placed = 0;

starter randomize_numbers()
{
   randomize();
}

action three_objects_only
{
   my.skill1 = random(1) + 0.1; // generate a random number between 0.1 and 1.1
   sleep (my.skill1); // wait 0.1 to 1.1 seconds
   my.passable = on;
   objects_placed += 1;
   if (objects_placed > 3)
   {
      ent_remove(my);
   }
   else
   {
      while (player == null) {wait (1);} // wait until the player is created
      while (vec_dist(player.x, my.x) > 50) {wait (1);} // wait until the player has come close to the object
      ent_remove(my);
      score += 10; // whatever
   }
}

panel score_pan
{
   layer = 15;
   digits = 5, 15, 6, _a4font, 1, score;
   flags = overlay, refresh, visible;
}

F: Ich würde gern feststellen, wie sich mein Spiel auf langsameren Rechnern verhält, aber ich habe nur einen vergleichsweise schnellen PC. Wie kann ich das trotzdem erreichen?
A: Mit diesem Code können Sie die Framerate manuell auf einen Wert zwischen 10 und 200 setzen.

starter adjust_fps()
{
    while (1)
    {
        if ((key_k == on) && (fps_max < 200)) {fps_max += 1 * time;} // press "K" to increase the frame rate
         if ((key_m == on) && (fps_max > 10)) {fps_max -= 1 * time;} // press "M" to decrease the frame rate
         wait (1);
    }
}