lipk's WML poems

[lipk]

"And so I'll do some fancy hacks
To create things which Wesnoth lacks,
Hope my efforts are not in vain,
They help you improve your campaign."



Working on my own project(s), I sometimes produce code which could be usable for others as well. Instead of hiding it in the attic or creating a separate thread for each one, I'm going to post them here.

So here we go:

Flood
v2.2 on 29.08.11

flood-utils.cfg

(4.72 KiB) Downloaded 254 times

Description: a set of macros to make a certain terrain type spread over the map, and convert other terrains using a given 'terrain table'.

Spoiler:

Minimum required version: 1.9

Usage: see the relevant section on the wiki page.

Additional credits: Sapient (improvements in general)

Code: Select all

    #version 2.2
    #last modification: 29.08.11

    #define INVERT_DIRECTIONS DIRECTIONS OUT_VAR
       #a macro to change directions to their opposites (n->s, sw->ne, etc)
       #DIRECTIONS is a comma-separated list of directions
       #OUT_VAR is the variable to write the output in.

    [set_variables]
       name=TMP_inverted_directions
       [split]
          list={DIRECTIONS}
          separator=","
          key=direction
          remove_empty=yes
       [/split]
    [/set_variables]

    {FOREACH TMP_inverted_directions TMP_ID_i}
            [set_variable]
                    name=TMP_inverted_directions[$TMP_ID_i].direction
                    value="-" + $TMP_inverted_directions[$TMP_ID_i].direction
            [/set_variable]
    {NEXT TMP_ID_i}

    {CLEAR_VARIABLE {OUT_VAR}}

    [set_variable]
       name={OUT_VAR}
       [join]
          variable=TMP_inverted_directions
          separator=","
          key=direction
       [/join]
    [/set_variable]

    {CLEAR_VARIABLE TMP_inverted_directions}
    #enddef

    #define STORE_FLOODABLE_LOCATIONS SOURCE DIRECTIONS TERRAINS OUT_VAR
       #stores hexes of type TERRAINS whose neighbour in one of DIRECTIONS directions can be found in SOURCE
       #SOURCE is an array of locations
       #DIRECTIONS is a list of directions
       #TERRAINS comma-separated list of terrain codes
       #OUT_VAR the variable to write the output in
       #
       #NOTE: this macro is in fact used to store the hexes of type TERRAINS which are neighbours of SOURCE in
       #certain directions, but we achieve that by inverting those directions outside of this macro. See INVERT_DIRECTIONS.

    [store_locations]
       variable={OUT_VAR}

       terrain={TERRAINS}

       [filter_adjacent_location]
          adjacent={DIRECTIONS}
         find_in={SOURCE}
       [/filter_adjacent_location]
    [/store_locations]
    #enddef


    #define SPLIT_PAIRS PAIRS SEP1 SEP2 OUT_VAR
    [set_variables]
       name=TMP_pairs
       [split]
          list={PAIRS}
          key=pair
          separator={SEP1}
          remove_empty=true
       [/split]
    [/set_variables]

    {FOREACH TMP_pairs TMP_SP_i}
       [set_variables]
          name=TMP_splitted
          [split]
             list=$TMP_pairs[$TMP_SP_i].pair
             separator={SEP2}
             key=value
          [/split]
       [/set_variables]

       [set_variable]
          name={OUT_VAR}[$TMP_SP_i].value1
          value=$TMP_splitted[0].value
       [/set_variable]
       [set_variable]
          name={OUT_VAR}[$TMP_SP_i].value2
          value=$TMP_splitted[1].value
       [/set_variable]
    {NEXT TMP_SP_i}

    {CLEAR_VARIABLE TMP_pairs}
    {CLEAR_VARIABLE TMP_splitted}
    #enddef

    #define FLOOD_SINGLE_HEX X Y TERRAIN_TABLE
    [store_locations]
       variable=TMP_current_hex
       x={X}
       y={Y}
    [/store_locations]

    {FOREACH {TERRAIN_TABLE} FSH_i}
       [if]
          [variable]
             name=TMP_current_hex.terrain
             equals=${TERRAIN_TABLE}[$FSH_i].value1
          [/variable]
          [then]
             {MODIFY_TERRAIN ${TERRAIN_TABLE}[$FSH_i].value2 {X} {Y}}
             [set_variable]
                name=FSH_i
                value=${TERRAIN_TABLE}.length
             [/set_variable]
          [/then]
       [/if]
    {NEXT FSH_i}


    {CLEAR_VARIABLE TMP_current_hex}
    #enddef

    #define SET_FLOOD_TERRAIN_TABLE TERRAIN_TABLE DATA_VAR
    {SPLIT_PAIRS {TERRAIN_TABLE} ";" ">" {DATA_VAR}.terrain_table}
    [set_variable]
       name={DATA_VAR}.floodable_terrains
       [join]
          variable={DATA_VAR}.terrain_table
          separator=","
          key=value1
       [/join]
    [/set_variable]
    #enddef

    #define SET_FLOOD_DIRECTIONS DIRECTIONS DATA_VAR
    {INVERT_DIRECTIONS {DIRECTIONS} {DATA_VAR}.directions}
    #enddef

    #define SET_FLOOD_SOURCE SOURCE DATA_VAR
    {SPLIT_PAIRS {SOURCE} ";" "," TMP_source_coordinates}
    [set_variable]
       name=TMP_fields_x
       [join]
          variable=TMP_source_coordinates
          key=value1
          separator=","
       [/join]
    [/set_variable]
    [set_variable]
       name=TMP_fields_y
       [join]
          variable=TMP_source_coordinates
          key=value2
          separator=","
       [/join]
    [/set_variable]

    [store_locations]
       variable={DATA_VAR}.fields
       x=$TMP_fields_x
       y=$TMP_fields_y
    [/store_locations]
    #enddef

    #define CREATE_FLOOD SOURCE DIRECTIONS TERRAIN_TABLE DATA_VAR
    [clear_variable]
       name={DATA_VAR}
    [/clear_variable]

    {SET_FLOOD_SOURCE {SOURCE} {DATA_VAR}}
    {SET_FLOOD_TERRAIN_TABLE {TERRAIN_TABLE} {DATA_VAR}}
    {SET_FLOOD_DIRECTIONS {DIRECTIONS} {DATA_VAR}}
    #enddef

    #define SPREAD_FLOOD DATA_VAR
    {STORE_FLOODABLE_LOCATIONS {DATA_VAR}.fields ${DATA_VAR}.directions ${DATA_VAR}.floodable_terrains {DATA_VAR}.fields}

    {FOREACH {DATA_VAR}.fields TMP_SF_i}
       {FLOOD_SINGLE_HEX ${DATA_VAR}.fields[$TMP_SF_i].x ${DATA_VAR}.fields[$TMP_SF_i].y {DATA_VAR}.terrain_table}
    {NEXT TMP_SF_i}
    [redraw][/redraw]

    [store_unit]
       variable=TMP_submerged_units
       [filter]
          [filter_location]
             find_in={DATA_VAR}.fields
          [/filter_location]
       [/filter]
    [/store_unit]

    {FOREACH TMP_submerged_units TMP_SF_i}
       [fire_event]
          [primary_unit]
             id=$TMP_submerged_units[$TMP_SF_i].id
          [/primary_unit]
          name=submerged
       [/fire_event]
    {NEXT TMP_SF_i}

    {CLEAR_VARIABLE TMP_submerged_units}
    #enddef

