Home | Introduction | Installation | Quick start | Troubleshooting | Themes | Script tutorial | Script basics | Script callbacks reference | Script API reference | Known bugs | Frequently Asked Questions

# Script API reference

## Introduction

The API functions are functions you can call within Lua, when you are scripting, to get information from the core C++ engine, and also modify what's happening in the game.

Technically speaking, these functions are just plain Lua functions mapped over C functions in the core engine, and these C functions call C++ methods off the "U61_Map" and "U61_Block" C++ objects. In this document, I will later say that the C++ engine calls some API fonctions automatically. In fact, it does not call the Lua functions but the C++ methods directly. But the result is exaclty the same, only the C++ engine does not make as many checks as the API functions do.

Those functions are quite "crash proof". I mean that various checks are triggered when you call them. For instance, calling a function which requires an array index with a bad, inexisting index will simply result in returning a default value, but there should not be (such a bug should be reported) a system crash of the core C++ engine.

The design of this API is not perfect, so maybe I'll create more functions later, since the functions I provide here are very low-level functions. However, I'll try and do my best not to remove any functions, so that in the long run scripts can be re-used easyly, and remain compatible with each other.

## u61_add_antidote

### Declaration

    u61_add_antidote()

- Arguments: none.
- Return values: none.
- Rights: map_write.

### Description

Gives an antidote to the current player.

The given antidote should appear in the status zone (a little heart in the default theme). The player is not forced to use it right away. In fact, as long as there's at least one antidote available, any press on the "use antidote" key will run the "user_use_antidote" function.

Note that even if the antidote does not appear in the status zone for there are already too many antidotes available, the "u61_add_antidote" will function correctly, and "u61_get_nb_antidotes" should always return the exact value.

### Example

In this example, we give an antidote and a score bonus to the player.

    function nice_present()
        u61_add_score(1000)
        u61_add_antidote()
    end

## u61_add_item

### Declaration

    u61_add_item(x,y,color)

- Arguments: coordinates and color of the square to add.
- Return values: none.
- Rights: block_write

### Description

This function adds a new square to the current block. It is the function which should be called in the "user_do_shape" callback, to build new blocks before they start falling.

You can consider this function as an "append" method on the block object. In a way, the block is a vector of squares, which grows as you call "u61_add_item", and can be emptied with "u61_clear_block". If you had a block with 3 squares, after a call to this function, it will have 4 squares. The added square has an index of [n-1], if the size of the block is n.

Of course, the square properties which are set up by this function (position and color), can be changed later in the game.

### Example

In this example, we add a square with a parameterd color at the right of the square which is already at the right extremity of the block.

    function expand_right(color)
        local max_x
        local x
        local y
        local i

        max_x=0
        y=0

        i = u61_get_nb_items()-1
        while i>=0 do
            x=u61_get_item_x(i)
            if x>max_x then
                max_x=x
                y=u61_get_item_y(i)
            end
            i=i-1
        end

        u61_add_item(x,y,color)
    end

## u61_add_score

### Declaration

    u61_add_score(score_diff)

- Arguments: the value which should be added to the score.
- Return values: none.
- Rights: map_write.

### Description

This function adds some points to the current score.

You can also use this function with negative values, if you want to decrease the score of a player. In fact, this function is really equivalent to a manual call to "u61_get_score" and then "u61_set_score". It is there to avoid you the pain of calling 2 functions where 1 is enough in most of the cases.

### Example

The following function adds some points to the player only if the "NO_POINTS" curse is not activated.

    ID_NO_POINTS=33

    function tweaked_add_score(score_diff)
        if u61_get_curse_age(ID_NO_POINTS)<0 then
            u61_add_score(score_diff)
        end
    end

## u61_blow_up_square

### Declaration

    u61_blow_up_square(x,y)

- Arguments: the coordinates of a block in the map.
- Return values: none.
- Rights: map_write.

### Description

This function starts an explosion at the given location, it should be used in the "user_match_pattern" function.

Of course, in the "user_match_pattenr" function, you could directly remove squares from the map, but you can get a nicer effect by calling the "u61_blow_up_square" function. It will indeed start an explosion on a given square, and at the end of the explosion - that's to say a few game cycles after the explosion has started -, the C++ core engine will call your "user_square_blown_up" callback. This way you may start an explosion, let the game run while the explosion is displayed to the player, and then get some control of what's happening at the end of the explosion with the "user_square_blown_up" function.

This function is very usefull if you want to create some cascading effects. In fact, I don't know about any other way to do it yet...

### Example

This example blows up the bottom line of the map. What has to be done when the explosion is over is not defined here, for it is defined i the "user_square_blown_up" function.

    function blow_bottom()
        local x
        local y

        y=u61_get_height()-1
        x=u61_get_width()-1
        while x>=0 do
            if u61_get_square_color(x,y)>=0 then
                u61_blow_up_square(x,y)
            end
            x=x-1
        end
    end

## u61_cancel_curse

### Declaration

    u61_cancel_curse(curse)

- Arguments: the id of a curse.
- Return values: none.
- Rights: map_write.

### Description

This function cancels a persistent curse which had been set up with "u61_register_curse".

