from process_smart_modules import preprocess
def write_python_header(postfx_params_list):
file = open(src_dir + "ID_postfx_params.py","w")
for i_postfx_param in xrange(len(postfx_params_list)):
file.write("pfx_%s = %d\n"%(postfx_params_list[i_postfx_param][0],i_postfx_param))
file.write("\n\n")
file.close()
def write_postfx_params(postfx_params_list):
ofile = open(export_dir + "postfx.txt","w")
ofile.write("postfx_paramsfile version 1\n")
ofile.write("%d\n"%len(postfx_params_list))
for postfx_param in postfx_params_list:
ofile.write("pfx_%s %d %d"%(postfx_param[0], postfx_param[1],postfx_param[2]))
params_list1 = postfx_param[3]
params_list2 = postfx_param[4]
params_list3 = postfx_param[5]
ofile.write(" %f %f %f %f"%(params_list1[0], params_list1[1], params_list1[2], params_list1[3]))
ofile.write(" %f %f %f %f"%(params_list2[0], params_list2[1], params_list2[2], params_list2[3]))
ofile.write(" %f %f %f %f\n"%(params_list3[0], params_list3[1], params_list3[2], params_list3[3]))
ofile.close()
print "Exporting postfx_params..."
preprocess(postfx_params,"postfx_params")
write_postfx_params(postfx_params)
write_python_header(postfx_params)
def compile_sounds(sounds):
all_sounds = []
for sound in sounds:
sound_files = sound[2]
sound_flags = sound[1]
for i_sound_file in xrange(len(sound_files)):
sound_file = sound_files[i_sound_file]
if (type(sound_file) != type([])):
sound_file = [sound_file, 0]
sound_no = 0
found = 0
while (sound_no < (len(all_sounds))) and (not found):
if all_sounds[sound_no][0] == sound_file[0]:
found = 1
else:
sound_no += 1
if not found:
all_sounds.append((sound_file[0], sound_flags))
sound_no = len(all_sounds) - 1
sound_files[i_sound_file] = [sound_no, sound_file[1]]
return all_sounds
print "Exporting sounds..."
preprocess(sounds, "sounds")
sound_samples = compile_sounds(sounds)
write_sounds(sound_samples, sounds)
write_python_header(sounds)
ofile.write("\n%d\n" % len(hair_meshes))
for mesh_name in hair_meshes:
ofile.write(" %s " % mesh_name)
ofile.write("\n %d\n" % len(beard_meshes))
for bmn in beard_meshes:
ofile.write(" %s\n" % bmn)
ofile.write("\n")
write_textures(ofile, hair_textures)
write_textures(ofile, beard_textures)
write_face_tex(ofile, face_textures)
write_voices(ofile, voices)
ofile.write(" %s %f " % (skeleton_name, scale))
ofile.write("\n%d %d\n" % (blood_particles_1, blood_particles_2))
ofile.write("%d\n" % (len(constraints)))
for constraint in constraints:
ofile.write("\n%f %d %d " % (constraint[0], constraint[1],
(len(constraint) - 2)))
for i_pair in xrange(len(constraint)):
if i_pair > 1:
ofile.write(" %f %d" %
(constraint[i_pair][0], constraint[i_pair][1]))
ofile.write("\n")
ofile.close()
print "Exporting skins..."
preprocess(skins, "skins")
export_skins(skins)
from process_smart_modules import preprocess
def save_info_pages():
ofile = open(export_dir + "info_pages.txt", "w")
ofile.write("infopagesfile version 1\n")
ofile.write("%d\n" % (len(info_pages)))
for i_info_page in xrange(len(info_pages)):
info_page = info_pages[i_info_page]
ofile.write("ip_%s %s %s" %
(info_page[0], string.replace(info_page[1], " ", "_"),
string.replace(info_page[2], " ", "_")))
ofile.write("\n")
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_info_pages.py", "w")
for i_info_page in xrange(len(info_pages)):
ofile.write("ip_%s = %d\n" % (info_pages[i_info_page][0], i_info_page))
ofile.write("\n\n")
ofile.close()
print "Exporting info_page data..."
preprocess(info_pages, "info_pages")
save_info_pages()
save_python_header()
from module_info import *
from module_scenes import *
from process_common import *
from process_smart_modules import preprocess
def save_python_header():
ofile = open(src_dir + "ID_scenes.py","w")
for i_scene in xrange(len(scenes)):
ofile.write("scn_%s = %d\n"%(convert_to_identifier(scenes[i_scene][0]),i_scene))
ofile.close()
print "Exporting scene data..."
preprocess(scenes,"scenes")
save_python_header()
from process_operations import *
from module_troops import *
scene_name_pos = 0
passages_pos = 8
scene_outer_terrain_pos = 10
def write_vec(ofile,vec):
ofile.write(" %f %f %f "%vec)
def write_passage(ofile,scenes,passage):
ofile.write(" %d" % item_faction)
ofile.write("\n")
else:
ofile.write(" 0\n")
trigger_list = []
if (len(item) > 8):
trigger_list = item[8]
save_simple_triggers(ofile, trigger_list, variable_list, variable_uses,
tag_uses, quick_strings)
ofile.close()
print "Exporting item data..."
preprocess(items, "items")
save_python_header()
from module_info import *
from process_common import *
from process_operations import *
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
write_items(variables, variable_uses, tag_uses, quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
tag_uses, quick_strings)
file.write("\n")
file.close()
def save_python_header():
file = open(src_dir + "ID_scripts.py", "w")
for i_script in xrange(len(scripts)):
file.write("script_%s = %d\n" %
(convert_to_identifier(scripts[i_script][0]), i_script))
file.write("\n\n")
file.close()
print "Exporting scripts..."
preprocess(scripts, "scripts")
save_python_header()
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
recompileGlobalVars(variables, variable_uses, scripts_args=scripts)
save_scripts(variables, variable_uses, scripts, tag_uses, quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
save_quick_strings(export_dir, quick_strings)
from header_common import *
from module_info import *
from module_strings import *
from process_common import *
from process_smart_modules import preprocess
def save_strings(strings):
ofile = open(export_dir + "strings.txt","w")
ofile.write("stringsfile version 1\n")
ofile.write("%d\n"%len(strings))
for i_string in xrange(len(strings)):
str = strings[i_string]
ofile.write("str_%s %s\n"%(convert_to_identifier(str[0]),replace_spaces(str[1])))
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_strings.py","w")
for i_string in xrange(len(strings)):
ofile.write("str_%s = %d\n"%(convert_to_identifier(strings[i_string][0]),i_string))
ofile.write("\n\n")
ofile.close()
print "Exporting strings..."
preprocess(strings,"strings")
save_python_header()
save_strings(strings)
add_tag_use(tag_uses, tag_troop, member[0])
file.write("%d %d 0 %d " % (member[0], member[1], member[2]))
bearing = 0.0
if (len(party) > 11):
bearing = (3.1415926 / 180.0) * party[11]
file.write("\n%f\n" % (bearing))
file.close()
def save_python_header(parties):
file = open(src_dir + "ID_parties.py", "w")
for i_party in xrange(len(parties)):
file.write("p_%s = %d\n" %
(convert_to_identifier(parties[i_party][0]), i_party))
file.close()
print "Exporting parties"
preprocess(parties, "parties")
tag_uses = load_tag_uses(export_dir)
save_python_header(parties)
save_parties(parties)
save_tag_uses(export_dir, tag_uses)
#print "Generating C header..."
#save_c_header()
#print "Generating Python header..."
#print "Finished."
party_template[3], party_template[4], party_template[5]))
members = party_template[6]
if (len(members) > 6):
print "Error! NUMBER OF TEMPLATE MEMBERS EXCEEDS 6 " + party_template[
0]
members = members[0:6]
for party_template_member in members:
save_party_template_troop(file, party_template_member)
for i in xrange(6 - len(members)):
save_party_template_troop(file, 0)
file.write("\n")
file.close()
def save_python_header():
file = open(src_dir + "ID_party_templates.py", "w")
for i_party_template in xrange(len(party_templates)):
file.write("pt_%s = %d\n" % (convert_to_identifier(
party_templates[i_party_template][0]), i_party_template))
file.close()
print "Exporting party_template data..."
preprocess(party_templates, "party_templates")
#tag_uses = load_tag_uses(export_dir)
save_python_header()
save_party_templates()
#save_tag_uses(export_dir, tag_uses)
file.write("0 ")
if (len(elem) > 6):
file.write("%f %f %f " % elem[6])
else:
file.write("0.0 0.0 0.0 ")
if (len(elem) > 7):
file.write("%f \n" % (elem[7]))
else:
file.write("0.0 \n")
action_found = 1
break
if not action_found:
file.write(" none 0 0\n") #oops
def save_python_header(action_codes):
ofile = open(src_dir + "ID_animations.py", "w")
for i_anim in xrange(len(action_codes)):
ofile.write("anim_%s = %d\n" % (action_codes[i_anim], i_anim))
ofile.write("\n\n")
ofile.close()
print "Exporting animations..."
preprocess(animations, "animations")
action_codes = compile_action_sets(animations)
save_python_header(action_codes)
write_actions(animations, len(action_codes), action_codes, "actions.txt")
def save_quests():
ofile = open(export_dir + "quests.txt", "w")
ofile.write("questsfile version 1\n")
ofile.write("%d\n" % (len(quests)))
for i_quest in xrange(len(quests)):
quest = quests[i_quest]
ofile.write("qst_%s %s %d " %
(quest[0], (string.replace(quest[1], " ", "_")), quest[2]))
ofile.write("%s " % (string.replace(quest[3], " ", "_")))
ofile.write("\n")
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_quests.py", "w")
for i_quest in xrange(len(quests)):
ofile.write("qst_%s = %d\n" % (quests[i_quest][0], i_quest))
for i_quest in xrange(len(quests)):
ofile.write("qsttag_%s = %d\n" %
(quests[i_quest][0], opmask_quest_index | i_quest))
ofile.write("\n\n")
ofile.close()
print "Exporting quest data..."
preprocess(quests, "quests")
save_quests()
save_python_header()
skill_max_level_pos = 3
skill_desc_pos = 4
def save_skills():
ofile = open(export_dir + "skills.txt", "w")
ofile.write("%d\n" % (len(skills)))
for i_skill in xrange(len(skills)):
skill = skills[i_skill]
ofile.write("skl_%s %s " % (skill[0], replace_spaces(skill[1])))
ofile.write("%d %d %s\n" %
(skill[skill_attribute_pos], skill[skill_max_level_pos],
(string.replace(skill[skill_desc_pos], " ", "_"))))
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_skills.py", "w")
for i_skill in xrange(len(skills)):
ofile.write("skl_%s = %d\n" % (skills[i_skill][0], i_skill))
ofile.write("\n\n")
ofile.close()
print "Exporting skills..."
preprocess(skills, "skills")
save_python_header()
save_skills()
file.write("\n")
file.close()
def save_python_header():
file = open(src_dir + "ID_mission_templates.py", "w")
for i_mission_template in xrange(len(mission_templates)):
file.write(
"mst_%s = %d\n" %
(mission_templates[i_mission_template][0], i_mission_template))
file.close()
print "Exporting mission_template data..."
preprocess(mission_templates, "mission_templates")
save_python_header()
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
recompileGlobalVars(variables,
variable_uses,
mission_templates_args=mission_templates)
save_mission_templates(variables, variable_uses, tag_uses, quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
quick_strings):
file = open(export_dir + "simple_triggers.txt", "w")
file.write("simple_triggers_file version 1\n")
file.write("%d\n" % len(simple_triggers))
for i in xrange(len(simple_triggers)):
simple_trigger = simple_triggers[i]
file.write("%f " % (simple_trigger[0]))
save_statement_block(file, 0, 1, simple_trigger[1], variable_list,
variable_uses, tag_uses, quick_strings)
file.write("\n")
file.close()
print "exporting simple triggers..."
preprocess(simple_triggers, "simple_triggers")
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
recompileGlobalVars(variables,
variable_uses,
simple_triggers_args=simple_triggers)
save_simple_triggers(variables, variable_uses, simple_triggers, tag_uses,
quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
save_quick_strings(export_dir, quick_strings)
import string
from header_common import *
from module_info import *
from module_music import *
from process_common import *
from process_smart_modules import preprocess
def save_python_header():
ofile = open(src_dir + "ID_music.py", "w")
for i_track in xrange(len(tracks)):
ofile.write("track_%s = %d\n" % (tracks[i_track][0], i_track))
ofile.write("\n\n")
ofile.close()
def save_tracks():
file = open(export_dir + "music.txt", "w")
file.write("%d\n" % len(tracks))
for track in tracks:
file.write("%s %d %d\n" % (track[1], track[2], (track[2] | track[3])))
file.close()
print "Exporting tracks..."
preprocess(tracks, "tracks")
save_python_header()
save_tracks()
"spr_%s %d %d %s %s " %
(scene_prop[0], scene_prop[1], get_spr_hit_points(
scene_prop[1]), scene_prop[2], scene_prop[3]))
save_simple_triggers(ofile, scene_prop[4], variable_list,
variable_uses, tag_uses, quick_strings)
ofile.write("\n")
ofile.close()
def save_python_header():
file = open(src_dir + "ID_scene_props.py", "w")
for i_scene_prop in xrange(len(scene_props)):
file.write("spr_%s = %d\n" %
(scene_props[i_scene_prop][0], i_scene_prop))
file.close()
print "Exporting scene props..."
preprocess(scene_props, "scene_props")
save_python_header()
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
save_scene_props(variables, variable_uses, tag_uses, quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
save_quick_strings(export_dir, quick_strings)
file.write("\n")
ranks = []
if (len(faction) > (faction_ranks_pos)):
ranks = faction[faction_ranks_pos]
file.write("%d "%(len(ranks)))
for rank in ranks:
file.write(" %s "%(replace_spaces(rank)))
file.close()
def two_to_pow(x):
result = 1
for i in xrange(x):
result = result * 2
return result
def save_python_header():
file = open(src_dir + "ID_factions.py","w")
for i_faction in xrange(len(factions)):
file.write("fac_%s = %d\n"%(factions[i_faction][0],i_faction))
file.write("\n\n")
file.close()
print "Exporting faction data..."
preprocess(factions,"factions")
save_python_header()
relations = compile_relations()
save_factions(relations)
for menu_item in menu_items:
save_game_menu_item(ofile, variable_list, variable_uses, menu_item,
tag_uses, quick_strings)
ofile.write("\n")
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_menus.py", "w")
for i_game_menu in xrange(len(game_menus)):
ofile.write("menu_%s = %d\n" %
(game_menus[i_game_menu][0], i_game_menu))
ofile.close()
print "Exporting game menus data..."
preprocess(game_menus, "game_menus")
save_python_header()
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
recompileGlobalVars(variables, variable_uses, game_menus_args=game_menus)
save_game_menus(variables, variable_uses, tag_uses, quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
save_quick_strings(export_dir, quick_strings)
ofile.write(
"tab_%s %d %s %d %d %d %d %d %d" %
(tableau[0], tableau[1], tableau[2], tableau[3], tableau[4],
tableau[5], tableau[6], tableau[7], tableau[8]))
save_statement_block(ofile, 0, 1, tableau[9], variable_list,
variable_uses, tag_uses, quick_strings)
ofile.write("\n")
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_tableau_materials.py", "w")
for i_tableau in xrange(len(tableaus)):
ofile.write("tableau_%s = %d\n" % (tableaus[i_tableau][0], i_tableau))
ofile.close()
print "Exporting tableau materials data..."
preprocess(tableaus, "tableaus")
save_python_header()
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
save_tableau_materials(variables, variable_uses, tag_uses, quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
save_quick_strings(export_dir, quick_strings)
from process_common import *
from process_smart_modules import preprocess
def save_meshes():
ofile = open(export_dir + "meshes.txt", "w")
ofile.write("%d\n" % len(meshes))
for i_mesh in xrange(len(meshes)):
mesh = meshes[i_mesh]
ofile.write(
"mesh_%s %d %s %f %f %f %f %f %f %f %f %f\n" %
(mesh[0], mesh[1], replace_spaces(mesh[2]), mesh[3], mesh[4],
mesh[5], mesh[6], mesh[7], mesh[8], mesh[9], mesh[10], mesh[11]))
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_meshes.py", "w")
for i_mesh in xrange(len(meshes)):
ofile.write("mesh_%s = %d\n" % (meshes[i_mesh][0], i_mesh))
ofile.write("\n\n")
ofile.close()
print "Exporting meshes..."
preprocess(meshes, "meshes")
save_python_header()
save_meshes()
file.close()
def two_to_pow(x):
result = 1
for i in xrange(x):
result = result * 2
return result
def save_python_header():
file = open(src_dir + "ID_troops.py", "w")
for i_troop in xrange(len(troops)):
file.write("trp_%s = %d\n" %
(convert_to_identifier(troops[i_troop][0]), i_troop))
file.close()
print "Exporting troops data"
preprocess(troops, "troops")
#tag_uses = load_tag_uses(export_dir)
save_python_header()
save_troops()
#save_tag_uses(export_dir, tag_uses)
#print "Generating C header..."
#save_c_header()
#print "Generating Python header..."
#print "Finished."
def save_presentations(variable_list,variable_uses,tag_uses,quick_strings):
ofile = open(export_dir + "presentations.txt","w")
ofile.write("presentationsfile version 1\n")
ofile.write(" %d\n"%(len(presentations)))
for presentation in presentations:
ofile.write("prsnt_%s %d %d "%(presentation[0], presentation[1], presentation[2]))
save_simple_triggers(ofile,presentation[3], variable_list,variable_uses,tag_uses,quick_strings)
ofile.write("\n")
ofile.close()
def save_python_header():
file = open(src_dir + "ID_presentations.py","w")
for i_presentation in xrange(len(presentations)):
file.write("prsnt_%s = %d\n"%(presentations[i_presentation][0],i_presentation))
file.close()
print "Exporting presentations..."
preprocess(presentations,"presentations")
save_python_header()
variable_uses = []
variables = load_variables(export_dir,variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
save_presentations(variables,variable_uses,tag_uses,quick_strings)
save_variables(export_dir,variables,variable_uses)
save_tag_uses(export_dir,tag_uses)
save_quick_strings(export_dir,quick_strings)
(psys[emit_velocity_pos][0], psys[emit_velocity_pos][1],
psys[emit_velocity_pos][2]))
ofile.write("%f \n" % (psys[emit_rndmness_pos]))
if (len(psys) >= (angular_speed_pos + 1)):
ofile.write("%f " % (psys[angular_speed_pos]))
else:
ofile.write("0.0 ")
if (len(psys) >= (angular_damping_pos + 1)):
ofile.write("%f " % (psys[angular_damping_pos]))
else:
ofile.write("0.0 ")
ofile.write("\n")
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_particle_systems.py", "w")
for i_particle_system in xrange(len(particle_systems)):
ofile.write(
"psys_%s = %d\n" %
(particle_systems[i_particle_system][0], i_particle_system))
ofile.close()
print "Exporting particle data..."
preprocess(particle_systems, "particle_systems")
save_particle_systems()
save_python_header()
(map_icon[0], map_icon[1], map_icon[2], map_icon[3],
map_icon[4]))
if (len(map_icon) == 6):
triggers = map_icon[5]
save_simple_triggers(ofile, triggers, variable_list, variable_uses,
tag_uses, quick_strings)
ofile.write("\n")
ofile.close()
def save_python_header():
ofile = open(src_dir + "ID_map_icons.py", "w")
for i_map_icon in xrange(len(map_icons)):
ofile.write("icon_%s = %d\n" % (map_icons[i_map_icon][0], i_map_icon))
ofile.close()
print "Exporting map icons..."
preprocess(map_icons, "map_icons")
save_python_header()
variable_uses = []
variables = load_variables(export_dir, variable_uses)
tag_uses = load_tag_uses(export_dir)
quick_strings = load_quick_strings(export_dir)
save_map_icons(variables, variable_uses, tag_uses, quick_strings)
save_variables(export_dir, variables, variable_uses)
save_tag_uses(export_dir, tag_uses)
save_quick_strings(export_dir, quick_strings)