Shroud on rooms
v1.0 on 27.09.11

room-shroud-utils.cfg

(2.79 KiB) Downloaded 240 times

Description: allows to define specific areas on the map surrounded by a certain terrain (these are the so-called rooms), and place/remove shroud on/from there at once.

Spoiler:

Minimum required version: 1.9

Usage: the code includes four macros: DEFINE_ROOM, PLACE_SHROUD_ON_ROOM, REMOVE_SHROUD_FROM_ROOM and REMOVE_SHROUD_FROM_ROOM_BY_UNIT. DEFINE_ROOM is used to specify the locations the room consists of.

Code: Select all

#usage: DEFINE_ROOM LOCATION_X LOCATION_Y ENTRANCES_X ENTRANCES_Y WALL_TYPE INCLUDE_WALL DATA_VAR
{DEFINE_ROOM 2 2 6,4 6,5 Xo yes dark_room}

Where LOCATION_X;LOCATION_Y is just any hex of the room, ENTRANCES_X;ENTRANCES_Y are a list of locations which aren't of the wall's terrain type, but they still should be treated as the border of the room, WALL_TYPE is obviously the terrain which surrounds the room, INCLUDE_WALL is a yes/no argument which tells whether shroud should placed on/removed from the wall on the very edge of the room as well. DATA_VAR is the variable to put the stored locations in.