This function cures the illness caused by a curse by disactivating it. It can be used in the "user_use_antidote" function for instance. Of course any persistent curse is automatically removed with time, but this function is very usefull in the case of a pseudo-permanent curse which has a very long delay.

### Example

In this example, we disable the "ID_CURSE_HUNGRY" curse manually.

    ID_CURSE_HUNGRY=10

    function feed_the_beast()
        u61_cancel_curse(ID_CURSE_HUNGRY)
    end

## u61_center_block

### Declaration

    u61_center_block()

- Arguments: None
- Return values: None
- Rights: block_write

### Description

This function centers the block, this means that after it has been called, the gravity center of the block (approximately), will be located at (x,y), x and y being the global coordinates of the block.

This is very usefull when you want to code something like a rotation or a symetry. You can indeed code things in a simple manner using "x=-x" like algorithms, and then call "u61_center_block" to center the block. If you had not this function, there could be situations where after a sequence of rotations/symetries, a block could have moved to the left and/or right. Worse, a rotation could cause the block to move down, which is bad in a block-based game. Please note that this function does note change the global (x,y) values of the block (access by "u61_get_block_x" for instance). Its role is only to make (x,y) be the actual center of the block.

This function is automatically called by the script engine after the following user callbacks:

- user_rotate_left
- user_rotate_right
- user_move_left
- user_move_right
- user_move_down

### Example

The following example leaves the block in a unchanged state. Indeed, the squares are translated, but "u61_center_block" cancels the translation.

    function leave_block_unchanged()
        local i

        i = u61_get_nb_items()-1
        while i>=0 do
            u61_set_item_x(i,u61_get_item_x(i)+1)
            i=i-1
        end
        u61_center_block()
    end

## u61_clear_block

### Declaration

    u61_clear_block()

- Arguments: None
- Return values: None
- Rights: block_write

### Description

This function clears the current block, this means it removes all the squares from it.

Beware not to leave a cleared, empty block falling in the players map, because it might cause some problems, since the C++ engine will not be able to find out when the block is supposed to have landed.

### Example

In this example, we imagine that we want to change the shape of the block as it falls. Since "user_do_shape()" is always called on an empty block, the functions which prepare shapes usually do not clear the block first. So we need to force the block clear in we want to change completely the shape of the block outside the "user_do_shape" function.

    function change_shape_to_tetramino_bar()
        u61_clear_block()
        tetramino_bar()
    end

## u61_delete_antidote

### Declaration

    u61_delete_antidote()

- Arguments: none.
- Return values: none.
- Rights: map_write.

### Description

Removes an antidote from the player available antidotes.

Note that it's not necessary to call this function within the "user_use_antidote" function, since the number of antidotes is automatically decreased by the C++ core engine. However, you might want to use this function if you want to remove manually some antidotes.

If you call this function too many times, the number of antidotes will remain 0, it should never get negative, since the C++ engine will not allow it.

### Example

This function clears all the antidotes of a player.

    function clear_antidote()
        while u61_get_nb_antidotes()>0 do
            u61_delete_antidote()
        end
    end

## u61_get_anticipation_state

### Declaration

    u61_get_anticipation_state()

- Arguments: none.
- Return values: true (1) if anticipation mode is on, or false (0).
- Rights: map_read.

### Description

This function returns the state of the anticipation mode, that means wether the player should see where the block will land if he presses the "drop" key right away.

You may have noticed that this parameter seems available in the player options menu, and the player might choose to have this information or not. However, the "u61_get_anticipation_state" function does not return the state of the menu item. Indeed, the "anticipation frame" is drawn only if the menu option has been set to "on" *and* the "u61_get_anticipation_state" returns true. So if you set the option to false in the menu, you will never see it, no matter what happens in the game.

### Example

In this example, we return true if both anticipation and preview mode are set to true.

    function is_game_easy()
        local result

        if u61_get_anticipation_state() and u61_get_preview_state() then
            result=1
        else
            result=0
        end

        return result
    end

## u61_get_block_x

### Declaration

    u61_get_block_x()

- Arguments: None
- Return values: The x coordinate of the block.
- Rights: block_read

### Description

This function returns the x coordinate of the block. This value should approximately correspond to the center of gravity of the block.

### Example

The following function returns the real position of a square in a block, ie the position this square has on the map.

    function get_absolute_x(i)
        return u61_get_block_x()+u61_get_item_x(i)
    end

## u61_get_block_y

Exactly the same as "u61_get_block_x", but x becomes y...

## u61_get_curse_age

### Declaration

    u61_get_curse_age(curse)

- Arguments: the id of a curse.
- Return values: the age of the curse.
- Rights: map_read.

### Description

This function returns the time ellapsed since the last call to "u61_register_curse" with the same curse id. If the curse is not active at all, then the function returns -1.

The time is counted in game cycles. It takes 100 game cycles to make one second. It's in fact the same unit used in "u61_get_time()".

This function's primary goal is to allow the scripter to know wether a curse has been registered with "u61_register_curse". These registered curses appear in the player's status zone, and are representent by little skulls in the default theme. A typical use of this function would be to test if its return value is greater or equal to 0, and decide to disable and/or enable features in the game.

### Example

