// weapon list changed
void player_start_editor::OnSelchangeWeaponList()
{
int selected;
int wi_index;
char weapon_name[255] = "";
char weapon_usage_buff[10];
// If the weapon list is selected the variable weapon list shouldn't be
m_weapon_variable_list.SetCurSel(-1);
// determine if we've selected something
selected = m_weapon_list.GetCurSel();
if (selected != -1) {
// lookup the weapon
m_weapon_list.GetText(selected, weapon_name);
wi_index = weapon_info_lookup(weapon_name);
// if we have a valid ship type
if(wi_index >= 0){
// if this item is checked
if(m_weapon_list.GetCheck(selected)) {
if (static_weapon_variable_pool[selected_team][wi_index] == -1) {
if (static_weapon_pool[selected_team][wi_index] <= 0){
static_weapon_pool[selected_team][wi_index] = 100;
}
m_weapon_pool = static_weapon_pool[selected_team][wi_index];
// Set the combo reflect that we are not using variables for this weapon
m_weapon_quantity_variable.SetCurSel(0);
}
// If the number of ships was set by a variable
else {
Assert (Sexp_variables[static_weapon_variable_pool[selected_team][wi_index]].type & SEXP_VARIABLE_NUMBER);
m_weapon_pool = atoi(Sexp_variables[static_weapon_variable_pool[selected_team][wi_index]].text);
int selected_variable = sexp_variable_typed_count(static_weapon_variable_pool[selected_team][wi_index], SEXP_VARIABLE_NUMBER);
m_weapon_quantity_variable.SetCurSel(selected_variable + 1);
}
}
// otherwise zero the count
else {
static_weapon_pool[selected_team][wi_index] = 0;
static_weapon_variable_pool[selected_team][wi_index] = -1;
m_weapon_pool = 0;
m_weapon_quantity_variable.SetCurSel(0);
}
// set the number used in wings
sprintf(weapon_usage_buff, "%d", weapon_usage[selected_team][wi_index]);
m_weapons_used_in_wings.SetWindowText(weapon_usage_buff);
} else {
Int3();
}
}
// update stuff
UpdateData(FALSE);
}
// Returns the weapon_info index of the selected and checked ship_list item or -1 if nothing is checked or
// the weapon is invalid
int player_start_editor::GetSelectedWeaponListIndex()
{
char name[255] = "";
int selected = m_weapon_list.GetCurSel();
if((selected != -1) && m_weapon_list.GetCheck(selected))
{
// lookup the weapon
m_weapon_list.GetText(m_weapon_list.GetCurSel(), name);
int weapon_index = weapon_info_lookup(name);
return weapon_index;
}
return -1;
}
// weapon pool count change
void player_start_editor::OnUpdateWeaponPool()
{
int selected, wi_index;
char weapon_name[255] = "";
if (!dlg_inited){
return;
}
UpdateData(TRUE);
// if we have a ship selected and checked, update the pool
selected = m_weapon_list.GetCurSel();
if((selected != -1) && m_weapon_list.GetCheck(selected)){
// lookup the ship
m_weapon_list.GetText(m_weapon_list.GetCurSel(), weapon_name);
wi_index = weapon_info_lookup(weapon_name);
// if we have a valid ship type
if(wi_index >= 0){
weapon_pool[selected_team][wi_index] = m_weapon_pool;
}
};
}
void pilotfile::csg_read_info()
{
char t_string[NAME_LENGTH+1] = { '\0' };
index_list_t ilist;
int idx, list_size = 0;
ubyte allowed = 0;
if ( !m_have_flags ) {
throw "Info before Flags!";
}
//
// NOTE: lists may contain missing/invalid entries for current data
// this is not necessarily fatal
//
// ship list (NOTE: may contain more than MAX_SHIP_CLASSES)
list_size = cfread_int(cfp);
for (idx = 0; idx < list_size; idx++) {
cfread_string_len(t_string, NAME_LENGTH, cfp);
ilist.name = t_string;
ilist.index = ship_info_lookup(t_string);
ship_list.push_back(ilist);
}
// weapon list (NOTE: may contain more than MAX_WEAPON_TYPES)
list_size = cfread_int(cfp);
for (idx = 0; idx < list_size; idx++) {
cfread_string_len(t_string, NAME_LENGTH, cfp);
ilist.name = t_string;
ilist.index = weapon_info_lookup(t_string);
weapon_list.push_back(ilist);
}
// intel list (NOTE: may contain more than MAX_INTEL_ENTRIES)
list_size = cfread_int(cfp);
for (idx = 0; idx < list_size; idx++) {
cfread_string_len(t_string, NAME_LENGTH, cfp);
ilist.name = t_string;
ilist.index = intel_info_lookup(t_string);
intel_list.push_back(ilist);
}
// medals list (NOTE: may contain more than Num_medals)
list_size = cfread_int(cfp);
for (idx = 0; idx < list_size; idx++) {
cfread_string_len(t_string, NAME_LENGTH, cfp);
ilist.name = t_string;
ilist.index = medals_info_lookup(t_string);
medals_list.push_back(ilist);
}
// last ship flown (index into ship_list)
idx = cfread_int(cfp);
// check the idx is within bounds
Assertion ((idx < (int)ship_list.size()), "Campaign file contains an incorrect value for the last flown ship class. No data in ship_list for ship number %d.", idx);
if (idx >= (int)ship_list.size())
idx = -1;
else if (idx != -1)
p->last_ship_flown_si_index = ship_list[idx].index;
else
p->last_ship_flown_si_index = -1;
// progression state
Campaign.prev_mission = cfread_int(cfp);
Campaign.next_mission = cfread_int(cfp);
// loop state
Campaign.loop_reentry = cfread_int(cfp);
Campaign.loop_enabled = cfread_int(cfp);
// missions completed
Campaign.num_missions_completed = cfread_int(cfp);
// allowed ships
list_size = (int)ship_list.size();
for (idx = 0; idx < list_size; idx++) {
allowed = cfread_ubyte(cfp);
if (allowed) {
if (ship_list[idx].index >= 0) {
Campaign.ships_allowed[ship_list[idx].index] = 1;
} else {
m_data_invalid = true;
}
}
}
// allowed weapons
list_size = (int)weapon_list.size();
for (idx = 0; idx < list_size; idx++) {
allowed = cfread_ubyte(cfp);
if (allowed) {
if (weapon_list[idx].index >= 0) {
Campaign.weapons_allowed[weapon_list[idx].index] = 1;
} else {
m_data_invalid = true;
}
}
}
if (csg_ver >= 2) {
// single/campaign squad name & image
cfread_string_len(p->s_squad_name, NAME_LENGTH, cfp);
cfread_string_len(p->s_squad_filename, MAX_FILENAME_LEN, cfp);
}
// if anything we need/use was missing then it should be considered fatal
if (m_data_invalid) {
throw "Invalid data for CSG!";
}
}
void parse_ssm(const char *filename)
{
char weapon_name[NAME_LENGTH];
try
{
read_file_text(filename, CF_TYPE_TABLES);
reset_parse();
// parse the table
while(required_string_either("#end", "$SSM:")) {
required_string("$SSM:");
ssm_info s;
int string_index;
// name
stuff_string(s.name, F_NAME, NAME_LENGTH);
if (*s.name == 0) {
sprintf(s.name, "SSM " SIZE_T_ARG, Ssm_info.size());
mprintf(("Found an SSM entry without a name. Assigning \"%s\".\n", s.name));
}
// stuff data
required_string("+Weapon:");
stuff_string(weapon_name, F_NAME, NAME_LENGTH);
string_index = optional_string_either("+Count:", "+Min Count:");
if (string_index == 0) {
stuff_int(&s.count);
s.max_count = -1;
} else if (string_index == 1) {
stuff_int(&s.count);
required_string("+Max Count:");
stuff_int(&s.max_count);
} else {
s.count = 1;
s.max_count = -1;
}
required_string("+WarpRadius:");
stuff_float(&s.warp_radius);
if (optional_string("+WarpTime:")) {
stuff_float(&s.warp_time);
// According to fireballs.cpp, "Warp lifetime must be at least 4 seconds!"
if ( (s.warp_time) < 4.0f) {
// So let's warn them before they try to use it, shall we?
Warning(LOCATION, "Expected a '+WarpTime:' value equal or greater than 4.0, found '%f' in weapon '%s'.\n Setting to 4.0, please check and set to a number 4.0 or greater!\n", s.warp_time, weapon_name);
// And then make the Assert obsolete -- Zacam
s.warp_time = 4.0f;
}
} else {
s.warp_time = 4.0f;
}
string_index = required_string_either("+Radius:", "+Min Radius:");
if (string_index == 0) {
required_string("+Radius:");
stuff_float(&s.radius);
s.max_radius = -1.0f;
} else {
required_string("+Min Radius:");
stuff_float(&s.radius);
required_string("+Max Radius:");
stuff_float(&s.max_radius);
}
string_index = optional_string_either("+Offset:", "+Min Offset:");
if (string_index == 0) {
stuff_float(&s.offset);
s.max_offset = -1.0f;
} else if (string_index == 1) {
stuff_float(&s.offset);
required_string("+Max Offset:");
stuff_float(&s.max_offset);
} else {
s.offset = 0.0f;
s.max_offset = -1.0f;
}
if (optional_string("+Shape:")) {
switch(required_string_one_of(3, "Point", "Circle", "Sphere")) {
case 0:
required_string("Point");
s.shape = SSM_SHAPE_POINT;
break;
case 1:
required_string("Circle");
case -1: // If we're ignoring parse errors and can't identify the shape, go with a circle.
s.shape = SSM_SHAPE_CIRCLE;
break;
case 2:
required_string("Sphere");
s.shape = SSM_SHAPE_SPHERE;
break;
default:
Assertion(false, "Impossible return value from required_string_one_of(); get a coder!\n");
}
} else {
s.shape = SSM_SHAPE_CIRCLE;
}
if (optional_string("+HUD Message:"))
stuff_boolean(&s.send_message);
else
s.send_message = true;
if (optional_string("+Custom Message:")) {
stuff_string(s.message, F_NAME, NAME_LENGTH);
s.use_custom_message = true;
}
s.sound_index = -1;
parse_sound("+Alarm Sound:", &s.sound_index, s.name);
// see if we have a valid weapon
s.weapon_info_index = weapon_info_lookup(weapon_name);
if(s.weapon_info_index >= 0) {
// valid
int existing = ssm_info_lookup(s.name);
if (existing >= 0) { // Redefined the existing entry instead of adding a duplicate.
Ssm_info[existing] = s;
} else {
Ssm_info.push_back(s);
}
}
}
}
catch (const parse::ParseException& e)
{
mprintf(("TABLES: Unable to parse '%s'! Error message = %s.\n", filename, e.what()));
return;
}
}
// ok
void player_start_editor::OnOK()
{
int i, idx;
int num_choices;
int num_sexp_variables = sexp_variable_count();
// store player entry time delay
Entry_delay_time = i2f(m_delay);
// store ship pools
for(i=0; i<MAX_TVT_TEAMS; i++) {
num_choices = 0;
// First look through the variables list and write out anything there
for (idx=0; idx < num_sexp_variables; idx++) {
// As soon as we come across a sexp_variable we are using
if (dynamic_ship_pool[i][idx] != -1) {
Assert (Sexp_variables[idx].type & SEXP_VARIABLE_STRING);
int ship_class = ship_info_lookup(Sexp_variables[idx].text);
// If the variable doesn't actually contain a valid ship class name. Warn the user and skip to the next one
if (ship_class < 0) {
char buffer[256];
sprintf(buffer,
"Sexp Variable %s holds the value %s. This is not a valid ship class. Skipping this entry",
Sexp_variables[idx].variable_name,
Sexp_variables[idx].text
);
MessageBox(buffer);
continue;
}
/* Can we can prevent the user from having to enter all his variables again just cause he can't spull gud?
// If the variable doesn't actually contain a valid ship class name. Warn the user
if (ship_class < 0)
{
char buffer[256];
sprintf(buffer,
"Sexp Variable %s holds the value %s. This is not a valid ship class. You should change this!",
Sexp_variables[idx].variable_name,
Sexp_variables[idx].text
);
MessageBox(buffer);
ship_class = ship_info_lookup(default_player_ship);
if (ship_class < 0 ) {
sprintf(buffer, "No default ship is set either. Skipping variable %s!", Sexp_variables[idx].variable_name);
}
}*/
// Copy the variable to Team_data
Team_data[i].ship_list_variables[num_choices] = idx;
Team_data[i].ship_list[num_choices] = -1;
// Now we need to set the number of this type available
if (dynamic_ship_variable_pool[i][idx] == -1) {
Team_data[i].ship_count[num_choices] = dynamic_ship_pool[i][idx];
Team_data[i].ship_count_variables[num_choices] = -1;
}
else {
Assert (Sexp_variables[dynamic_ship_variable_pool[i][idx]].type & SEXP_VARIABLE_NUMBER);
Team_data[i].ship_count_variables[num_choices] = dynamic_ship_variable_pool[i][idx];
Team_data[i].ship_count[num_choices] = atoi(Sexp_variables[dynamic_ship_variable_pool[i][idx]].text);
}
num_choices++;
}
}
// Now we deal with the loadout ships that are statically assigned by class
for(idx=0; idx<Num_ship_classes; idx++) {
// if we have ships here
if(static_ship_pool[i][idx] > 0 || static_ship_variable_pool[i][idx] > -1) {
Team_data[i].ship_list[num_choices] = idx;
Team_data[i].ship_list_variables[num_choices] = -1;
// Now set the number of this class available
if (static_ship_variable_pool[i][idx] == -1) {
Team_data[i].ship_count[num_choices] = static_ship_pool[i][idx];
Team_data[i].ship_count_variables[num_choices] = -1;
}
else {
Assert (Sexp_variables[static_ship_variable_pool[i][idx]].type & SEXP_VARIABLE_NUMBER);
Team_data[i].ship_count_variables[num_choices] = static_ship_variable_pool[i][idx];
Team_data[i].ship_count[num_choices] = atoi(Sexp_variables[static_ship_variable_pool[i][idx]].text);
}
num_choices++;
}
}
Team_data[i].num_ship_choices = num_choices;
}
// store weapon pools
for(i=0; i<MAX_TVT_TEAMS; i++){
num_choices = 0;
// First look through the variables list and write out anything there
for (idx=0; idx < num_sexp_variables; idx++) {
// As soon as we come across a sexp_variable we are using
if (dynamic_weapon_pool[i][idx] != -1) {
Assert (Sexp_variables[idx].type & SEXP_VARIABLE_STRING);
int weapon_class = weapon_info_lookup(Sexp_variables[idx].text);
// If the variable doesn't actually contain a valid ship class name. Warn the user and skip to the next one
if (weapon_class < 0)
{
char buffer[256];
sprintf(buffer,
"Sexp Variable %s holds the value %s. This is not a valid weapon class. Skipping this entry",
Sexp_variables[idx].variable_name,
Sexp_variables[idx].text
);
MessageBox(buffer);
continue;
}
// Copy the variable to Team_data
Team_data[i].weaponry_pool_variable[num_choices] = idx;
Team_data[i].weaponry_pool[num_choices] = -1;
// Now we need to set the number of this class available
if (dynamic_weapon_variable_pool[i][idx] == -1)
{
Team_data[i].weaponry_count[num_choices] = dynamic_weapon_pool[i][idx];
Team_data[i].weaponry_amount_variable[num_choices] = -1;
}
else
{
Assert (Sexp_variables[dynamic_weapon_variable_pool[i][idx]].type & SEXP_VARIABLE_NUMBER);
Team_data[i].weaponry_amount_variable[num_choices] = dynamic_weapon_variable_pool[i][idx];
Team_data[i].weaponry_count[num_choices] = atoi(Sexp_variables[dynamic_weapon_variable_pool[i][idx]].text);
}
num_choices++;
}
}
// Now we deal with the loadout weapons that are statically assigned by class
for(idx=0; idx<Num_weapon_types; idx++)
{
// if we have weapons here
if(static_weapon_pool[i][idx] > 0 || static_weapon_variable_pool[i][idx] > -1)
{
Team_data[i].weaponry_pool[num_choices] = idx;
Team_data[i].weaponry_pool_variable[num_choices] = -1;
// Now set the number of this class available
if (static_weapon_variable_pool[i][idx] == -1)
{
Team_data[i].weaponry_count[num_choices] = static_weapon_pool[i][idx];
Team_data[i].weaponry_amount_variable[num_choices] = -1;
}
else
{
Assert (Sexp_variables[static_weapon_variable_pool[i][idx]].type & SEXP_VARIABLE_NUMBER);
Team_data[i].weaponry_amount_variable[num_choices] = static_weapon_variable_pool[i][idx];
Team_data[i].weaponry_count[num_choices] = atoi(Sexp_variables[static_weapon_variable_pool[i][idx]].text);
}
num_choices++;
}
}
Team_data[i].num_weapon_choices = num_choices;
}
theApp.record_window_data(&Player_wnd_data, this);
CDialog::OnOK();
}
void pilotfile_convert::csg_import_ships_weapons()
{
index_list_t ilist;
char name[35];
int idx;
int list_size = 0;
int ship_count = cfread_int(cfp);
int weap_count = cfread_int(cfp);
for (idx = 0; idx < ship_count; idx++) {
ubyte allowed = cfread_ubyte(cfp);
csg->ships_allowed.push_back( (allowed != 0) );
cfread_string_len(name, sizeof(name), cfp);
ilist.name = name;
ilist.index = ship_info_lookup(name);
if (ilist.index < 0) {
std::ostringstream error_msg;
error_msg << "Data mismatch (ship lookup: " << ilist.name << ")!";
throw std::runtime_error(error_msg.str().c_str());
}
csg->ship_list.push_back( ilist );
}
for (idx = 0; idx < weap_count; idx++) {
ubyte allowed = cfread_ubyte(cfp);
csg->weapons_allowed.push_back( allowed != 0 );
cfread_string_len(name, sizeof(name), cfp);
ilist.name = name;
ilist.index = weapon_info_lookup(name);
if (ilist.index < 0) {
std::ostringstream error_msg;
error_msg << "Data mismatch (weapon lookup: " << ilist.name << ")!";
throw std::runtime_error(error_msg.str().c_str());
}
csg->weapon_list.push_back( ilist );
}
// get last ship flown index
for (idx = 0; idx < ship_count; idx++) {
if ( csg->ship_list[idx].name == plr->last_ship_flown ) {
csg->last_ship_flown_index = idx;
break;
}
}
if (csg->last_ship_flown_index < 0) {
std::ostringstream error_msg;
error_msg << "Data mismatch (player ship: " << csg->last_ship_flown_index << ")!";
throw std::runtime_error(error_msg.str().c_str());
}
// create list of medals (since it's missing from the old files)
list_size = Num_medals;
for (idx = 0; idx < list_size; idx++) {
ilist.name = Medals[idx].name;
ilist.index = idx;
csg->medals_list.push_back( ilist );
}
// stuff intel list as well (present but burried in old files)
list_size = Intel_info_size;
for (idx = 0; idx < list_size; idx++) {
ilist.name = Intel_info[idx].name;
ilist.index = idx;
csg->intel_list.push_back( ilist );
}
}
// game init
void ssm_init()
{
int rval;
ssm_info bogus, *s;
char weapon_name[NAME_LENGTH];
if ((rval = setjmp(parse_abort)) != 0) {
mprintf(("TABLES: Unable to parse '%s'! Error code = %i.\n", "ssm.tbl", rval));
return;
}
read_file_text("ssm.tbl", CF_TYPE_TABLES);
reset_parse();
// parse the table
Ssm_info_count = 0;
while(!optional_string("#end")){
// another ssm definition
if(optional_string("$SSM:")){
// pointer to info struct
if(Ssm_info_count >= MAX_SSM_TYPES){
s = &bogus;
} else {
s = &Ssm_info[Ssm_info_count];
}
// name
stuff_string(s->name, F_NAME, NAME_LENGTH);
// stuff data
required_string("+Weapon:");
stuff_string(weapon_name, F_NAME, NAME_LENGTH);
required_string("+Count:");
stuff_int(&s->count);
required_string("+WarpRadius:");
stuff_float(&s->warp_radius);
required_string("+WarpTime:");
stuff_float(&s->warp_time);
// According to fireballs.cpp, "Warp lifetime must be at least 4 seconds!"
if ( (s->warp_time) < 4.0f) {
// So let's warn them before they try to use it, shall we?
Warning(LOCATION, "Expected a '+WarpTime:' value equal or greater than 4.0, found '%f' in weapon '%s'.\n Setting to 4.0, please check and set to a number 4.0 or greater!\n", s->warp_time, weapon_name);
// And then make the Assert obsolete -- Zacam
s->warp_time = 4.0f;
}
required_string("+Radius:");
stuff_float(&s->radius);
required_string("+Offset:");
stuff_float(&s->offset);
if (optional_string("+HUD Message:"))
stuff_boolean(&s->send_message);
else
s->send_message = true;
if (optional_string("+Custom Message:")) {
stuff_string(s->message, F_NAME, NAME_LENGTH);
s->use_custom_message = true;
}
// see if we have a valid weapon
s->weapon_info_index = -1;
s->weapon_info_index = weapon_info_lookup(weapon_name);
if(s->weapon_info_index >= 0){
// valid
Ssm_info_count++;
}
}
}
}
