main/editor/kbuild.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 /*
  15  *
  16  * Functions for building parts of mines.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "conf.h"
  22 #endif
  23
  24 #include <string.h>
  25
  26 #include "inferno.h"
  27 #include "editor.h"
  28 #include "mono.h"
  29
  30
  31 //  ---------- Create a bridge segment between current segment/side and marked segment/side ----------
  32 int CreateBridge()
  33 {
  34     if (!med_form_bridge_segment(Cursegp,Curside,Markedsegp,Markedside)) {
  35                 Update_flags |= UF_WORLD_CHANGED;
  36                 mine_changed = 1;
  37         autosave_mine(mine_filename);
  38         diagnostic_message("Bridge segment formed.");
  39         strcpy(undo_status[Autosave_count], "Bridge segment UNDONE.");
  40         warn_if_concave_segments();
  41         }
  42     return 1;
  43 }
  44
  45
  46
  47 // ---------- Form a joint between current segment:side and marked segment:side, modifying marked segment ----------
  48 int FormJoint()
  49 {
  50         if (!Markedsegp)
  51                 diagnostic_message("Marked segment not set -- unable to form joint.");
  52         else {
  53         if (!med_form_joint(Cursegp,Curside,Markedsegp,Markedside)) {
  54             Update_flags |= UF_WORLD_CHANGED;
  55             mine_changed = 1;
  56             autosave_mine(mine_filename);
  57             diagnostic_message("Joint formed.");
  58             strcpy(undo_status[Autosave_count], "Joint undone.");
  59                         warn_if_concave_segments();
  60         }
  61         }
  62
  63         return 1;
  64
  65 }
  66
  67 //  ---------- Create a bridge segment between current segment:side adjacent segment:side ----------
  68 int CreateAdjacentJoint()
  69 {
  70         int             adj_side;
  71         segment *adj_sp;
  72
  73         if (med_find_adjacent_segment_side(Cursegp, Curside, &adj_sp, &adj_side)) {
  74                 if (Cursegp->children[Curside] != SEGMENT_NUMBER(adj_sp)) {
  75                         med_form_joint(Cursegp,Curside,adj_sp,adj_side);
  76                         Update_flags |= UF_WORLD_CHANGED;
  77                         mine_changed = 1;
  78          autosave_mine(mine_filename);
  79          diagnostic_message("Joint segment formed.");
  80          strcpy(undo_status[Autosave_count], "Joint segment undone.");
  81                 warn_if_concave_segments();
  82                 } else
  83                         editor_status("Attempted to form joint through connected side -- joint segment not formed (you bozo).");
  84         } else
  85                 editor_status("Could not find adjacent segment -- joint segment not formed.");
  86
  87         return 1;
  88 }
  89
  90 //  ---------- Create a bridge segment between current segment:side adjacent segment:side ----------
  91 int CreateSloppyAdjacentJoint()
  92 {
  93         int             adj_side;
  94         segment *adj_sp;
  95
  96         save_level("SLOPPY.LVL");
  97
  98         if (med_find_closest_threshold_segment_side(Cursegp, Curside, &adj_sp, &adj_side, 20*F1_0)) {
  99                 if (Cursegp->children[Curside] != SEGMENT_NUMBER(adj_sp)) {
 100                         if (!med_form_joint(Cursegp,Curside,adj_sp,adj_side))
 101                                 {
 102                                 Update_flags |= UF_WORLD_CHANGED;
 103                                 mine_changed = 1;
 104                  autosave_mine(mine_filename);
 105                  diagnostic_message("Sloppy Joint segment formed.");
 106                  strcpy(undo_status[Autosave_count], "Sloppy Joint segment undone.");
 107                         warn_if_concave_segments();
 108                                 }
 109                         else editor_status("Couldn't form sloppy joint.\n");
 110                 } else
 111                         editor_status("Attempted to form sloppy joint through connected side -- joint segment not formed (you bozo).");
 112         } else
 113                 editor_status("Could not find close threshold segment -- joint segment not formed.");
 114
 115         return 1;
 116 }
 117
 118
 119 //  -------------- Create all sloppy joints within CurrentGroup ------------------
 120 int CreateSloppyAdjacentJointsGroup()
 121 {
 122         int             adj_side;
 123         segment *adj_sp;
 124         int             num_segs = GroupList[current_group].num_segments;
 125         short           *segs = GroupList[current_group].segments;
 126         segment *segp;
 127         int             done_been_a_change = 0;
 128         int             segind, sidenum;
 129
 130         for (segind=0; segind<num_segs; segind++) {
 131                 segp = &Segments[segs[segind]];
 132
 133                 for (sidenum=0; sidenum < MAX_SIDES_PER_SEGMENT; sidenum++)
 134                         if (!IS_CHILD(segp->children[sidenum]))
 135                                 if (med_find_closest_threshold_segment_side(segp, sidenum, &adj_sp, &adj_side, 5*F1_0)) {
 136                                         if (adj_sp->group == segp->group) {
 137                                                 if (segp->children[sidenum] != SEGMENT_NUMBER(adj_sp))
 138                                                         if (!med_form_joint(segp, sidenum, adj_sp,adj_side))
 139                                                                 done_been_a_change = 1;
 140                                         }
 141                                 }
 142         }
 143
 144         if (done_been_a_change) {
 145                 Update_flags |= UF_WORLD_CHANGED;
 146                 mine_changed = 1;
 147                 autosave_mine(mine_filename);
 148                 diagnostic_message("Sloppy Joint segment formed.");
 149                 strcpy(undo_status[Autosave_count], "Sloppy Joint segment undone.");
 150                 warn_if_concave_segments();
 151         }
 152
 153         return 1;
 154 }
 155
 156
 157 //  ---------- Create a bridge segment between current segment and all adjacent segment:side ----------
 158 int CreateAdjacentJointsSegment()
 159 {
 160         int             adj_side,s;
 161         segment *adj_sp;
 162
 163         med_combine_duplicate_vertices(Vertex_active);
 164
 165         for (s=0; s<MAX_SIDES_PER_SEGMENT; s++) {
 166                 if (med_find_adjacent_segment_side(Cursegp, s, &adj_sp, &adj_side))
 167                         if (Cursegp->children[s] != SEGMENT_NUMBER(adj_sp))
 168                                         {
 169                                         med_form_joint(Cursegp,s,adj_sp,adj_side);
 170                                         Update_flags |= UF_WORLD_CHANGED;
 171                                         mine_changed = 1;
 172                     autosave_mine(mine_filename);
 173                     diagnostic_message("Adjacent Joint segment formed.");
 174                     strcpy(undo_status[Autosave_count], "Adjacent Joint segment UNDONE.");
 175                                 warn_if_concave_segments();
 176                                         }
 177         }
 178
 179         return 1;
 180 }
 181
 182 //  ---------- Create a bridge segment between all segment:side and all adjacent segment:side ----------
 183 int CreateAdjacentJointsAll()
 184 {
 185         int             adj_side,seg,s;
 186         segment *adj_sp;
 187
 188         med_combine_duplicate_vertices(Vertex_active);
 189
 190         for (seg=0; seg<=Highest_segment_index; seg++)
 191                 for (s=0; s<MAX_SIDES_PER_SEGMENT; s++)
 192                         if (med_find_adjacent_segment_side(&Segments[seg], s, &adj_sp, &adj_side))
 193                                 if (Segments[seg].children[s] != SEGMENT_NUMBER(adj_sp))
 194                                                 med_form_joint(&Segments[seg],s,adj_sp,adj_side);
 195
 196         Update_flags |= UF_WORLD_CHANGED;
 197         mine_changed = 1;
 198    autosave_mine(mine_filename);
 199    diagnostic_message("All Adjacent Joint segments formed.");
 200    strcpy(undo_status[Autosave_count], "All Adjacent Joint segments UNDONE.");
 201         warn_if_concave_segments();
 202    return 1;
 203 }
 204
 205