In this example, we don't allow the user to use the rotate left key if he's doomed with the "ID_CURSE_NO_ROTATE" curse. It supposes there's a "low_level_rotate_left" function that does the dirty job of rotating the block.

    ID_CURSE_NO_ROTATE=20

    function my_rotate_left()
        if u61_get_curse_age(ID_CURSE_NO_ROTATE)<0 then
            low_level_rotate_left()
        end
    end

## u61_get_curse_state

### Declaration

    u61_get_curse_state()

- Arguments: none.
- Return values: 1 if the curse mode is on, 0 if not.
- Rights: map_read.

### Description

Returns true if there should be a special "curse square" on the map.

This function is very different from "u61_is_curse_available". Indeed, it returns true if the map is in such a mode that a curse square could exists. But this does not garantee there's a curse square available. A trivial example is the empty map. If there are no squares at all on the map, you can oviously not have a special square anywhere. In fact, this function is merely to return the value set by "u61_set_curse_state" but in most of the cases what you'll need to call is "u61_is_curse_available".

### Example

In this example, the player has his score freezed when he can't have any curse square on his map. This is a very unfair script since he is already disadvantaged by having no weapon at hand.

    function add_score_unfair(points)
        if not (u61_get_curse_state()==0) then
            u61_add_score(points)
        end
    end

## u61_get_curse_x

### Declaration

    u61_get_curse_x()

- Arguments: none.
- Return values: the x coordinate of the "curse square" in the map.
- Rights: map_read.

### Description

This function gives the x position of the "curse square". This special square is the black and white "?" in the default theme.

When this special square disappears (after an explosion), then the "user_do_curse" function is called. Of course you can start curses on other events, such as a special pattern match, but the explosion of this special square should remain the most common method to issue a curse - at least this is the way I view things, you may agree or not with me on this point.

This special square historically comes from EITtris. Since U61 is quite extensible I could have honestly imagined a more original and flexible way to launch curses but I was too lazy and I just like this idea since it reminds me of all the nights spent playing EITtris with 3 friends on a single computer in a small student room =8-)

### Example

In this example, the player gets a score bonus if the curse square was located in the right or left columns of the map.

    function bonus_if_curse_on_sides()
        local x

        x=u61_get_curse_x()

        if x==0 or x==(u61_get_width()-1) then
            u61_add_score(1000)
        end
    end

## u61_get_curse_y

Exactly the same as "u61_get_curse_x", but x becomes y...

## u61_get_global

### Declaration

    u61_get_global(i)

- Arguments: the index of the global value.
- Return values: the value of the global.
- Rights: map_read.

### Description

This function returns the global value associated to a given index (between 0 and 99).

This function is by no way related to the luac "getglobal" function. For more information about how to use it, see the documentation of "u61_set_global".

### Example

This function returns the value of the ID_COUNTER value. Note that the lua object ID_COUNTER is a global lua value. However, you can use it safely since it is a constant. It's just a way to write things in a cleanier way. Without such constants, the code would rapidly become ununderstandable. But the value returned by the function is not a global lua value, it's a local value which has been initialized with a value stored internally by the C++ core engine.

    ID_COUNTER=8

    function get_counter()
        return u61_get_global(ID_COUNTER)
    end

## u61_get_height

### Declaration

    u61_get_height()

- Arguments: none.
- Return values: the height of the map.
- Rights: map_read.

### Description

Returns the height of the map.

This function always returns 25. It is pretty much like the "u61_get_width" function, so please read the documentation of "u61_get_width" to understand why you should use this function even if you are pretty sure it will always return 25.

### Example

The following example colors the whole map, using the example function "colorize_row".

    function colorize_map(color)
        local y

        y=u61_get_height()-1
        while y>=0 do
            colorize_row(y,color)
            y=y-1
        end
    end

## u61_get_item_color

### Declaration

    u61_get_item_color(i)

- Arguments: the index of the square.
- Return values: the color of the square.
- Rights: block_read

### Description

Returns the color of a square in the block.

The color should normally always be a regular color (ie between 0 and 7), since having an empty square in a block does not really make any sense.

### Example

The following function returns true if a given color is present in the block.

    function is_color_present(color)
        local i
        local present

        present=0

        i = u61_get_nb_items()-1
        while i>=0 do
            if u61_get_item_color(i)==color then
                present=1
            end
            i=i-1
        end
    end

## u61_get_item_x

### Declaration

    u61_get_item_x(i)

- Arguments: the index of the square.
- Return values: the x coordinate of the square.
- Rights: block_read

### Description

This function returns the x coordinate of a square in the block.

Note that the returned coordinate is not absolute. This means that if you want to have the real position of this square in the map, you'll have to call the "u61_get_block_x" function too and add the results.

### Example

This function returns the width of a block, by getting the min and max x values.

    function get_block_width()
        local i
        local min_x
        local max_x

        min_x=1
        max_x=-1

        i = u61_get_nb_items()-1
        while i>=0 do
            x=u61_get_item_x(i)
            min_x=min(min_x,x)
            max_x=max(max_x,x)
            i=i-1
        end

        return max_x-min_x
    end

## u61_get_item_y

Exactly the same as "u61_get_item_x", but x becomes y...

## u61_get_nb_antidotes

### Declaration

    u61_get_nb_antidotes()

- Arguments: none.
- Return values: the number of antidotes available.
- Rights: map_read.

### Description