PLACE_SHROUD_ON_ROOM and REMOVE_SHROUD_FROM_ROOM are pretty straightforward:

Code: Select all

#usage: PLACE_SHROUD_ON_ROOM SIDE_FILTER DATA_VAR
{PLACE_SHROUD_ON_ROOM side=1 dark_room}
#usage: ~
{REMOVE_SHROUD_FROM_ROOM side=1 dark_room}

Note that REMOVE_SHROUD_FROM_ROOM will fire a sighted event for every unit which is placed in any hex of the room (unfortunately, even for those who weren't shrouded. I'm just realising this while typing so it may be fixed later...). This sighted event won't have secondary unit.

REMOVE_SHROUD_FROM_ROOM_BY_UNIT works exactly like REMOVE_SHROUD_FROM_ROOM, with the only exception that it expects a unit filter instead of side filter. The shroud will be lifted for the unit's side, and the unit will be used as the secondary unit of any possible sighted events.

Code: Select all

#version 1.0
#last modification: 27.09.11

#define DEFINE_ROOM LOCATION_X LOCATION_Y ENTRANCES_X ENTRANCES_Y WALL_TYPE INCLUDE_WALLS DATA_VAR

[store_locations]
	variable=TMP_entrances
	x={ENTRANCES_X}
	y={ENTRANCES_Y}
[/store_locations]	

[store_locations]
	variable={DATA_VAR}
	x={LOCATION_X}
	y={LOCATION_Y}
[/store_locations]

[set_variable]
	name=TMP_room_prev_count
	value=${DATA_VAR}.length
[/set_variable]

[while]
	[variable]
		name=TMP_break
		not_equals=true
	[/variable]
	[do]
		[store_locations]
			variable={DATA_VAR}
			mode=append

			terrain=!,{WALL_TYPE}
			[and]
				[not]
					find_in=TMP_entrances
				[/not]
			[/and]
			[and]
				[filter_adjacent_location]
					find_in={DATA_VAR}
				[/filter_adjacent_location]
			[/and]
		[/store_locations]
		[if]
			[variable]
				name={DATA_VAR}.length
				equals=$TMP_room_prev_length
			[/variable]
			[then]
				[set_variable]
					name=TMP_break
					value=true
				[/set_variable]
			[/then]
			[else]
				[set_variable]
					name=TMP_room_prev_length
					value=${DATA_VAR}.length
				[/set_variable]
			[/else]
		[/if]
	[/do]
[/while]

[set_variable]
	name=TMP_include_walls
	value={INCLUDE_WALLS}
[/set_variable]

[if]
	[variable]
		name=TMP_include_walls
		equals=yes
	[/variable]
	[then]
		[store_locations]
			variable={DATA_VAR}
			mode=append

			[filter_adjacent_location]
				find_in={DATA_VAR}
			[/filter_adjacent_location]
		[/store_locations]
	[/then]
[/if]

