def get_layout_action2s(spritelayout, feature, spr_pos):
"""
@param spr_pos: Position information of the sprite view.
@type spr_pos: L{Position}
"""
ground_sprite = None
building_sprites = []
actions = []
if feature not in action2.features_sprite_layout:
raise generic.ScriptError(
"Sprite layouts are not supported for feature '{}'.".format(
general.feature_name(feature)))
# Allocate registers
param_map = {}
param_registers = []
for param in spritelayout.param_list:
reg = action2var.VarAction2CallParam(param.value)
param_registers.append(reg)
param_map[param.value] = reg
param_map = (param_map, lambda name, value, pos: action2var.
VarAction2LoadCallParam(value, name))
spritelayout.register_map[feature] = param_registers
# Reduce all expressions, can't do that earlier as feature is not known
all_sprite_sets = []
layout_sprite_list = [] # Create a new structure
for layout_sprite in spritelayout.layout_sprite_list:
param_list = []
layout_sprite_list.append(
(layout_sprite.type, layout_sprite.pos, param_list))
for param in layout_sprite.param_list:
param_val = action2var.reduce_varaction2_expr(
param.value, feature, [param_map])
param_list.append((param.name, param_val))
if isinstance(param_val, expression.SpriteGroupRef):
spriteset = action2.resolve_spritegroup(param_val.name)
if not spriteset.is_spriteset():
raise generic.ScriptError(
"Expected a reference to a spriteset.", param_val.pos)
all_sprite_sets.append(spriteset)
actions.extend(
action1.add_to_action1(all_sprite_sets, feature, spritelayout.pos))
temp_registers = []
for type, pos, param_list in layout_sprite_list:
if type.value not in layout_sprite_types:
raise generic.ScriptError(
"Invalid sprite type '{}' encountered. Expected 'ground', 'building', or 'childsprite'."
.format(type.value),
type.pos,
)
sprite = Action2LayoutSprite(feature, layout_sprite_types[type.value],
pos, [param_map])
for name, value in param_list:
sprite.set_param(name, value)
temp_registers.extend(sprite.get_all_registers())
if sprite.type == Action2LayoutSpriteType.GROUND:
if ground_sprite is not None:
raise generic.ScriptError(
"Sprite layout can have no more than one ground sprite",
spritelayout.pos)
ground_sprite = sprite
else:
building_sprites.append(sprite)
if ground_sprite is None:
if len(building_sprites) == 0:
# no sprites defined at all, that's not very much.
raise generic.ScriptError(
"Sprite layout requires at least one sprite", spr_pos)
# set to 0 for no ground sprite
ground_sprite = Action2LayoutSprite(feature,
Action2LayoutSpriteType.GROUND)
ground_sprite.set_param(expression.Identifier("sprite"),
expression.ConstantNumeric(0))
action6.free_parameters.save()
act6 = action6.Action6()
advanced = any(x.is_advanced_sprite()
for x in building_sprites + [ground_sprite])
offset = 4
sprite_num = ground_sprite.get_sprite_number()
sprite_num, offset = actionD.write_action_value(sprite_num, actions, act6,
offset, 4)
if advanced:
offset += ground_sprite.get_registers_size()
for sprite in building_sprites:
sprite_num = sprite.get_sprite_number()
sprite_num, offset = actionD.write_action_value(
sprite_num, actions, act6, offset, 4)
if advanced:
offset += sprite.get_registers_size()
offset += 3 if sprite.type == Action2LayoutSpriteType.CHILD else 6
if len(act6.modifications) > 0:
actions.append(act6)
layout_action = Action2Layout(
feature,
spritelayout.name.value + " - feature {:02X}".format(feature),
spritelayout.pos,
ground_sprite,
building_sprites,
param_registers,
)
actions.append(layout_action)
if temp_registers:
varact2parser = action2var.Varaction2Parser(feature, feature)
for register_info in temp_registers:
reg, expr = register_info[1], register_info[2]
if reg is None:
continue
varact2parser.parse_expr(expr)
varact2parser.var_list.append(nmlop.STO_TMP)
varact2parser.var_list.append(reg)
varact2parser.var_list.append(nmlop.VAL2)
varact2parser.var_list_size += reg.get_size() + 2
# Only continue if we actually needed any new registers
if temp_registers and varact2parser.var_list: # lgtm[py/uninitialized-local-variable]
# Remove the last VAL2 operator
varact2parser.var_list.pop()
varact2parser.var_list_size -= 1
actions.extend(varact2parser.extra_actions)
extra_act6 = action6.Action6()
for mod in varact2parser.mods:
extra_act6.modify_bytes(mod.param, mod.size, mod.offset + 4)
if len(extra_act6.modifications) > 0:
actions.append(extra_act6)
varaction2 = action2var.Action2Var(
feature,
"{}@registers - feature {:02X}".format(spritelayout.name.value,
feature), spritelayout.pos,
0x89)
varaction2.var_list = varact2parser.var_list
ref = expression.SpriteGroupRef(spritelayout.name, [], None,
layout_action)
varaction2.ranges.append(
action2var.VarAction2Range(expression.ConstantNumeric(0),
expression.ConstantNumeric(0), ref, ""))
varaction2.default_result = ref
varaction2.default_comment = ""
# Add two references (default + range)
# Make sure that registers allocated here are not used by the spritelayout
action2.add_ref(ref, varaction2, True)
action2.add_ref(ref, varaction2, True)
spritelayout.set_action2(varaction2, feature)
actions.append(varaction2)
else:
spritelayout.set_action2(layout_action, feature)
action6.free_parameters.restore()
return actions
def parse_randomswitch(random_switch):
"""
Parse a randomswitch block into actions
@param random_switch: RandomSwitch block to parse
@type random_switch: L{RandomSwitch}
@return: List of actions
@rtype: C{list} of L{BaseAction}
"""
action_list = action2real.create_spriteset_actions(random_switch)
feature = next(iter(random_switch.feature_set))
type_byte, count, count_expr, start_bit, bits_available = parse_randomswitch_type(random_switch)
total_prob = sum([choice.probability.value for choice in random_switch.choices])
assert total_prob > 0
nrand = 1
while nrand < total_prob: nrand <<= 1
# Verify that enough random data is available
if min(1 << bits_available, 0x80) < nrand:
msg = "The maximum sum of all random_switch probabilities is {:d}, encountered {:d}."
msg = msg.format(min(1 << bits_available, 0x80), total_prob)
raise generic.ScriptError(msg, random_switch.pos)
randbit, nrand = parse_randomswitch_dependencies(random_switch, start_bit, bits_available, nrand)
random_action2 = Action2Random(feature, random_switch.name.value, random_switch.pos, type_byte, count, random_switch.triggers.value, randbit, nrand)
random_switch.random_act2 = random_action2
action6.free_parameters.save()
act6 = action6.Action6()
offset = 8 if count is not None else 7
#divide the 'extra' probabilities in an even manner
i = 0
resulting_prob = dict((c, c.probability.value) for c in random_switch.choices)
while i < (nrand - total_prob):
best_choice = None
best_ratio = 0
for choice in random_switch.choices:
#float division, so 9 / 10 = 0.9
ratio = choice.probability.value / float(resulting_prob[choice] + 1)
if ratio > best_ratio:
best_ratio = ratio
best_choice = choice
assert best_choice is not None
resulting_prob[best_choice] += 1
i += 1
for choice in random_switch.choices:
res_prob = resulting_prob[choice]
result, comment = action2var.parse_result(choice.result.value, action_list, act6, offset, random_action2, None, 0x89, res_prob)
offset += res_prob * 2
comment = "({:d}/{:d}) -> ({:d}/{:d}): ".format(choice.probability.value, total_prob, res_prob, nrand) + comment
random_action2.choices.append(RandomAction2Choice(result, res_prob, comment))
if len(act6.modifications) > 0: action_list.append(act6)
action_list.append(random_action2)
if count_expr is None:
random_switch.set_action2(random_action2, feature)
else:
# Create intermediate varaction2
varaction2 = action2var.Action2Var(feature, '{}@registers'.format(random_switch.name.value), random_switch.pos, 0x89)
varact2parser = action2var.Varaction2Parser(feature)
varact2parser.parse_expr(count_expr)
varaction2.var_list = varact2parser.var_list
action_list.extend(varact2parser.extra_actions)
extra_act6 = action6.Action6()
for mod in varact2parser.mods:
extra_act6.modify_bytes(mod.param, mod.size, mod.offset + 4)
if len(extra_act6.modifications) > 0: action_list.append(extra_act6)
ref = expression.SpriteGroupRef(random_switch.name, [], None, random_action2)
varaction2.ranges.append(action2var.VarAction2Range(expression.ConstantNumeric(0), expression.ConstantNumeric(0), ref, ''))
varaction2.default_result = ref
varaction2.default_comment = ''
# Add two references (default + range)
action2.add_ref(ref, varaction2)
action2.add_ref(ref, varaction2)
random_switch.set_action2(varaction2, feature)
action_list.append(varaction2)
action6.free_parameters.restore()
return action_list
def create_intermediate_varaction2(feature, varact2parser, mapping, default,
pos):
"""
Create a varaction2 based on a parsed expression and a value mapping
@param feature: Feature of the varaction2
@type feature: C{int}
@param varact2parser: Parser containing a parsed expression
@type varact2parser: L{Varaction2Parser}
@param mapping: Mapping of various values to sprite groups / return values,
with a possible extra function to apply to the return value
@type mapping: C{dict} that maps C{int} to C{tuple} of (L{SpriteGroupRef}, C{function}, or C{None})
@param default: Default sprite group if no value matches
@type default: L{SpriteGroupRef}
@param pos: Positional context.
@type pos: L{Position}
@return: A tuple containing the action list and a reference to the created action2
@rtype: C{tuple} of (C{list} of L{BaseAction}, L{SpriteGroupRef})
"""
global action2_id
action_list = varact2parser.extra_actions
act6 = action6.Action6()
for mod in varact2parser.mods:
act6.modify_bytes(mod.param, mod.size, mod.offset + 4)
name = expression.Identifier("@action3_{:d}".format(action2_id))
action2_id += 1
varaction2 = action2var.Action2Var(feature, name.value, pos, 0x89)
varaction2.var_list = varact2parser.var_list
offset = 5 + varact2parser.var_list_size
for proc in varact2parser.proc_call_list:
action2.add_ref(proc, varaction2, True)
for switch_value in sorted(mapping):
return_value, ret_value_function = mapping[switch_value]
if ret_value_function is None:
result, comment = action2var.parse_result(return_value,
action_list, act6,
offset, varaction2, None,
0x89)
else:
if isinstance(return_value, expression.SpriteGroupRef):
# We need to execute the callback via a procedure call
# then return CB_FAILED if the CB failed,
# or the CB result (with ret_value_function applied) if successful
if return_value.name.value == "CB_FAILED":
result, comment = action2var.parse_result(
return_value, action_list, act6, offset, varaction2,
None, 0x89)
else:
extra_actions, result, comment = create_proc_call_varaction2(
feature, return_value, ret_value_function, varaction2,
pos)
action_list.extend(extra_actions)
else:
return_value = ret_value_function(return_value).reduce()
result, comment = action2var.parse_result(
return_value, action_list, act6, offset, varaction2, None,
0x89)
varaction2.ranges.append(
action2var.VarAction2Range(
expression.ConstantNumeric(switch_value),
expression.ConstantNumeric(switch_value), result, comment))
offset += 10
result, comment = action2var.parse_result(default, action_list, act6,
offset, varaction2, None, 0x89)
varaction2.default_result = result
varaction2.default_comment = comment
return_ref = expression.SpriteGroupRef(name, [], None, varaction2)
if len(act6.modifications) > 0:
action_list.append(act6)
action_list.append(varaction2)
return (action_list, return_ref)