This function returns the number of antidotes available. It is very similar to "u61_get_nb_curses".

The number of antidotes available is not updated by the C++ core engine. You need to give antidotes to players explicitly, by calling the "u61_add_antidote" function.

You can easily view the value this function would return by counting on the screen the number of little hearts (assuming you are playing with the default theme) in the status zone. Still, if there are too many antidotes available, only a limited number of them is displayed. Howvever, the "u61_get_nb_antidotes" will always return the exact value, even if it's too great to be displayed accurately.

### Example

In this example, we increase the score of the player if he has more than 5 antidotes.

    function update_score()
        if u61_get_nb_antidotes()>=5 then
            u61_add_score(10)
        end
    end

## u61_get_nb_curses

### Declaration

    u61_get_nb_curses(good)

- Arguments: the type of curse to get information about.
- Return values: the number of persistent curses currently active.
- Rights: map_read.

### Description

This function returns the number of persistent curses which have been set up with "u61_register_curse".

Calling it with a value of 0 will return you the number of "bad" curses, and calling it with a value of 1 will return the number of "good" curses. For more informations on bad and good curses, see "u61_register_curse".

You can easily view the value this function would return by counting on the screen the number of little skulls (assuming you are playing with the default theme) in the status zone. Still, if there are too many curses activated, only a limited number of them is displayed. Howvever, the "u61_get_nb_curses" will always return the exact value, even if it's too great to be displayed accurately.

### Example

In this example, we decrease the score of the player if he is affected by more than 5 persistent curses.

    function update_score()
        if u61_get_nb_curses(0)>=5 then
            u61_add_score(-1)
        end
    end

## u61_get_nb_items

### Declaration

    u61_get_nb_items()

- Arguments: none
- Return values: the number of squares in the current block.
- Rights: block_read

### Description

Returns the number of squares in the current block. It is very usefull if you want to program a loop on all the squares of the block.

If this function returns 4, it means that there are 4 squares available, which can be accessed with indexes 0,1,2 and 3. Any call outside this range to function like "u61_set_block_x" will simply do nothing.

### Example

In the following example, the x and y coordinate of each square are exchanged.

    function flip_xy()
        local i
        local x
        local y

        i = u61_get_nb_items()-1
        while i>=0 do
            x=u61_get_item_x(i)
            y=u61_get_item_y(i)
            x,y=y,x
            u61_set_item_x(i,x)
            u61_set_item_y(i,y)
            i=i-1
        end
    end

## u61_get_oldest_curse

### Declaration

    u61_get_oldest_curse(good)

- Arguments: the type of curse to get information about.
- Return values: the id of the oldest curse.
- Rights: map_read.

### Description

This function returns the id of the oldest curse which has been set with "u61_register_curse".

Calling it with a value of 0 will return the oldest "bad" curse, and calling it with a value of 1 will return the oldest "good" curse. For more informations on bad and good curses, see "u61_register_curse".

It's important to be able to know rapidly which of the active persistent curses is the oldest one. A very simple example is a basic "user_use_antidote" where you want to remove a curse. You need a way to choose which one to delete. A possibility is to remove the oldest one, and this way the list of curse behaves like a FIFO (first in/first out) queue. And there you need the "u61_get_oldest_curse" function, or you would have to poll manually each curse to know his age and compare them...

The id returned by this function could typically be used with "u61_cancel_curse".

### Example

In this example, we remove the oldest curse, except if it is the "ID_CURSE_BAD_LUCK" curse.

    ID_CURSE_BAD_LUCK=13

    function special_antidote()
        local curse

        curse=u61_get_oldest_curse(0)

        if curse~=ID_CURSE_BAD_LUCK then
            u61_cancel_curse(curse)
        end
    end

## u61_get_preview_state

### Declaration

    u61_get_preview_state()

- Arguments: none.
- Return values: true (1) if the preview should be displayed, of false(0).
- Rights: map_read.

### Description

Returns the preview state of the player. The preview is what shows the player what kind of block he will get next time a block falls.

Unlike the anticipation state, the preview state can not be controlled from the menus. By default, it is set to true at the beginning of the game, and may be changed by calls to "u61_set_preview_state".

### Example

This function gives more points to the player if preview state is off.

    function tweaked_add_score(points)
        if u61_get_preview_state()==1 then
            u61_add_score(2*points)
        else
            u61_add_score(points)
        end
    end

## u61_get_score

### Declaration

    u61_get_score()

- Arguments: none.
- Return values: the current score.
- Rights: map_read.

### Description

This function returns the current score.

One important thing about the score is that it is set to 0 each time the game restarts. The core C++ engine knows what is the player's highest score, but it does not inform the script about it on purpose. In fact, different high scores might be displayed for the same player on different machines. This occurs when someone has been playing for hours and has luckily got a high score of 999999. Then a remote player decides to connect himself to the game. In this case, he will not be informed that there's someone with a 999999 high score. I don't consider it a bug since it has been designed like this. High scores and frags are counted differently on every machine. Indeed, each machine calculates the high scores according to what it sees. What has happened before does not count at all. No matter if the guy playing on the server has a high score of 999999, what you see if how much he managed to score playing with you.

### Example

This example returns true if the score is greater than a given value.

    function is_score_enough(limit)
        local result

        result=0

        if u61_get_score()>=limit then
            result=1
        end
    end