{CLEAR_VARIABLE TMP_break}
{CLEAR_VARIABLE TMP_include_walls}
{CLEAR_VARIABLE TMP_room_prev_length}
{CLEAR_VARIABLE TMP_entrances}

#enddef

#define PLACE_SHROUD_ON_ROOM SIDE_FILTER DATA_VAR
[place_shroud]
	[filter_side]
		{SIDE_FILTER}
	[/filter_side]

	find_in={DATA_VAR}
[/place_shroud]
[redraw][/redraw]
#enddef

#define REMOVE_SHROUD_FROM_ROOM SIDE_FILTER DATA_VAR 
[remove_shroud]
	[filter_side]
		{SIDE_FILTER}
	[/filter_side]

	find_in={DATA_VAR}
[/remove_shroud]

[store_unit]
	variable=TMP_sighted_units

	[filter]
		[filter_location]
			find_in={DATA_VAR}
		[/filter_location]
	[/filter]
[/store_unit]

{FOREACH TMP_sighted_units TMP_RSFR_i}
	[fire_event]
		name=sighted
		[primary_unit]
			id=$TMP_sighted_units[$TMP_RSFR_i].id
		[/primary_unit]
	[/fire_event]
{NEXT TMP_RSFR_i}

{CLEAR_VARIABLE TMP_sighted_units}
[redraw][/redraw]
#enddef

#define REMOVE_SHROUD_FROM_ROOM_BY_UNIT UNIT DATA_VAR 
[remove_shroud]
	side=${UNIT}.side

	find_in={DATA_VAR}
[/remove_shroud]

[store_unit]
	variable=TMP_sighted_units

	[filter]
		[filter_location]
			find_in={DATA_VAR}
		[/filter_location]
	[/filter]
[/store_unit]

{FOREACH TMP_sighted_units TMP_RSFR_i}
	[fire_event]
		name=sighted
		[primary_unit]
			id=$TMP_sighted_units[$TMP_RSFR_i].id
		[/primary_unit]
		[secondary_unit]
			id=${UNIT}.id
		[/secondary_unit]
	[/fire_event]
{NEXT TMP_RSFR_i}

{CLEAR_VARIABLE TMP_sighted_units}
[redraw][/redraw]
#enddef

Toss units
v1.1 on 17.10.11

toss-utils.cfg

(3.23 KiB) Downloaded 224 times

Description: this pretty idiot macro lets you push a unit with another by one hex and if there's somebody else in the tossed one's path, he will push him too.

Spoiler:

Minimum required version: 1.9

Usage: {TOSS UNIT1 UNIT2} where UNIT1 and UNIT2 are stored units. UNIT2 tosses UNIT1 which moves straight away from UNIT2 and, if there is, pushes off the unit from the hex he arrives to (and so on). Whenever a unit is pushed, either directly via the macro or as a result of some other unit being tossed, a 'tossed' event is fired. It only has a primary unit which is the unit being pushed. The event is fired before the unit gets moving! You can use this event to harm the unit, play sound or whatever.

Known problems:
- strange things happen when you try to push somebody to hex impassable for him (including map edges)
- tossed event lacks secondary unit

Code: Select all

#version 1.1
#last modification: 17.10.11

