FormulaAI/Replacing - Revision history

Celtic Minstrel: /* Candidate Actions */ Missed id and name in the converted example

2023-04-09T03:26:15Z

Candidate Actions: Missed id and name in the converted example

← Older revision		Revision as of 03:26, 9 April 2023
Line 605:		Line 605:
	[ai]		[ai]
	[stage]		[stage]
			id=rca_formulas
			name=ai_default_rca::candidate_action_evaluation_loop
	[candidate_action]		[candidate_action]
	engine=lua		engine=lua

Celtic Minstrel: /* Candidate Actions */ A bit more of an explanation on filters

2023-04-09T03:25:15Z

Candidate Actions: A bit more of an explanation on filters

← Older revision		Revision as of 03:25, 9 April 2023
Line 623:		Line 623:
	[/ai]		[/ai]
	</syntaxhighlight>		</syntaxhighlight>

			As you can see, the <tt>[filter]</tt> from the FormulaAI candidate action becomes a <tt>[filter_own]</tt> on the Lua candidate action. This only works for "me" filters in the FormulaAI, however. An attack formula also has a "target" filter, but Lua candidate actions have no equivalent – you could add the contents of the filter under <tt>[args]</tt>, but the Lua code still needs to be written to read and obey that filter.

	== Translating Code ==		== Translating Code ==

	'''to be filled in'''		'''to be filled in'''

Celtic Minstrel: /* Formula Priorities */ Add an extra variable to make it a bit clearer what select() is doing here

2023-04-09T03:15:44Z

Formula Priorities: Add an extra variable to make it a bit clearer what select() is doing here

← Older revision		Revision as of 03:15, 9 April 2023
Line 511:		Line 511:
	max_score=10000010		max_score=10000010
	evaluation=<<		evaluation=<<
	local u = ~~wesnoth.units.find(~~select(4, ...))[1]		local filter_own = select(4, ...)
			local u = wesnoth.units.find(filter_own)[1]
	if not u then return 0 end		if not u then return 0 end
	return ai.check_attack(u,3,12).ok and 10000010 or 0		return ai.check_attack(u,3,12).ok and 10000010 or 0
	>>		>>
	execution=<<		execution=<<
	local u = ~~wesnoth.units.find(~~select(4, ...))[1]		local filter_own = select(4, ...)
			local u = wesnoth.units.find(filter_own)[1]
	ai.attack(u,3,12)		ai.attack(u,3,12)
	>>		>>
Line 531:		Line 533:
	max_score=10000009		max_score=10000009
	evaluation=<<		evaluation=<<
	local u = ~~wesnoth.units.find(~~select(4, ...))[1]		local filter_own = select(4, ...)
			local u = wesnoth.units.find(filter_own)[1]
	if not u then return 0 end		if not u then return 0 end
	return ai.check_attack(u,3,12).ok and 10000009 or 0		return ai.check_attack(u,3,12).ok and 10000009 or 0
	>>		>>
	execution=<<		execution=<<
	local u = ~~wesnoth.units.find(~~select(4, ...))[1]		local filter_own = select(4, ...)
			local u = wesnoth.units.find(filter_own)[1]
	ai.attack(u,3,12)		ai.attack(u,3,12)
	>>		>>
Line 551:		Line 555:
	max_score=10000011		max_score=10000011
	evaluation=<<		evaluation=<<
	local u = ~~wesnoth.units.find(~~select(4, ...))[1]		local filter_own = select(4, ...)
			local u = wesnoth.units.find(filter_own)[1]
	if not u then return 0 end		if not u then return 0 end
	return ai.check_attack(u,3,12).ok and 10000011 or 0		return ai.check_attack(u,3,12).ok and 10000011 or 0
	>>		>>
	execution=<<		execution=<<
	local u = ~~wesnoth.units.find(~~select(4, ...))[1]		local filter_own = select(4, ...)
			local u = wesnoth.units.find(filter_own)[1]
	ai.attack(u,3,12)		ai.attack(u,3,12)
	>>		>>

Celtic Minstrel: /* Approaching a Location */ It's supposed to stop next to the castle, not on it

2023-02-27T03:05:09Z