## u61_get_square_color

### Declaration

    u61_get_square_color(x,y)

- Arguments: the coordinates of a square in the map.
- Return values: the color of the square.
- Rights: map_read.

### Description

This function returns the color of a square in the map. The possible return values are:

- -1 if the square is not activated, ie there's no colored square at the given coordinates.
- 0-7 if there's a colored the square. There are 8 colors, ranging from 0 to 7.

This function is very important in the game, and you'll probably end up in using it all the time if you create scripts for U61. It is the best way to know if there's a square at a given position. You just have to call it and if it returns something greater than 0, then it means there's something.

It is important to note that it is quite different from "u61_get_item_color". Indeed, "u61_get_item_color" takes an index as a single argument, since the block is a vector of squares, whereas "u61_get_block_color" takes the coordinates of the square as an argument. This is because the map and block objects have fundamentaly different structures.

### Example

In this example, we return 1 if there's a square at a given location, and 0 if there's none. This way we have a true/false function which tells us if the place is free.

    function is_there_a_square(x,y)
        local exists

        exists=0

        if u61_get_square_color(x,y)>=0 then
            exists=1
        end

        return exists
    end

## u61_get_time

### Declaration

    u61_get_time()

- Arguments: none.
- Return values: the current system time.
- Rights: map_read.

### Description

This function returns the system time associated to the map. The unit is 0.01 sec, this means that 100 equals one second.

The time can be very usefull, you can for instance use it as a pseudo-random value. This is very important, since the use of any other random value in a script could raise serious problems. Indeed, in U61, all the computers make all the calculus about all the players. So if a script generates internally a random number, then the game may not behave the same on 2 computers which are linked during a network game. By using the time value, you are sure that your pseudo-random number will be exactly the same on any computer, so the game will behave correctly. To sum up, the only pseudo-random values that should be use in U61 are:

- The value returned by "u61_get_time".
- The value returned by "u61_get_score".
- The argument of "user_new_block".
- The argument of "user_new_shape".

The time is always positive, but you should not assume that games start at time 0. Indeed, when a player looses, the game ends, and another game starts, but there's no time reset. This is for the core C++ engine to handle messages correctly. Therefore, the time value can get very great.

### Example

In this example, we use the time as a pseudo-random value. The result is a random number between 0 and range-1.

    function pseudo_random(range)
        return mod(u61_get_time(),range)
    end

## u61_get_width

### Declaration

    u61_get_width()

- Arguments: none.
- Return values: the width of the map.
- Rights: map_read

### Description

Returns the width of the map.

This function always returns 10. So what's the interest in calling it since everyone knows the map is 10 squares wide. Well, it's a good habit to use it, one never knows, U61 scripts might someday be used in a context where maps are lager.

However, I don't think the width of maps is likely to change, since it would induce many changes in the themes. I mean that a theme desgined for 10 columns might look ugly if you use it with 16 columns. I can't think of a nice solution to this problem, I mean one that would enable players to choose their themes/scripts independently and get a good looking result.

So as a conclusion, just use this function to get the width of the map, but please do not plan to use another value than 10 since it would mess up all the themes.

### Example

This function modify the color of a whole line in the map. Only the active colored squares are affected.

    function colorize_row(y,color)
        local x

        x=u61_get_width()-1
        while x>=0 do
            if u61_get_square_color(x,y)>=0 then
                u61_set_square_color(x,y,color)
            end
            x=x-1
        end
    end

## u61_is_block_ok

### Declaration

    u61_is_block_ok()

- Arguments: none.
- Return values: 1 if the block is correctly placed, 0 if there's a conflict with the map.
- Rights: map_read, block_read.

### Description

Returns true if the block is correctly placed, and has a correct shape. By "correct" we mean that:

- there are no squares in the block which are in conflict with the map squares, that's to say we could freeze the block as is without superposing a map square and a block square.
- there are no squares in the block that are outside the map, that's to say too much on the right, left or too low. If the block is too high it does not matter (think of when the block just start falling for instance, and you'll understand why it's obviously possible).

You may use this function when you want to move the block in a complex manner, or completely change it, and really need to keep an accurate control on what's happening. Indeed, this function is called very often by the C++ core engine, and for instance it's perfectly useless to call it in functions like "user_move_down" for instance, since the check is already performed, and you'll only slow down the game by calling it twice.

But a good example of when "u61_is_block_ok" is usefull is a script that needs to make the block cross the entire map, or move it for say at least 10 squares. Then the C++ core engine won't be able to detect if there are squares between the initial and final position. All what the C++ core engine is aware of is the initial and final positions. So this way the block might (from the player point of view) go through a solid wall, which is not what the scripter wants. The scripter wants the block to stop if there's a wall. So what he'll have to do is move the block by steps of 1 square and call "u61_is_block_ok" each time and stop if there's a problem.

It's usually not a problem if at the end of the script function you leave the block in an incorret state, with a conflict. Since the C++ core engine performs himself a check, he will move the block up or sideways so that it fits, or sometimes perform a plain rollback and cancel all your script functions. But if you want to control exactly what's happening, then you'll have to do it yourself in your script.

### Example