#define TOSS UNIT1 UNIT2
[if]
	[have_location]
		x=${UNIT1}.x
		y=${UNIT1}.y
		[filter_adjacent_location]
			x=${UNIT2}.x
			y=${UNIT2}.y
		[/filter_adjacent_location]
	[/have_location]

	[then]
		[fire_event]
			name=tossed
			
			[primary_unit]
				id=${UNIT1}.id
			[/primary_unit]
		[/fire_event]
		[store_unit]
			variable=TMP_tossed[0]
			kill=yes
			mode=replace
			[filter]
				id=${UNIT1}.id
			[/filter]
		[/store_unit]
		[store_unit]
			variable=TMP_tosser
			[filter]
				id=${UNIT2}.id
			[/filter]
		[/store_unit]
		
		[while]
			[variable]
				name=TMP_T_loop
				not_equals=true
			[/variable]
			
			[do]
				[set_variable]
					name=TMP_destination_x
					value="$( 2*$TMP_tossed[$($TMP_tossed.length - 1)].x - $TMP_tosser.x )"
				[/set_variable]
				[set_variable]
					name=TMP_destination_y
					value="$( 2*$TMP_tossed[$($TMP_tossed.length - 1)].y - $TMP_tosser.y + (($TMP_tossed[$($TMP_tossed.length - 1)].x - $TMP_tosser.x)^2)*( - ($TMP_tossed[$($TMP_tossed.length - 1)].x % 2) + (($TMP_tossed[$($TMP_tossed.length - 1)].x + 1) % 2)  ))"
				[/set_variable]

			
				[move_unit_fake]
					type=$TMP_tossed["$($TMP_tossed.length - 1)"].type
					side=$TMP_tossed["$($TMP_tossed.length - 1)"].side
					x=$TMP_tossed["$($TMP_tossed.length - 1)"].x,$TMP_destination_x
					y=$TMP_tossed["$($TMP_tossed.length - 1)"].y,$TMP_destination_y
				[/move_unit_fake]
				[if]
					[have_unit]
						x=$TMP_destination_x
						y=$TMP_destination_y
					[/have_unit]
					[then]
					
						[fire_event]
							name=tossed
					
							[primary_unit]
								x=$TMP_destination_x
								y=$TMP_destination_y
							[/primary_unit]
						[/fire_event]
						[store_unit]
							variable=TMP_tossed
							mode=append
							kill=yes
							[filter]
								x=$TMP_destination_x
								y=$TMP_destination_y
							[/filter]
						[/store_unit]
						
						[unstore_unit]
							variable=TMP_tossed["$($TMP_tossed.length - 2)"]
							x=$TMP_destination_x
							y=$TMP_destination_y
						[/unstore_unit]
						[fire_event]
							name=moveto
							[primary_unit]
								x=$TMP_destination_x
								y=$TMP_destination_y
							[/primary_unit]
						[/fire_event]
				
						[store_unit]
							variable=TMP_tosser
							mode=replace
							[filter]
								id=$TMP_tossed["$($TMP_tossed.length - 2)"].id
							[/filter]
						[/store_unit]
						
						[set_variable]
							name=TMP_tosser.x
							value=$TMP_tossed["$($TMP_tossed.length - 2)"].x
						[/set_variable]
						[set_variable]
							name=TMP_tosser.y
							value=$TMP_tossed["$($TMP_tossed.length - 2)"].y
						[/set_variable]
					[/then]
					[else]
						[unstore_unit]
							variable=TMP_tossed["$($TMP_tossed.length - 1)"]
							x=$TMP_destination_x
							y=$TMP_destination_y
						[/unstore_unit]
						[set_variable]
							name=TMP_T_loop
							value=true
						[/set_variable]
					[/else]
				[/if]
			[/do]
		[/while]							
	[/then]
[/if]

{CLEAR_VARIABLE TMP_destination_x}
{CLEAR_VARIABLE TMP_destination_y}
{CLEAR_VARIABLE TMP_tosser}
{CLEAR_VARIABLE TMP_T_loop}

{FOREACH TMP_tossed TMP_T_i}
	{CLEAR_VARIABLE TMP_tossed[$TMP_T_i]}
{NEXT TMP_T_i}
#enddef

Have fun!

[lipk]

Here's a new macro 'Toss units'. I've changed my mind about the separate-thread-for-complex-code policy, I'm not going to create a thread for whatever big WML monsters.

From now on, you can download code as attachment too.

[lipk]

Fixed up a stupid little mistype in Toss units.

Since I'm serious about updating these macros sometimes, I decided to give a version number to each one, so you can easily check if you have the latest version.
All download counters set to zero

[lipk]

After a long time, here's a new one. It's rather a Lua poem, but who cares?