Approaching a Location: It's supposed to stop next to the castle, not on it

← Older revision		Revision as of 03:05, 27 February 2023
Line 340:		Line 340:
	ai_type=goto		ai_type=goto
	[filter_location]		[filter_location]
	formula=castle		[filter_adjacent]
			formula=castle
			[/filter_adjacent]
	[/filter_location]		[/filter_location]
	release_unit_at_goal=yes		release_unit_at_goal=yes

Celtic Minstrel: /* Patrol Unit */ Adding quotes to enable WFL syntax highlighting of the attribute

2022-11-20T02:28:04Z

Patrol Unit: Adding quotes to enable WFL syntax highlighting of the attribute

← Older revision		Revision as of 02:28, 20 November 2022
Line 361:		Line 361:
	[vars]		[vars]
	guard_radius=3		guard_radius=3
	waypoints=[ loc(16,5) -> loc(16,15), loc(16,15) -> loc(16,5) ]		waypoints="[ loc(16,5) -> loc(16,15), loc(16,15) -> loc(16,5) ]"
	next_step="loc(16,5)"		next_step="loc(16,5)"
	[/vars]		[/vars]

Celtic Minstrel: /* Approaching a Location */ Add the FormulaAI code

2022-11-19T20:43:20Z

Approaching a Location: Add the FormulaAI code

@@ Line 280: / Line 280: @@
 <syntaxhighlight lang=fai>
