src/fred2/shipflagsdlg.cpp

   1 // ShipFlagsDlg.cpp : implementation file
   2 //
   3
   4 #include "stdafx.h"
   5 #include "fred.h"
   6 #include "shipflagsdlg.h"
   7 #include "linklist.h"
   8
   9 #ifdef _DEBUG
  10 #define new DEBUG_NEW
  11 #undef THIS_FILE
  12 static char THIS_FILE[] = __FILE__;
  13 #endif
  14
  15 /////////////////////////////////////////////////////////////////////////////
  16 // ship_flags_dlg dialog
  17
  18 ship_flags_dlg::ship_flags_dlg(CWnd* pParent /*=NULL*/)
  19         : CDialog(ship_flags_dlg::IDD, pParent)
  20 {
  21         //{{AFX_DATA_INIT(ship_flags_dlg)
  22         //}}AFX_DATA_INIT
  23 }
  24
  25 void ship_flags_dlg::DoDataExchange(CDataExchange* pDX)
  26 {
  27         int n;
  28         CString str;
  29
  30         CDialog::DoDataExchange(pDX);
  31         //{{AFX_DATA_MAP(ship_flags_dlg)
  32         DDX_Control(pDX, IDC_REDALERTCARRY, m_red_alert_carry);
  33         DDX_Control(pDX, IDC_SCANNABLE, m_scannable);
  34         DDX_Control(pDX, IDC_REINFORCEMENT, m_reinforcement);
  35         DDX_Control(pDX, IDC_PROTECT_SHIP, m_protect_ship);
  36         DDX_Control(pDX, IDC_BEAM_PROTECT_SHIP, m_beam_protect_ship);
  37         DDX_Control(pDX, IDC_NO_DYNAMIC, m_no_dynamic);
  38         DDX_Control(pDX, IDC_NO_ARRIVAL_MUSIC, m_no_arrival_music);
  39         DDX_Control(pDX, IDC_KAMIKAZE, m_kamikaze);
  40         DDX_Control(pDX, IDC_INVULNERABLE, m_invulnerable);
  41         DDX_Control(pDX, IDC_IGNORE_COUNT, m_ignore_count);
  42         DDX_Control(pDX, IDC_HIDDEN_FROM_SENSORS, m_hidden);
  43         DDX_Control(pDX, IDC_ESCORT, m_escort);
  44         DDX_Control(pDX, IDC_DESTROY_CHECK, m_destroy);
  45         DDX_Control(pDX, IDC_CARGO_KNOWN, m_cargo_known);
  46         DDX_Control(pDX, IDC_DESTROY_SPIN, m_destroy_spin);
  47         DDX_Control(pDX, IDC_SPECIAL_WARP, m_special_warp);
  48         //}}AFX_DATA_MAP
  49
  50         if (pDX->m_bSaveAndValidate) {  // get dialog control values
  51                 GetDlgItem(IDC_DESTROY_VALUE)->GetWindowText(str);
  52                 n = atoi(str);
  53                 if (n < 0)
  54                         n = 0;
  55
  56                 m_destroy_value.init(n);
  57
  58                 GetDlgItem(IDC_KDAMAGE)->GetWindowText(str);
  59                 m_kdamage.init(atoi(str));
  60
  61                 //  get escort priority
  62                 GetDlgItem(IDC_ESCORT_PRIORITY)->GetWindowText(str);
  63                 m_escort_value.init(atoi(str));
  64
  65                 // get respawn priority
  66                 if(The_mission.game_type & MISSION_TYPE_MULTI){
  67                         GetDlgItem(IDC_RESPAWN_PRIORITY)->GetWindowText(str);
  68                         m_respawn_priority.init(atoi(str));
  69                 }
  70         }
  71 }
  72
  73 BEGIN_MESSAGE_MAP(ship_flags_dlg, CDialog)
  74         //{{AFX_MSG_MAP(ship_flags_dlg)
  75         ON_BN_CLICKED(IDC_CARGO_KNOWN, OnCargoKnown)
  76         ON_BN_CLICKED(IDC_DESTROY_CHECK, OnDestroyCheck)
  77         ON_BN_CLICKED(IDC_ESCORT, OnEscort)
  78         ON_BN_CLICKED(IDC_HIDDEN_FROM_SENSORS, OnHiddenFromSensors)
  79         ON_BN_CLICKED(IDC_IGNORE_COUNT, OnIgnoreCount)
  80         ON_BN_CLICKED(IDC_INVULNERABLE, OnInvulnerable)
  81         ON_BN_CLICKED(IDC_KAMIKAZE, OnKamikaze)
  82         ON_BN_CLICKED(IDC_NO_ARRIVAL_MUSIC, OnNoArrivalMusic)
  83         ON_BN_CLICKED(IDC_NO_DYNAMIC, OnNoDynamic)
  84         ON_BN_CLICKED(IDC_PROTECT_SHIP, OnProtectShip)
  85         ON_BN_CLICKED(IDC_BEAM_PROTECT_SHIP, OnBeamProtectShip)
  86         ON_BN_CLICKED(IDC_REINFORCEMENT, OnReinforcement)
  87         ON_BN_CLICKED(IDC_SCANNABLE, OnScannable)
  88         ON_BN_CLICKED(IDC_REDALERTCARRY, OnRedalertcarry)
  89         //}}AFX_MSG_MAP
  90 END_MESSAGE_MAP()
  91
  92 /////////////////////////////////////////////////////////////////////////////
  93 // ship_flags_dlg message handlers
  94
  95 void ship_flags_dlg::setup(int n)
  96 {
  97         p_enable = n;
  98 }
  99
 100 BOOL ship_flags_dlg::OnInitDialog()
 101 {
 102         int i, j, first;
 103         int protect_ship = 0, beam_protect_ship = 0, ignore_count = 0, reinforcement = 0, cargo_known = 0, destroy_before_mission = 0;
 104         int no_arrival_music = 0, escort = 0, invulnerable = 0, hidden_from_sensors = 0;
 105         int scannable = 0, kamikaze = 0, no_dynamic = 0, red_alert_carry = 0, special_warp = 0;
 106         object *objp;
 107         bool ship_in_wing = false;
 108
 109         first = 1;
 110         objp = GET_FIRST(&obj_used_list);
 111         while (objp != END_OF_LIST(&obj_used_list)) {
 112                 if ((objp->type == OBJ_START) || (objp->type == OBJ_SHIP)) {
 113                         if (objp->flags & OF_MARKED) {
 114                                 i = objp->instance;
 115                                 if (first) {
 116                                         first = 0;
 117                                         scannable = (Ships[i].flags & SF_SCANNABLE) ? 1 : 0;
 118                                         red_alert_carry = (Ships[i].flags & SF_RED_ALERT_STORE_STATUS) ? 1 : 0;
 119                                         special_warp = (Objects[Ships[i].objnum].flags & OF_SPECIAL_WARP) ? 1 : 0;
 120                                         protect_ship = (Objects[Ships[i].objnum].flags & OF_PROTECTED) ? 1 : 0;
 121                                         beam_protect_ship = (Objects[Ships[i].objnum].flags & OF_BEAM_PROTECTED) ? 1 : 0;
 122                                         invulnerable = (Ships[i].flags & SF_INVULNERABLE) ? 1 : 0;
 123                                         hidden_from_sensors = (Ships[i].flags & SF_HIDDEN_FROM_SENSORS) ? 1 : 0;
 124                                         ignore_count = (Ships[i].flags & SF_IGNORE_COUNT) ? 1 : 0;
 125                                         no_arrival_music = (Ships[i].flags & SF_NO_ARRIVAL_MUSIC) ? 1 : 0;
 126                                         cargo_known = (Ships[i].flags & SF_CARGO_REVEALED) ? 1 : 0;
 127                                         no_dynamic = (Ai_info[Ships[i].ai_index].ai_flags & AIF_NO_DYNAMIC) ? 1 : 0;
 128
 129                                         destroy_before_mission = (Ships[i].flags & SF_KILL_BEFORE_MISSION) ? 1 : 0;
 130                                         m_destroy_value.init(Ships[i].final_death_time);
 131
 132                                         kamikaze = (Ai_info[Ships[i].ai_index].ai_flags & AIF_KAMIKAZE) ? 1 : 0;
 133                                         m_kdamage.init( (int) Ai_info[Ships[i].ai_index].kamikaze_damage );
 134
 135                                         escort = (Ships[i].flags & SF_ESCORT) ? 1 : 0;
 136                                         m_escort_value.init(Ships[i].escort_priority);
 137
 138                                         if(The_mission.game_type & MISSION_TYPE_MULTI){
 139                                                 m_respawn_priority.init(Ships[i].respawn_priority);
 140                                         }
 141
 142                                         for (j=0; j<Num_reinforcements; j++){
 143                                                 if (!stricmp(Reinforcements[j].name, Ships[i].ship_name)){
 144                                                         break;
 145                                                 }
 146                                         }
 147
 148                                         reinforcement = (j < Num_reinforcements) ? 1 : 0;
 149
 150                                         // check if ship in wing
 151                                         ship_in_wing = (Ships[i].wingnum != -1);;
 152                                 } else {
 153
 154                                         scannable = tristate_set( Ships[i].flags & SF_SCANNABLE, scannable );
 155                                         red_alert_carry = tristate_set( Ships[i].flags & SF_RED_ALERT_STORE_STATUS, red_alert_carry );
 156                                         special_warp = tristate_set( Objects[Ships[i].objnum].flags & OF_SPECIAL_WARP, special_warp );
 157                                         protect_ship = tristate_set(Objects[Ships[i].objnum].flags & OF_PROTECTED, protect_ship);
 158                                         beam_protect_ship = tristate_set(Objects[Ships[i].objnum].flags & OF_BEAM_PROTECTED, beam_protect_ship);
 159                                         invulnerable = tristate_set(Ships[i].flags & SF_INVULNERABLE, invulnerable);
 160                                         hidden_from_sensors = tristate_set(Ships[i].flags & SF_HIDDEN_FROM_SENSORS, hidden_from_sensors);
 161                                         ignore_count = tristate_set(Ships[i].flags & SF_IGNORE_COUNT, ignore_count);
 162                                         no_arrival_music = tristate_set(Ships[i].flags & SF_NO_ARRIVAL_MUSIC, no_arrival_music);
 163                                         cargo_known = tristate_set(Ships[i].flags & SF_CARGO_REVEALED, cargo_known);
 164                                         no_dynamic = tristate_set( Ai_info[Ships[i].ai_index].ai_flags & AIF_NO_DYNAMIC, no_dynamic );
 165
 166                                         // check the final death time and set the internal variable according to whether or not
 167                                         // the final_death_time is set.  Also, the value in the edit box must be set if all the
 168                                         // values are the same, and cleared if the values are not the same.
 169                                         destroy_before_mission = tristate_set(Ships[i].flags & SF_KILL_BEFORE_MISSION, destroy_before_mission);
 170                                         m_destroy_value.set(Ships[i].final_death_time);
 171
 172                                         kamikaze = tristate_set( Ai_info[Ships[i].ai_index].ai_flags & AIF_KAMIKAZE, kamikaze );
 173                                         m_kdamage.set( (int) Ai_info[Ships[i].ai_index].kamikaze_damage );
 174
 175                                         escort = tristate_set(Ships[i].flags & SF_ESCORT, escort);
 176                                         m_escort_value.init(Ships[i].escort_priority);
 177
 178                                         if(The_mission.game_type & MISSION_TYPE_MULTI){
 179                                                 m_respawn_priority.init(Ships[i].escort_priority);
 180                                         }
 181
 182                                         for (j=0; j<Num_reinforcements; j++){
 183                                                 if (!stricmp(Reinforcements[j].name, Ships[i].ship_name)){
 184                                                         break;
 185                                                 }
 186                                         }
 187                                         reinforcement = tristate_set(j < Num_reinforcements, reinforcement);
 188
 189                                         // check if ship in wing
 190                                         ship_in_wing = (Ships[i].wingnum != -1);;
 191                                 }
 192
 193                         }
 194                 }
 195
 196                 objp = GET_NEXT(objp);
 197         }
 198
 199         CDialog::OnInitDialog();
 200
 201         m_protect_ship.SetCheck(protect_ship);
 202         m_beam_protect_ship.SetCheck(beam_protect_ship);
 203         m_ignore_count.SetCheck(ignore_count);
 204         m_reinforcement.SetCheck(reinforcement);
 205         m_cargo_known.SetCheck(cargo_known);
 206         m_destroy.SetCheck(destroy_before_mission);
 207         m_no_arrival_music.SetCheck(no_arrival_music);
 208         m_escort.SetCheck(escort);
 209         m_invulnerable.SetCheck(invulnerable);
 210         m_hidden.SetCheck(hidden_from_sensors);
 211         m_scannable.SetCheck(scannable);
 212         m_kamikaze.SetCheck(kamikaze);
 213         m_no_dynamic.SetCheck(no_dynamic);
 214         m_red_alert_carry.SetCheck(red_alert_carry);
 215         m_special_warp.SetCheck(special_warp);
 216
 217         m_kdamage.setup(IDC_KDAMAGE, this);
 218         m_destroy_value.setup(IDC_DESTROY_VALUE, this);
 219         m_escort_value.setup(IDC_ESCORT_PRIORITY, this);
 220
 221         if(The_mission.game_type & MISSION_TYPE_MULTI){
 222                 m_respawn_priority.setup(IDC_RESPAWN_PRIORITY, this);
 223         }
 224         m_destroy_spin.SetRange(0, UD_MAXVAL);
 225
 226         m_destroy_value.display();
 227         m_kdamage.display();
 228         m_escort_value.display();
 229
 230         if(The_mission.game_type & MISSION_TYPE_MULTI){
 231                 m_respawn_priority.display();
 232         } else {
 233                 GetDlgItem(IDC_RESPAWN_PRIORITY)->EnableWindow(FALSE);
 234         }
 235
 236         GetDlgItem(IDC_REINFORCEMENT)->EnableWindow(p_enable);
 237         GetDlgItem(IDC_CARGO_KNOWN)->EnableWindow(p_enable);
 238         GetDlgItem(IDC_PROTECT_SHIP)->EnableWindow(p_enable);
 239         GetDlgItem(IDC_DESTROY_CHECK)->EnableWindow(p_enable);
 240         GetDlgItem(IDC_DESTROY_VALUE)->EnableWindow(p_enable);
 241         GetDlgItem(IDC_DESTROY_SPIN)->EnableWindow(p_enable);
 242         GetDlgItem(IDC_SCANNABLE)->EnableWindow(p_enable);
 243
 244         // disable the spinner and edit window if the corrsponding check box
 245         // is not checked!
 246         if (m_destroy.GetCheck() != 1) {
 247                 GetDlgItem(IDC_DESTROY_VALUE)->EnableWindow(FALSE);
 248                 GetDlgItem(IDC_DESTROY_SPIN)->EnableWindow(FALSE);
 249         }
 250
 251         // disable destroy option for ship in wing
 252         if (ship_in_wing) {
 253                 GetDlgItem(IDC_DESTROY_CHECK)->EnableWindow(FALSE);
 254                 GetDlgItem(IDC_DESTROY_VALUE)->EnableWindow(FALSE);
 255                 GetDlgItem(IDC_DESTROY_SPIN)->EnableWindow(FALSE);
 256         }
 257
 258         // maybe disable escort priority window
 259         if (m_escort.GetCheck() == 1)
 260                 GetDlgItem(IDC_ESCORT_PRIORITY)->EnableWindow(TRUE);
 261         else
 262                 GetDlgItem(IDC_ESCORT_PRIORITY)->EnableWindow(FALSE);
 263
 264         // maybe disable kamikaze damage window
 265         if (m_kamikaze.GetCheck() == 1)
 266                 GetDlgItem(IDC_KDAMAGE)->EnableWindow(TRUE);
 267         else
 268                 GetDlgItem(IDC_KDAMAGE)->EnableWindow(FALSE);
 269
 270         return TRUE;
 271 }
 272
 273 void ship_flags_dlg::OnOK()
 274 {
 275         object *objp;
 276
 277         objp = GET_FIRST(&obj_used_list);
 278         while (objp != END_OF_LIST(&obj_used_list)) {
 279                 if ((objp->type == OBJ_START) || (objp->type == OBJ_SHIP)) {
 280                         if (objp->flags & OF_MARKED)
 281                                 update_ship(objp->instance);
 282                 }
 283
 284                 objp = GET_NEXT(objp);
 285         }
 286
 287         CDialog::OnOK();
 288 }
 289
 290 void ship_flags_dlg::update_ship(int ship)
 291 {
 292         if (m_reinforcement.GetCheck() != 2)
 293                 set_reinforcement(Ships[ship].ship_name, m_reinforcement.GetCheck());
 294
 295         switch (m_cargo_known.GetCheck()) {
 296                 case 1:
 297                         if ( !(Ships[ship].flags & SF_CARGO_REVEALED) )
 298                                 set_modified();
 299
 300                         Ships[ship].flags |= SF_CARGO_REVEALED;
 301                         break;
 302
 303                 case 0:
 304                         if ( Ships[ship].flags & SF_CARGO_REVEALED )
 305                                 set_modified();
 306
 307                         Ships[ship].flags &= ~SF_CARGO_REVEALED;
 308                         break;
 309         }
 310
 311         // update the flags for IGNORE_COUNT and PROTECT_SHIP
 312         switch (m_protect_ship.GetCheck()) {
 313                 case 1:
 314                         if (!(Objects[Ships[ship].objnum].flags & OF_PROTECTED) )
 315                                 set_modified();
 316
 317                         Objects[Ships[ship].objnum].flags |= OF_PROTECTED;
 318                         break;
 319
 320                 case 0:
 321                         if ( Objects[Ships[ship].objnum].flags & OF_PROTECTED )
 322                                 set_modified();
 323
 324                         Objects[Ships[ship].objnum].flags &= ~OF_PROTECTED;
 325                         break;
 326         }
 327
 328         switch (m_beam_protect_ship.GetCheck()) {
 329                 case 1:
 330                         if (!(Objects[Ships[ship].objnum].flags & OF_BEAM_PROTECTED) )
 331                                 set_modified();
 332
 333                         Objects[Ships[ship].objnum].flags |= OF_BEAM_PROTECTED;
 334                         break;
 335
 336                 case 0:
 337                         if ( Objects[Ships[ship].objnum].flags & OF_BEAM_PROTECTED )
 338                                 set_modified();
 339
 340                         Objects[Ships[ship].objnum].flags &= ~OF_BEAM_PROTECTED;
 341                         break;
 342         }
 343
 344         switch (m_invulnerable.GetCheck()) {
 345                 case 1:
 346                         if ( !(Ships[ship].flags & SF_INVULNERABLE) )
 347                                 set_modified();
 348
 349                         Ships[ship].flags |= SF_INVULNERABLE;
 350                         break;
 351
 352                 case 0:
 353                         if ( Ships[ship].flags & SF_INVULNERABLE )
 354                                 set_modified();
 355
 356                         Ships[ship].flags &= ~SF_INVULNERABLE;
 357                         break;
 358         }
 359
 360         switch (m_hidden.GetCheck()) {
 361                 case 1:
 362                         if ( !(Ships[ship].flags & SF_HIDDEN_FROM_SENSORS) )
 363                                 set_modified();
 364
 365                         Ships[ship].flags |= SF_HIDDEN_FROM_SENSORS;
 366                         break;
 367
 368                 case 0:
 369                         if ( Ships[ship].flags & SF_HIDDEN_FROM_SENSORS )
 370                                 set_modified();
 371
 372                         Ships[ship].flags &= ~SF_HIDDEN_FROM_SENSORS;
 373                         break;
 374         }
 375
 376         switch (m_ignore_count.GetCheck()) {
 377                 case 1:
 378                         if ( !(Ships[ship].flags & SF_IGNORE_COUNT) )
 379                                 set_modified();
 380
 381                         Ships[ship].flags |= SF_IGNORE_COUNT;
 382                         break;
 383
 384                 case 0:
 385                         if (Ships[ship].flags & SF_IGNORE_COUNT)
 386                                 set_modified();
 387
 388                         Ships[ship].flags &= ~SF_IGNORE_COUNT;
 389                         break;
 390         }
 391
 392         switch (m_escort.GetCheck()) {
 393                 case 1:
 394                         if (!(Ships[ship].flags & SF_ESCORT))
 395                                 set_modified();
 396
 397                         Ships[ship].flags |= SF_ESCORT;
 398                         m_escort_value.save(&Ships[ship].escort_priority);
 399                         break;
 400
 401                 case 0:
 402                         if (Ships[ship].flags & SF_ESCORT)
 403                                 set_modified();
 404
 405                         Ships[ship].flags &= ~SF_ESCORT;
 406                         break;
 407         }
 408
 409         // deal with updating the "destroy before the mission" stuff
 410         switch (m_destroy.GetCheck()) {
 411                 case 0:  // this means no check in checkbox
 412                         if ( Ships[ship].flags & SF_KILL_BEFORE_MISSION )
 413                                 set_modified();
 414
 415                         Ships[ship].flags &= ~SF_KILL_BEFORE_MISSION;
 416                         break;
 417
 418                 case 1:  // this means checkbox is checked
 419                         if ( !(Ships[ship].flags & SF_KILL_BEFORE_MISSION) )
 420                                 set_modified();
 421
 422                         Ships[ship].flags |= SF_KILL_BEFORE_MISSION;
 423                         m_destroy_value.save(&Ships[ship].final_death_time);
 424                         break;
 425         }  // a mixed state is 2, and since it's not handled, it doesn't change
 426
 427         switch (m_no_arrival_music.GetCheck()) {
 428                 case 0:
 429                         if (Ships[ship].flags & SF_NO_ARRIVAL_MUSIC)
 430                                 set_modified();
 431
 432                         Ships[ship].flags &= ~SF_NO_ARRIVAL_MUSIC;
 433                         break;
 434
 435                 case 1:
 436                         if (!(Ships[ship].flags & SF_NO_ARRIVAL_MUSIC))
 437                                 set_modified();
 438
 439                         Ships[ship].flags |= SF_NO_ARRIVAL_MUSIC;
 440                         break;
 441         }
 442
 443         switch (m_scannable.GetCheck()) {
 444                 case 1:
 445                         if ( !(Ships[ship].flags & SF_SCANNABLE) )
 446                                 set_modified();
 447
 448                         Ships[ship].flags |= SF_SCANNABLE;
 449                         break;
 450
 451                 case 0:
 452                         if ( Ships[ship].flags & SF_SCANNABLE )
 453                                 set_modified();
 454
 455                         Ships[ship].flags &= ~SF_SCANNABLE;
 456                         break;
 457         }
 458
 459         switch (m_red_alert_carry.GetCheck()) {
 460                 case 1:
 461                         if ( !(Ships[ship].flags & SF_RED_ALERT_STORE_STATUS) )
 462                                 set_modified();
 463
 464                         Ships[ship].flags |= SF_RED_ALERT_STORE_STATUS;
 465                         break;
 466
 467                 case 0:
 468                         if ( Ships[ship].flags & SF_RED_ALERT_STORE_STATUS )
 469                                 set_modified();
 470
 471                         Ships[ship].flags &= ~SF_RED_ALERT_STORE_STATUS;
 472                         break;
 473         }
 474
 475         switch (m_special_warp.GetCheck()) {
 476                 case 1:
 477                         if ( !(Objects[Ships[ship].objnum].flags & OF_SPECIAL_WARP) )
 478                                 set_modified();
 479
 480                         Objects[Ships[ship].objnum].flags |= OF_SPECIAL_WARP;
 481                         break;
 482
 483                 case 0:
 484                         if ( (Objects[Ships[ship].objnum].flags & OF_SPECIAL_WARP) )
 485                                 set_modified();
 486
 487                         Objects[Ships[ship].objnum].flags &= (~OF_SPECIAL_WARP);
 488                         break;
 489         }
 490
 491         switch (m_no_dynamic.GetCheck()) {
 492                 case 1:
 493                         if ( !(Ai_info[Ships[ship].ai_index].ai_flags & AIF_NO_DYNAMIC) )
 494                                 set_modified();
 495
 496                         Ai_info[Ships[ship].ai_index].ai_flags |= AIF_NO_DYNAMIC;
 497                         break;
 498
 499                 case 0:
 500                         if ( Ai_info[Ships[ship].ai_index].ai_flags & AIF_NO_DYNAMIC )
 501                                 set_modified();
 502
 503                         Ai_info[Ships[ship].ai_index].ai_flags &= ~AIF_NO_DYNAMIC;
 504                         break;
 505         }
 506
 507         switch (m_kamikaze.GetCheck()) {
 508                 case 1: {
 509                         int damage;
 510
 511                         if ( !(Ai_info[Ships[ship].ai_index].ai_flags & AIF_KAMIKAZE) )
 512                                 set_modified();
 513
 514                         Ai_info[Ships[ship].ai_index].ai_flags |= AIF_KAMIKAZE;
 515                         m_kdamage.save(&damage);
 516                         Ai_info[Ships[ship].ai_index].kamikaze_damage = i2fl(damage);
 517                         break;
 518                 }
 519
 520                 case 0:
 521                         if ( Ai_info[Ships[ship].ai_index].ai_flags & AIF_KAMIKAZE )
 522                                 set_modified();
 523
 524                         Ai_info[Ships[ship].ai_index].ai_flags &= ~AIF_KAMIKAZE;
 525                         Ai_info[Ships[ship].ai_index].kamikaze_damage = 0.0f;
 526                         break;
 527         }
 528
 529         Ships[ship].respawn_priority = 0;
 530         if(The_mission.game_type & MISSION_TYPE_MULTI){
 531                 m_respawn_priority.save(&Ships[ship].respawn_priority);
 532         }
 533 }
 534
 535 int ship_flags_dlg::tristate_set(int val, int cur_state)
 536 {
 537         if (val) {
 538                 if (!cur_state){
 539                         return 2;
 540                 }
 541         } else {
 542                 if (cur_state){
 543                         return 2;
 544                 }
 545         }
 546
 547         return cur_state;
 548 }
 549
 550 // a stub for now, but might be useful later.  Easier than ripping out the calls to this
 551 // everywhere at least.
 552 void ship_flags_dlg::set_modified()
 553 {
 554 }
 555
 556 void ship_flags_dlg::OnCargoKnown()
 557 {
 558         if (m_cargo_known.GetCheck() == 1){
 559                 m_cargo_known.SetCheck(0);
 560         } else {
 561                 m_cargo_known.SetCheck(1);
 562         }
 563 }
 564
 565 void ship_flags_dlg::OnDestroyCheck()
 566 {
 567         if (m_destroy.GetCheck() == 1) {
 568                 m_destroy.SetCheck(0);
 569                 GetDlgItem(IDC_DESTROY_VALUE)->EnableWindow(FALSE);
 570                 GetDlgItem(IDC_DESTROY_SPIN)->EnableWindow(FALSE);
 571
 572         } else {
 573                 m_destroy.SetCheck(1);
 574                 GetDlgItem(IDC_DESTROY_VALUE)->EnableWindow(TRUE);
 575                 GetDlgItem(IDC_DESTROY_SPIN)->EnableWindow(TRUE);
 576         }
 577 }
 578
 579 void ship_flags_dlg::OnEscort()
 580 {
 581         if (m_escort.GetCheck() == 1) {
 582                 m_escort.SetCheck(0);
 583                 GetDlgItem(IDC_ESCORT_PRIORITY)->EnableWindow(FALSE);
 584         } else {
 585                 m_escort.SetCheck(1);
 586                 GetDlgItem(IDC_ESCORT_PRIORITY)->EnableWindow(TRUE);
 587         }
 588 }
 589
 590 void ship_flags_dlg::OnHiddenFromSensors()
 591 {
 592         if (m_hidden.GetCheck() == 1){
 593                 m_hidden.SetCheck(0);
 594         } else {
 595                 m_hidden.SetCheck(1);
 596         }
 597 }
 598
 599 void ship_flags_dlg::OnIgnoreCount()
 600 {
 601         if (m_ignore_count.GetCheck() == 1){
 602                 m_ignore_count.SetCheck(0);
 603         } else {
 604                 m_ignore_count.SetCheck(1);
 605         }
 606 }
 607
 608 void ship_flags_dlg::OnInvulnerable()
 609 {
 610         if (m_invulnerable.GetCheck() == 1){
 611                 m_invulnerable.SetCheck(0);
 612         } else {
 613                 m_invulnerable.SetCheck(1);
 614         }
 615 }
 616
 617 void ship_flags_dlg::OnKamikaze()
 618 {
 619         if (m_kamikaze.GetCheck() == 1) {
 620                 GetDlgItem(IDC_KDAMAGE)->EnableWindow(FALSE);
 621                 m_kamikaze.SetCheck(0);
 622
 623         } else {
 624                 GetDlgItem(IDC_KDAMAGE)->EnableWindow(TRUE);
 625                 m_kamikaze.SetCheck(1);
 626         }
 627 }
 628
 629 void ship_flags_dlg::OnNoArrivalMusic()
 630 {
 631         if (m_no_arrival_music.GetCheck() == 1){
 632                 m_no_arrival_music.SetCheck(0);
 633         } else {
 634                 m_no_arrival_music.SetCheck(1);
 635         }
 636 }
 637
 638 void ship_flags_dlg::OnNoDynamic()
 639 {
 640         if (m_no_dynamic.GetCheck() == 1){
 641                 m_no_dynamic.SetCheck(0);
 642         } else {
 643                 m_no_dynamic.SetCheck(1);
 644         }
 645 }
 646
 647 void ship_flags_dlg::OnProtectShip()
 648 {
 649         if (m_protect_ship.GetCheck() == 1){
 650                 m_protect_ship.SetCheck(0);
 651         } else {
 652                 m_protect_ship.SetCheck(1);
 653         }
 654 }
 655
 656 void ship_flags_dlg::OnBeamProtectShip()
 657 {
 658         if (m_beam_protect_ship.GetCheck() == 1){
 659                 m_beam_protect_ship.SetCheck(0);
 660         } else {
 661                 m_beam_protect_ship.SetCheck(1);
 662         }
 663 }
 664
 665 void ship_flags_dlg::OnReinforcement()
 666 {
 667         if (m_reinforcement.GetCheck() == 1){
 668                 m_reinforcement.SetCheck(0);
 669         } else {
 670                 m_reinforcement.SetCheck(1);
 671         }
 672 }
 673
 674 void ship_flags_dlg::OnScannable()
 675 {
 676         if (m_scannable.GetCheck() == 1){
 677                 m_scannable.SetCheck(0);
 678         } else {
 679                 m_scannable.SetCheck(1);
 680         }
 681 }
 682
 683 void ship_flags_dlg::OnRedalertcarry()
 684 {
 685         if (m_red_alert_carry.GetCheck() == 1){
 686                 m_red_alert_carry.SetCheck(0);
 687         } else {
 688                 m_red_alert_carry.SetCheck(1);
 689         }
 690 }
 691