static void VerifyTagReferenceFieldDefinition(const tag_field& field,
const tag_block_definition* block_definition)
{
auto* definition = field.Definition<tag_reference_definition>();
YELO_ASSERT_DISPLAY(definition, "no definition specified for tag reference field in block %s.",
block_definition->name); // NOTE: added owner block name to info
YELO_ASSERT( VALID_FLAGS(definition->flags, Flags::k_number_of_tag_group_tag_reference_flags) );
group_tag_to_string gt_string;
gt_string.Terminate();
if(definition->group_tag != NONE)
{
gt_string.group = definition->group_tag;
YELO_ASSERT_DISPLAY( blam::tag_group_get(definition->group_tag),
"invalid group tag '%s' for tag reference field '%s' in block %s",
gt_string.TagSwap().str, field.name, block_definition->name);
YELO_ASSERT( definition->group_tags==nullptr );
TagGroupMarkAsReferenced(definition->group_tag);
}
else if(definition->group_tags != nullptr)
{
for(auto group_tag : *definition)
{
gt_string.group = group_tag;
YELO_ASSERT_DISPLAY( blam::tag_group_get(group_tag),
"invalid group tag '%s' for variable tag reference field '%s' in block %s",
gt_string.TagSwap().str, field.name, block_definition->name);
TagGroupMarkAsReferenced(group_tag);
}
}
}
static void VerifyDataFieldDefinition(const tag_field& field,
const tag_block_definition* block_definition)
{
auto* definition = field.Definition<tag_data_definition>();
YELO_ASSERT_DISPLAY(definition, "no definition specified for tag_data field in block %s.",
block_definition->name); // NOTE: added owner block name to info
YELO_ASSERT( definition->name );
YELO_ASSERT( VALID_FLAGS(definition->flags, Flags::k_number_of_tag_data_definition_flags) );
YELO_ASSERT( definition->maximum_size>0 );
}
void c_tag_fieldset_replacement_builder::NextSourceField(bool copy_current_field_first)
{
YELO_ASSERT( !CurrentSourceFieldIsTerminator() );
if(copy_current_field_first)
{
YELO_ASSERT(m_target_fields_cursor < m_target_fields_max_count);
tag_field* dst= &m_target_fields[m_target_fields_cursor++];
const tag_field* src= &m_source_fields[m_source_fields_cursor];
memcpy_s(dst, sizeof(*dst), src, sizeof(*src));
}
scanner.Scan();
++m_source_fields_cursor;
}
void VerifyGroupFieldDefinitions()
{
struct verify_group_field_definitions_action
{
bool m_found_group_missing_header_definition;
verify_group_field_definitions_action() : m_found_group_missing_header_definition(false) { }
void operator()(const tag_group* group)
{
if(group->header_block_definition != nullptr)
VerifyBlockFieldDefinitions(group->header_block_definition);
else
{ // NOTE: added this warning
YELO_WARN("tag group '%s' doesn't have a definition", group->name);
m_found_group_missing_header_definition = true;
}
}
};
auto action = verify_group_field_definitions_action();
TagGroups::tag_groups_do_action(action);
if(action.m_found_group_missing_header_definition)
{
YELO_ASSERT( !"fix your goddamn tag groups" );
}
}
bool game_time_get_paused()
{
auto game_time_globals = GameState::GameTimeGlobals();
YELO_ASSERT(game_time_globals);
return game_time_globals->paused;
}
game_time_t local_time_get_elapsed()
{
auto game_time_globals = GameState::GameTimeGlobals();
YELO_ASSERT(game_time_globals && game_time_globals->initialized);
return game_time_globals->elapsed_time;
}
game_ticks_t game_time_get()
{
auto game_time_globals = GameState::GameTimeGlobals();
YELO_ASSERT(game_time_globals && game_time_globals->initialized);
return game_time_globals->game_time;
}
void game_time_set_speed(float speed)
{
auto game_time_globals = GameState::GameTimeGlobals();
YELO_ASSERT(game_time_globals);
game_time_globals->game_speed = speed;
}
float game_time_get_speed()
{
auto game_time_globals = GameState::GameTimeGlobals();
YELO_ASSERT(game_time_globals);
return game_time_globals->game_speed;
}
void VerifyBlockFieldDefinitions(tag_block_definition* block)
{
YELO_ASSERT( block );
YELO_ASSERT( block->name );
YELO_ASSERT( VALID_FLAGS(block->flags, Flags::k_number_of_tag_block_definition_flags) );
YELO_ASSERT( block->maximum_element_count>=0 );
YELO_ASSERT( CAST(int,block->element_size)>=0 );
YELO_ASSERT( block->fields );
struct verify_tag_field_action
{ void operator()(const tag_block_definition* block, const tag_field& field) const
{
VerifyTagField(block, field);
}
};
block->FieldsDoAction<verify_tag_field_action, true>();
}
c_tag_fieldset_replacement_builder::c_tag_fieldset_replacement_builder(
const tag_field* source_fields,
tag_field* target_fields, int target_fields_size, int target_fields_count)
:
m_source_fields( source_fields ),
m_source_fields_cursor( 0 ),
m_target_fields( target_fields ),
m_target_fields_cursor( 0 ),
m_target_fields_max_count( target_fields_size ),
m_available_pad_size( NONE ),
scanner(source_fields, NULL)
{
YELO_ASSERT( source_fields != NULL );
YELO_ASSERT( target_fields != NULL && target_fields_size > 0 );
// the target fields shouldn't be initialized yet
YELO_ASSERT( target_fields_count == 0 );
scanner.AddAllFieldTypes();
}
void game_time_set_paused(bool paused)
{
auto game_time_globals = GameState::GameTimeGlobals();
YELO_ASSERT(game_time_globals);
if (game_time_globals->initialized)
{
game_time_globals->active = !paused;
}
game_time_globals->paused = paused;
}
bool game_in_progress()
{
auto game_time_globals = GameState::GameTimeGlobals();
YELO_ASSERT(game_time_globals);
if (game_time_globals->initialized)
{
return game_time_globals->active || game_time_globals->paused;
}
return false;
}
void c_animation_fixups::InitializeAnimationIndexArrayFixups()
{
importer_animation_index_array = YELO_NEW_ARRAY(int32, max_animations);
YELO_ASSERT( importer_animation_index_array );
void* IMPORTER_ANIMATION_INDEX_SET_INDICE_HOOK = CAST_PTR(void*, 0x404415);
Memory::WriteRelativeJmp(_importer_animation_index_set_indice,
IMPORTER_ANIMATION_INDEX_SET_INDICE_HOOK, true);
void* IMPORTER_ANIMATION_INDEX_SET_INDICE2_HOOK = CAST_PTR(void*, 0x404452);
Memory::WriteRelativeJmp(_importer_animation_index_set_indice2,
IMPORTER_ANIMATION_INDEX_SET_INDICE2_HOOK, true);
}
void c_animation_fixups::InitializeAnimationRemappingIndexArrayFixups()
{
importer_animation_remapping_index_array = YELO_NEW_ARRAY(int16, max_animations);
YELO_ASSERT( importer_animation_remapping_index_array );
memset(importer_animation_remapping_index_array, NONE, max_animations * sizeof(importer_animation_remapping_index_array[0]));
void* IMPORTER_ANIMATION_REMAPPING_INDEX_SET_INDICE_HOOK = CAST_PTR(void*, 0x403326);
Memory::WriteRelativeJmp(_importer_animation_remapping_index_set_indice,
IMPORTER_ANIMATION_REMAPPING_INDEX_SET_INDICE_HOOK, true);
void* IMPORTER_ANIMATION_REMAPPING_INDEX_GET_INDICE_HOOK = CAST_PTR(void*, 0x4033AF);
Memory::WriteRelativeJmp(_importer_animation_remapping_index_get_indice,
IMPORTER_ANIMATION_REMAPPING_INDEX_GET_INDICE_HOOK, true);
void* IMPORTER_ANIMATION_REMAPPING_INDEX_GET_INDICE2_HOOK = CAST_PTR(void*, 0x40349D);
Memory::WriteRelativeJmp(_importer_animation_remapping_index_get_indice2,
IMPORTER_ANIMATION_REMAPPING_INDEX_GET_INDICE2_HOOK, true);
}
void VerifyTagField(const tag_block_definition* block_definition, const tag_field& field)
{
switch(field.type)
{
case Enums::_field_string:
{
uintptr_t definition = CAST_PTR(uintptr_t, field.definition);
YELO_ASSERT( definition==0 || definition <= Enums::k_long_string_length ||
TagFieldIsOldStringId(&field) );
}
break;
case Enums::_field_enum:
VerifyEnumFieldDefinition<int16>(field, block_definition);
break;
case Enums::_field_long_flags:
VerifyFlagsFieldDefinition<long_flags>(field, block_definition);
break;
case Enums::_field_word_flags:
VerifyFlagsFieldDefinition<word_flags>(field, block_definition);
break;
case Enums::_field_byte_flags:
VerifyFlagsFieldDefinition<byte_flags>(field, block_definition);
break;
case Enums::_field_tag_reference:
VerifyTagReferenceFieldDefinition(field, block_definition);
break;
case Enums::_field_block:
{
auto* definition = field.Definition<tag_block_definition>();
YELO_ASSERT_DISPLAY(definition, "no definition specified for block field in block %s.",
block_definition->name); // NOTE: added owner block name to info
VerifyBlockFieldDefinitions(definition);
}
break;
case Enums::_field_data:
VerifyDataFieldDefinition(field, block_definition);
break;
case Enums::_field_short_block_index:
case Enums::_field_long_block_index:
{
auto* definition = field.Definition<tag_block_definition>();
YELO_ASSERT_DISPLAY(definition, "no definition specified for block index field in block %s.",
block_definition->name); // NOTE: added owner block name to info
}
break;
case Enums::_field_array_start:
case Enums::_field_pad:
case Enums::_field_skip:
YELO_ASSERT( CAST_PTR(int32,field.definition)>0 );
break;
case Enums::_field_explanation:
{
cstring definition = field.Definition<const char>();
YELO_ASSERT_DISPLAY(definition, "no definition specified for explanation field in block %s.",
block_definition->name); // NOTE: added owner block name to info
}
break;
}
}