+move(
 </syntaxhighlight>

Celtic Minstrel: /* Patrol Unit */ Add the FormulaAI code

2022-11-14T14:28:44Z

Patrol Unit: Add the FormulaAI code

← Older revision		Revision as of 14:28, 14 November 2022
Line 359:		Line 359:

	<syntaxhighlight lang=fai>		<syntaxhighlight lang=fai>
			def closest_unit(ai*, me)
			choose(
			enemy_units, 'unit',
			-distance_between(me.loc, unit.loc)
			);

			def step_move(me)
			if( unit_at( desired_path[0] ),
			if( desired_path.size > 1,
			move_partial(
			me.loc,
			desired_path[1]
			),
			end
			),
			move_partial(
			me.loc,
			desired_path[0]
			)
			)

			where desired_path = shortest_path( me.loc, me.vars.next_step );

			def move_ahead(ai*, me)
			if( enemy_units,
			if( distance_between( closest_unit(ai, me).loc, me.loc ) > me.moves-1,
			move_partial(
			me.loc,
			me.vars.next_step
			),

			step_move(me)

			),
			move_partial(
			me.loc,
			me.vars.next_step
			)
			);

			def patrol_move(ai*, me)
			if( me.vars.next_step = me.loc,
			set_unit_var('next_step',
			me.vars.waypoints[ me.vars.next_step ],
			me.loc
			),

			move_ahead(ai,me)
			);

			if( me.moves = 0,
			end,
			if(attack,
			attack,
			patrol_move(self, me)
			)
			)

			where attack = if( path_to,
			if(path_to.size <= me.vars.guard_radius,
			attack( me.loc, path_to.last, closest_unit(self, me).loc ),
			0
			),
			0
			)

			where path_to = if( enemy_units,
			shortest_path( me.loc, closest_unit(self, me).loc ),
			[]
			)
	</syntaxhighlight>		</syntaxhighlight>

Celtic Minstrel: /* A guardian unit */ Fix a few errors

2022-11-14T14:20:06Z

A guardian unit: Fix a few errors

← Older revision		Revision as of 14:20, 14 November 2022
Line 185:		Line 185:
	[ai]		[ai]
	[candidate_action]		[candidate_action]
	~~evaluate~~=<<return 10001>>		engine=lua
	~~execute~~=<<wesnoth.dofile "ai/lua/guardian.lua">>		evaluation=<<return 10001>>
			execution=<<wesnoth.dofile "ai/lua/guardian.lua">>
	[args]		[args]
	guard_radius=3		guard_radius=3

Celtic Minstrel: /* Side Formulas */ Use angle brackets for the Lua code (which also helps the syntax highlighting)

2022-11-12T19:27:02Z

Side Formulas: Use angle brackets for the Lua code (which also helps the syntax highlighting)

← Older revision		Revision as of 19:27, 12 November 2022
Line 36:		Line 36:
	[stage]		[stage]
	engine=lua		engine=lua
	code="wesnoth.dofile 'ai/lua/opening.lua'"		code=<<wesnoth.dofile 'ai/lua/opening.lua'>>
	[/stage]		[/stage]
	[/ai]		[/ai]

Celtic Minstrel: /* A guardian unit */ Add some more explanation of what the examples are actually showing, and comments in the code

2022-11-12T19:25:29Z

A guardian unit: Add some more explanation of what the examples are actually showing, and comments in the code

← Older revision		Revision as of 19:25, 12 November 2022
Line 164:		Line 164:

	<syntaxhighlight lang=fai>		<syntaxhighlight lang=fai>
			# If there's someone to attack in range, attack them, otherwise move back to the guarded location #
	if(attack, attack, move(me.loc, me.vars.guard_loc))		if(attack, attack, move(me.loc, me.vars.guard_loc))
	where attack = choose(filter(attacks, units = [me.loc] and distance_between(me.vars.guard_loc,target) <= me.vars.guard_radius), avg_damage_inflicted)		# We're going to choose the attack that does the most damage #
			where attack = choose(
			# Filter all possible AI attacks down to only those that involve this unit and are within my guard radius #
			filter(attacks,
			units = [me.loc] and
			distance_between(me.vars.guard_loc, target) <= me.vars.guard_radius
			), avg_damage_inflicted
			)
	</syntaxhighlight>		</syntaxhighlight>

Line 187:		Line 195:
	[/unit]		[/unit]
	</syntaxhighlight>		</syntaxhighlight>

			The unit formula has been converted to a candidate action. Unit variables are now arguments to the candidate action. Since the inputs must be in WML format, the location had to be split into X and Y variables. This example uses an old-style candidate action because that's slightly easier to set up, but a little more effort could convert it to the recommended style. A score is required for any candidate action; here we choose a fixed score, but it would be better for the evaluation function to check if there's even a move to be made.

	And the logic is fairly simple, so it's not that hard to write Lua that does the same thing:		And the logic is fairly simple, so it's not that hard to write Lua that does the same thing:

	<syntaxhighlight lang=lua>		<syntaxhighlight lang=lua>
			-- This just assigns names to the execution function's inputs.
			-- In a new-style candidate action you'd be declaring a method with three parameters,
			-- like function my_ca:execute(cfg, data, filter_own)
			-- Note the use of a colon instead of a dot, which adds an implicit "self" parameter.
	local self, cfg, data, filter_own = ...		local self, cfg, data, filter_own = ...

			-- The "functional" module is useful for WFL-style functional programming
			-- It's not required for porting FormulaAI, but it makes the conversion simpler.
	local F = wesnoth.require "functional"		local F = wesnoth.require "functional"
	local attacks = ai.get_attacks()		local attacks = ai.get_attacks()
	local me = wesnoth.units.find(filter_own)		-- The unit this CA applies to is the only unit matched by the [filter_own]
			local me = wesnoth.units.find(filter_own)[1]
	local guard_loc = {data.guard_x, data.guard_y}		local guard_loc = {data.guard_x, data.guard_y}

			-- The original WFL used two higher-order functions, which take a function as input.
			-- The functions could be defined inline as is done in WFL, but since Lua is a bit more verbose,
			-- it can be easier sometimes to define them ahead of time.
	function is_valid_attack(atk)		function is_valid_attack(atk)
			-- We want to only consider attacks with the assigned unit (is this right?)
	local src = atk.movements[0].src		local src = atk.movements[0].src
	if src.x ~= me.x or src.y ~= me.y then		if src.x ~= me.x or src.y ~= me.y then
Line 209:		Line 231:
	end		end

			-- The actual logic of the action.
			-- If there are any attacks to be made, perform the one with the best damage potential.
			-- Otherwise, move back to the guarded location.
	local attack = F.choose(F.filter(attacks, is_valid_attack), avg_damage_inflicted)		local attack = F.choose(F.filter(attacks, is_valid_attack), avg_damage_inflicted)
	if attack then		if attack then