main/editor/kbuild.c

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