rotate_area tag
v1.1 on 05.02.12



Description: a new WML tag which allows you to rotate hexagonal areas on the map around their centres.

Spoiler:

Minimum required version: 1.9

Usage: insert the {ENABLE_AREA_ROTATION} macro in a prestart event of the scenario you wish to use this feature in. From then on, you have a rotate_area tag, usable inside event tags. It has the following keys: x,y: the centre of the hexagonal area you wish to rotate, radius: the size of the area, move_units: whether to rotate units along with their locations (default yes), fire_event: whether to fire a moveto event for each unit rotated (default yes)

Code:

Code: Select all

#version 1.1
#last modification: 05.02.12

#define ENABLE_AREA_ROTATION
	[lua]
		code = <<

local helper = wesnoth.require "lua/helper.lua"

function sort_ring(ring, radius)
	local result = {}
	
	for i = 1, radius + 1 do
		table.insert(result, ring[i])
	end
	
	for i = 1, 4*radius - 2 do
		local element =  ring[i + radius + 1]
		if i%2 == 1 then
			table.insert(result, 1, element)
		else
			table.insert(result, element)
		end
	end
	
	for i = 5*radius, 6*radius do
		table.insert(result, 1, ring[i])
	end
	
	return result
end

function get_new_index(index, radius)
	local result = index + radius
	if (result > 6*radius) then
		result = result - 6*radius
	end
	
	return result
end

function rotate_ring(ring, radius)
	local result = { }
	
	for i,elem in ipairs(ring) do
		local new_index = get_new_index(i, radius)
		result[new_index] = elem
	end
	
	return result
end

function wesnoth.wml_actions.rotate_area(cfg)

	local radius_ = cfg.radius
	local x_ = cfg.x
	local y_ = cfg.y
	
	local rings = {}
	local excluded_locs = { { x = x_, y = y_} }
	local moved_units = { }
	
	for i = 1, radius_ do
		helper.set_variable_array("__RA_excluded_locs", excluded_locs)
		
		local current_ring = wesnoth.get_locations {
								{"not", { find_in = "__RA_excluded_locs" } },
								{"and", {
											x = x_,
											y = y_,
											radius = i
										}
								}
							}
		
		
		for n=1, 6*i do
			table.insert (excluded_locs, { x = current_ring[n][1], y = current_ring[n][2]})
			current_ring[n][3] = wesnoth.get_terrain(current_ring[n][1], current_ring[n][2])
		end
		
		current_ring = sort_ring(current_ring, i)
		rotated_ring = current_ring
		
		
		for n = 1, cfg.times do
			rotated_ring = rotate_ring(rotated_ring, i)
		end
		
		for n,elem in ipairs(current_ring) do
			wesnoth.set_terrain ( elem[1], elem[2], rotated_ring[n][3] )
			
			local unit = wesnoth.get_unit (elem[1], elem[2])
			if unit ~= nil then
				table.insert(moved_units, {id = unit.id, x = rotated_ring[n][1], y = rotated_ring[n][2]} )
			end
		end

	end
	
	wesnoth.fire "redraw"
	
	if cfg.move_units ~= false then	
		for i,unit in ipairs(moved_units) do
			wesnoth.fire ( "store_unit", { { "filter", { id = unit.id } }, variable = "__RA_stored_units[" .. i .. "]", kill = true } )
		end
		
		for i,unit in ipairs(moved_units) do
			wesnoth.fire ( "unstore_unit", { variable = "__RA_stored_units[" .. i .. "]", x = unit.x, y = unit.y } )
		end
		
		if cfg.fire_event ~= false then
			for i,unit in ipairs(moved_units) do
				wesnoth.fire_event ("moveto", unit.x, unit.y)
			end
		end
	end
	
end

		>>
	[/lua]
#enddef

Have fun!

[lipk]

rotate_area updated to version 1.1, fixing a bug which might have moved units to the wrong place under certain circumstances. Also updated the description: the move_unit key is in fact move_units.