In this example, the block is moved in both directions x and y, only if there are no squares on its path. The block is left in an incorrect state but this is not a problem since the C++ core engine will automatically cure the problem.

    function translation_yx_safe(n)
        local i

        i=n
        while i>0 do
            u61_translate_x(1)
    	u61_translate_y(1)
            if u61_is_block_ok()==0 then
                i=0
            end
            i=i-1
        end
    end

## u61_is_curse_available

### Declaration

    u61_is_curse_available()

- Arguments: none.
- Return values: 1 if there is actually a special curse square on the map,0 if there is none.
- Rights: map_read.

### Description

Returns true if there's a special curse square available, that's to say if the "curse state" parameter is set to true *and* the curse square is located on an active square in the map.

This function is very different from "u61_get_curse_state". Indeed, if the special curse square is badly placed, or if it is impossible to place it correctly, for instance when there are no squares at all, then you might get a situation where "u61_get_curse_state" returns true and "u61_is_square_available" returns false. For instance, this is often the case when a new game starts, since there are no squares on the map, and by default the "curse state" parameter is set to true.

### Example

In this example, we return true if we the special curse square is badly placed, ie when "u61_get_curse_state" and "u61_is_curse_available" do not return the same value.

    function is_curse_badly_placed()
        local result

        result=0

        if u61_get_curse_state()==1 and u61_is_curse_available()==0 then
            result=1
        end

        return result
    end

## u61_is_square_exploding

### Declaration

    u61_is_square_exploding(x,y)

- Arguments: the coordinates of a square in the map.
- Return values: 1 if the square is exploding, 0 if not.
- Rights: map_read.

### Description

This function tells if the square is exploding, that's to say if the player can see an explosion at this location.

When this function is called, the square is "still there". Im mean that it is still possible to test its color for instance. Basically, a square is in the exploding state after "u61_blow_up_square" and before "u61_square_blown_up" have been called.

### Example

This function counts all the exploding squares from the map.

    function count_explosions()
        local x
        local y
        local count

        count=0

        y=u61_get_height()-1
        while y>=0 do
            x=u61_get_width()-1
            while x>=0 do
                if not (u61_is_square_exploding(x,y)==0) then
                    count=count+1
                end
                x=x-1
            end
            y=y-1
        end

        return count
    end

## u61_register_curse

### Declaration

    u61_register_curse(curse,time,good)

- Arguments: the id of a curse, the time it should last, and the kind of curse it is.
- Return values: none.
- Rights: map_write.

### Description

This function registers the curse, ie it adds it to the list of active curses. The curse will be active for a limited time, counted in 1/100 of seconds, but a value of 0 should make it last forever - or at least most player won't notice the difference since if you use 0 the curse will last for about 10 hours...

Used with the "u61_get_curse_age", this function allows you program "persistent" curses. By persistent curse I mean a curse which is displayed in the player's status zone (represented with a little skull in the default theme) and can be cancelled by an antidote. A typical non-persistent curse is a curse that fills your map with grabage. A typical persistent curse is the curse that forbids you to use some of your keyboard keys.

Curses set up with "u61_register_curse" can be cancelled manually with "u61_cancel_curse". Otherwise they will disappear automatically after some time.

The third parameter allows you to choose wether the curse is a real bad curse or if it's a "good" curse. Basically, it's up to you to decide which curses are good and which aren't. Basically a curse that accels the player is a bad one, and one that slows the player is a good one, since it makes the game easier. So in fact a "good" curse is an "anti-curse", it's a benediction opposed to a malediction. For U61's C++ engine, the only difference between good curses and bad curses is that the icons used to represent them on the screen are not the same.

### Example

In this example, we have defined a function that handles remote curses (see the definition of "u61_send_curse"). And if the curse id is greater than 50, then we assume the curse is a persistent one, so we set it up for a time of 60, that's to say about 1 minute.

    function my_handle_remote_curse(curse)
        if curse>50 then
            u61_register_curse(curse,6000,0)
        end
    end

## u61_send_curse

### Declaration

    u61_send_curse(curse)

- Arguments: the id of a curse.
- Return values: none.
- Rights: map_write.

### Description

This function sends a curse to the default victim of the current player.

It is probably one the most interesting function in U61. At least it is definitely *the* function which makes U61 a cool (?) game. Basically, this function sends a message over the network - if needed of course - to a remote player, and on the remote machine, the "user_do_curse" function is called. This allows a player to alter the map of another player.

A mojor pitfall is to get confused with the difference between what I call a local curse and a remote curse:

- A local curse is issued when the special "curse square" explodes for instance. The consequence is a call to "user_do_curse" in the map where the square disappeared with the second parameter set to 0. In most of the cases, a local curse will do something positive on the player's map, such as clearing it.
- A remote curse is issued after an explicit call to "u61_send_curse". The consequence is a call to "user_do_curse" in the map of the default victim (the name of the victim is displayed in the player's status zone), with the second parameter set to 1. Any script code that has a "map_write" access may call "u61_send_curse". This way, remote curses can be launched in many situations. In most of the cases, a remote curse will do something negative on the player'smap, such as filling it with garbage.

### Example

In this example, the player sends a "SPECIAL_CURSE_1" and a "SPECIAL_CURSE_2" to its default victim. This function might be called within "user_do_curse", but it'snot necessary, you could also call it when the player has matched a very rare pattern.

    SPECIAL_CURSE_1=51
    SPECIAL_CURSE_2=52

    function send_special_package()
        u61_send_curse(SPECIAL_CURSE_1)
        u61_send_curse(SPECIAL_CURSE_2)
    end

## u61_set_anticipation_state

### Declaration

    u61_set_anticipation_state(state)

- Arguments: a boolean (1 or 0) telling if this mode should be on or off.
- Return values: one.
- Rights: map_write.

### Description

This function sets the state of the anticipation mode, that means wether the player should see where the block will land if he presses the "drop" key right away.

As mentionned in the doc of "u61_get_anticipation_state", this parameter is mixed with the value entered by the player in the menus, and the preview of where the block will land is drawn only if both are true. Basically, it should be easier to play with this mode set to true, but some players (me for instance) find that in the long run it's not so great to have it set on. So in your scripts, you might decide that a curse disables this mode (to make the game harder) and enables it back when the curse is over. But for players like me who do not like the anticipation mode, it would be annoying to see this mode appearing when I have said in my options that I do not want to have it. So it's OK to call this function with false if you want to make things a little harder, but just remember that it will do nothing on players who have the option set to false anyway.

### Example

In this example, we set the mode to false or true according to a curse state.

    ID_HALF_BLIND=8

    function update_half_blind()
        if u61_get_curse_age(ID_HALF_BLIND)>=0 then
            u61_set_anticipation_state(0)
        else
            u61_set_anticipation_state(1)
        end
    end

## u61_set_block_x

### Declaration

    u61_set_block_x(x)

- Arguments: The x coordinate of the block.
- Return values: None
- Rights: block_write

### Description

This function changes the global x coordinate of the block. Basically, it allows translation.

This function is very important, since it's not possible to perform a translation by calling "u61_set_item_x". Indeed, the "u61_center_block", which is called quite often, modifies the individual coordinates of each squares in a block so that it's centered on (x,y), x and y being set by "u61_set_block_x" and "u61_set_block_y". So you *need* to call this function if you want to translate the block horizontally.

### Example

In this example, we move the block to the middle of the map.

    function to_middle()
        u61_set_block_x(5)
    end

## u61_set_block_y

Exactly the same as "u61_set_block_x", but x becomes y...

## u61_set_curse_state

### Declaration

    u61_set_curse_state(state)

- Arguments: 1 if the special curse square is to be activated, 0 if not.
- Return values: none.
- Rights: map_write.

### Description

Sets the current "curse state", ie tells if there should be a special curse square available on the map.

As I'm writting this document, the "curse_state" parameter is set to true on a regular basis, so if you really want to remove the curse permanently, you have to call "u61_set_curse_state" continuously. By default, the curse will be disable for a given time (corresponding to a curse period, that's to say the delay until the curse moves and/or changes).

### Example

In this example, we disable the special curse square when the user has more than 100000 points. This should prevent scores from getting too high...

    function limit_score_with_curse()
        if u61_get_score()>100000 then
            u61_set_curse_state(0)
        end
    end

## u61_set_curse_x

### Declaration

    u61_set_curse_x(x)

- Arguments: the x coordinate of the special curse square.
- Return values: none.
- Rights: map_write.

### Description

Sets the x position of the special curse square - that's to say the square which launches curses when it explodes, in the default theme it is the black and white "?".

Note that if you call this function with an invalid parameter, ie a position which is outside the map or where there's no active square, then the special curse square won't be visible. In fact, you'll end up in a situation where "u61_get_curse_state" returns true and "u61_is_curse_available" returns false, even if you have set the curse square as active with "u61_set_curse_state".

You should also keep in mind that it's not really necessary to call this function to move the curse square on a regular basis, since this is already done by the C++ core engine. In fact, this function is usefull when you mess up the whole map with calls to "u61_set_square_color", remove accidentally the square which was at the special square's location, and still want the special square to be available. In this case, you have to move the special curse square manually.

### Example

In this example, we put the curse square on the first active square founded. The search starts at the bottom of the map.

    function put_curse_on first()
        local x
        local y

        y=u61_get_height()-1
        while y>=0 do
            x=u61_get_width()-1
            while x>=0 do
                if u61_get_square_color(x,y)>=0 then
                    u61_set_curse_x(x)
                    u61_set_curse_y(y)
                    x=-1
                    y=-1
                end
                x=x-1
            end
            y=y-1
        end
    end

## u61_set_curse_y

Exactly the same as "u61_set_curse_x", but x becomes y...

## u61_set_global

### Declaration

    u61_set_global(i,value)

- Arguments: an index and a value.
- Return values: none.
- Rights: map_write.

### Description

This function updates the global value associated to a given index (between 0 and 99).

This function is by no way related to the luac "setglobal" function. Indeed, in U61, you must *not* use any global lua variable to store parameters. Lua globals can only be used to store constants. This is due to the fact that if you use global lua variables:

- They will be shared by all the players, which might not be what you want.
- They won't be shared accross the network, since the core engine does not transmit lua globals between computers.

Therefore, the chances that you end up with a wrecked game are important. Please do not try to do it, for this kind of bug never appears when you test your script with a single player, but will always occur during a thrilling internet play. See Murphy's theory.

So "u61_get_global" and "u61_set_global" are here to help you in case you want to have a persistent value stored. The values accessed with these functions are different for each player, and do not generate any inconsistency when used in a network game. Basically thay consist in a array of numbers, where you can store your own values, for instance parameters linked to a curse. These numbers are set to 0 each time a new game starts, ie each time the map is filled with squares and the player looses.

As of today, numbers are the only lua type which is usable with this function. It's actually a severe limitation, since being possible to store any lua object would make the writting of scripts a lot easier. However, I haven't yet managed to find a nice solution to this problem. It's true that lua offers the possibility to get a reference on any object, but I fear such a method would lead to memory problems - at least until I or someone else finds a way to handle references in a clean manner.

Please keep in mind that if you want to use a global value such as a boolean telling if the player has the right to do some special action, then "u61_register_curse" might be a better choice than "u61_set_global".

### Example

The following function decrements the value of a global counter.

    ID_COUNTER=8

    function decrement_counter()
        u61_set_global(ID_COUNTER,u61_get_global()-1)
    end

## u61_set_item_color

### Declaration

    u61_set_item_color(i,color)

- Arguments: the index and color of the square.
- Return values: none.
- Rights: block_write

### Description

Modifies the color of a square in the block.

The color should normally always be a regular color (ie between 0 and 7), since having an empty square in a block does not really make any sense.

### Example

The following example sets all the squares of the block to the given color.

    function set_color(color)
        local i

        i = u61_get_nb_items()-1
        while i>=0 do
            u61_set_item_color(i,color)
            i=i-1
        end
    end

## u61_set_item_x

### Declaration

    u61_set_item_x(i,x)

- Arguments: the index of the square, and its x coordinate.
- Return values: none.
- Rights: block_write

### Description

This function modifies the x coordinate of a square in the block.

Note that the returned coordinate is not absolute. This means that if you want to set the real position of this square in the map, you'll need to call the "u61_get_block_x" function too.

### Example

This function sets the absolute position of a square in the block, ie its position in the map. So wherever the block may be, calling "set_absolute_x(0,0)" will place the first square of the block in the leftmost column of the map.

    function set_absolute_x(i,x)
        u61_set_item_x(i,x-u61_get_block_x())
    end

## u61_set_item_y

Exactly the same as "u61_set_item_x", but x becomes y...

## u61_set_preview_state

### Declaration

    u61_set_preview_state(state)

- Arguments: the state for the preview mode (1=on, 0=off).
- Return values: none.
- Rights:

### Description

Sets the preview state of the player. The preview is what shows the player what kind of block he will get next time a block falls.

This function would typically used in a curse, to remove the great help provided by the preview, and put the player in a difficult position.

### Example

This example sets the preview mode to false if the score is greater than 100000. It assumes that any player capable of getting such a high score is good enough to play without a preview.

    function disable_preview_for_good_players()
        if u61_get_score()>100000 then
            u61_set_preview_state(0)
        end
    end

## u61_set_score

### Declaration

    u61_set_score(score)

- Arguments: the new score.
- Return values: none.
- Rights: map_write.

### Description

This function updates the current score.

You'll have to remember that scores should not exceed 999.999, so that they can fit on 6 digits. However, if you exceed this limit, the value will be truncated to 999.999 anyway.

### Example

The following example doubles the score of the player.

    function double_score()
        u61_set_score(u61_get_score()*2)
    end

## u61_set_square_color

### Declaration

    u61_set_square_color(x,y,color)

- Arguments: the coordinates of a square, and its color.
- Return values: none.
- Rights: map_write.

### Description

This function sets the color of a square in the map. The possible values for color are:

- -1 if the square is to be disabled.
- 0-7 if one whishes to put a colored square in this location.

Any call with an invalid color (lower than 0 or greater than 7) will result in setting the color to -1. The question is: "why should the game be limited to 8 colors?". well, in fact, I had to fix a limited number of colors, since theme creation would have been too complex with a flexible number of colors. Indeed, you would have risked to get a 16-color based script with an 8-color based theme. And then you can't play since you can not distinguish all types of squares. So I had to set up a limit. I chose 8 and think it's a good compromise between rich gameplay and easyness of theme creation.

In the scritps and themes I have created, I have tried to respect the following rules:

- Colors 0-6 are standard colors for blocks.
- Color 7 is a special color, used for squares that are generated by curses and which in a general manner don't come with standard blocks. In the "classic" theme, theses are the grey squares.

However, this is just a convention, and you can bypass it. Still, players might find the game more consistent if you respect it,

### Example

This example moves all the squares from the current block to the map. This is what is done before the "user_match_pattern" function is called. However, you should never need such a function - it's only an example - since this work is automatically done by the C++ core engine.

    function block_to_map()
        local i
        local x
        local y
        local color

        i = u61_get_nb_items()-1
        while i>=0 do
            x=u61_get_item_x(i)+u61_get_block_x(i)
            y=u61_get_item_y(i)+u61_get_block_y(i)
            color=u61_get_item_color(i)
            u61_set_square_color(x,y,color)
            i=i-1
        end
        u61_clear_block()
    end

This documentation is also available on: www.ufoot.org.
Contact author: ufoot@ufoot.org