home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the DOOM Programming Gurus / Tricks_of_the_Doom_Programming_Gurus.iso / bonus / editors / deth / source / editobj.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-03  |  72.7 KB  |  2,317 lines
  1. /*   Doom Editor for Total Headcases, by Simon Oke and Antony Burden.
  2.    
  3.    You are allowed to use any parts of this code in another program, as
  4.    long as you give credits to the authors in the documentation and in
  5.    the program itself.  Read the file README.1ST for more information.
  6.    
  7.    This program comes with absolutely no warranty.
  8.    
  9.    EDITOBJ.C - object editing routines.
  10.    */
  11.  
  12. /* the includes */
  13. #include "deu.h"
  14. #include "levels.h"
  15.  
  16. /*
  17.    display the information about one object
  18.    */
  19.  
  20. void DisplayObjectInfo( BCINT objtype, BCINT objnum) /* SWAP! */
  21. {
  22.     char texname[ 9];
  23.     BCINT  tag, n;
  24.     BCINT  sd1 = -1, sd2 = -1, s1 = -1, s2 = -1;
  25.     BCINT  x0, y0;
  26.     
  27.     ObjectsNeeded( objtype, 0);
  28.     switch (objtype) {
  29.     case OBJ_THINGS:
  30.     x0 = 0;
  31.     /* ajb */
  32.     y0 = ScrMaxY - 72;
  33.     if (InfoShown)
  34.         y0 -= 13;
  35.     /* ajb */
  36.     DrawScreenBox3D( x0, y0, x0 + 360, y0 + 72);
  37.     if (objnum < 0) {
  38.         /* ajb 2 */
  39.         DrawScreenText( x0 + 112, y0 + 30, "Use the cursor to");
  40.         DrawScreenText( x0 + 124, y0 + 40, "select a Thing  ");
  41.         break;
  42.     }
  43.     SetColor( YELLOW);
  44.     DrawScreenText( x0 + 5, y0 + 5, "Selected Thing (#%d)", objnum);
  45.     /* ajb 2 */
  46.     SetColor( RED);
  47.     DrawScreenText( -1, y0 + 20, "Thing Number:  (%4d)", Things[ objnum].type);
  48.     SetColor( BLACK);
  49.     DrawScreenText( -1, -1, "Coordinates:   (%d, %d)", Things[ objnum].xpos, Things[ objnum].ypos);
  50.         DrawScreenText( -1, -1, "Type:          %s", GetThingName( Things[ objnum].type));
  51.         DrawScreenText( -1, -1, "Angle:         %s", GetAngleName( Things[ objnum].angle));
  52.     DrawScreenText( -1, -1, "Flags:         %s", GetWhenName( Things[ objnum].when));
  53.     break;
  54.     
  55.     case OBJ_LINEDEFS:
  56.     x0 = 0;
  57.     y0 = ScrMaxY - 80;
  58.     if (InfoShown)
  59.         y0 -= 13;
  60.     DrawScreenBox3D(   x0, y0, x0 + 254, y0 + 80);
  61.     if (objnum >= 0) {
  62.         SetColor( YELLOW);
  63.         DrawScreenText( x0 + 5, y0 + 5, "Selected LineDef (#%d)", objnum);
  64.         SetColor( BLACK);
  65.             DrawScreenText( -1, y0 + 20, "Flags:%3d    %s", LineDefs[ objnum].flags, GetLineDefFlagsName( LineDefs[ objnum].flags));
  66.         DrawScreenText( -1, -1, "Type: %3d %s", LineDefs[ objnum].type, GetLineDefTypeName( LineDefs[ objnum].type));
  67.         sd1 = LineDefs[ objnum].sidedef1;
  68.         sd2 = LineDefs[ objnum].sidedef2;
  69.         tag = LineDefs[ objnum].tag;
  70.         ObjectsNeeded( OBJ_SIDEDEFS, OBJ_SECTORS, 0);
  71.         s1 = LineDefs[ objnum].start;
  72.         s2 = LineDefs[ objnum].end;
  73.         ObjectsNeeded( OBJ_VERTEXES, 0);
  74.         n = ComputeDist( Vertexes[ s2].x - Vertexes[ s1].x, Vertexes[ s2].y - Vertexes[ s1].y);
  75.         DrawScreenText( x0 + 160, y0 + 60, "Length:");
  76.         DrawScreenText( x0 + 170, y0 + 70, "%d", n);
  77.         if (tag > 0) {
  78.         for (n = 0; n < NumSectors; n++)
  79.             if (Sectors[ n].tag == tag)
  80.             break;
  81.         }
  82.         else
  83.         n = NumSectors;
  84.         if (n < NumSectors)
  85.         DrawScreenText( x0 + 5, y0 + 40, "Sector Tag:  %d (#%d)", tag, n);
  86.         else
  87.         DrawScreenText( x0 + 5, y0 + 40, "Sector Tag:  %d (none)", tag);
  88.             DrawScreenText( -1, -1, "Vertexes:    (#%d, #%d)", s1, s2);
  89.         DrawScreenText( -1, -1, "1st SideDef: #%d", sd1);
  90.         DrawScreenText( -1, -1, "2nd SideDef: #%d", sd2);
  91.         if (sd1 >= 0)
  92.         s1 = SideDefs[ sd1].sector;
  93.         else
  94.         s1 = -1;
  95.         if (sd2 >= 0)
  96.         s2 = SideDefs[ sd2].sector;
  97.         else
  98.         s2 = -1;
  99.     }
  100.     else {
  101.         SetColor(LIGHTGRAY);
  102.         DrawScreenText( x0 + 25, y0 + 35, "(No LineDef selected)");
  103.     }
  104.     x0 = 255;
  105.     y0 = ScrMaxY - 80;
  106.     if (InfoShown)
  107.         y0 -= 13;
  108.     DrawScreenBox3D( x0, y0, x0 + 192, y0 + 80);
  109.     if (objnum >= 0 && sd1 >= 0) {
  110.         SetColor( YELLOW);
  111.         DrawScreenText( x0 + 5, y0 + 5, "First SideDef (#%d)", sd1);
  112.         SetColor( BLACK);
  113.         texname[ 8] = '\0';
  114.         strncpy( texname, SideDefs[ sd1].tex3, 8);
  115.         DrawScreenText( -1, y0 + 20, "Norm. Texture: %s", texname);
  116.         strncpy( texname, SideDefs[ sd1].tex1, 8);
  117.         if (s1 >= 0 && s2 >= 0 && Sectors[ s1].ceilh > Sectors[ s2].ceilh) {
  118.         if (texname[ 0] == '-' && texname[ 1] == '\0')
  119.             SetColor( RED);
  120.         }
  121.         else
  122.         SetColor(GRAY);
  123.         DrawScreenText( -1, -1, "Upper Texture: %s", texname);
  124.         SetColor( BLACK);
  125.         strncpy( texname, SideDefs[ sd1].tex2, 8);
  126.         if (s1 >= 0 && s2 >= 0 && Sectors[ s1].floorh < Sectors[ s2].floorh) {
  127.         if (texname[ 0] == '-' && texname[ 1] == '\0')
  128.             SetColor( RED);
  129.         }
  130.         else
  131.         SetColor(GRAY);
  132.         DrawScreenText( -1, -1, "Lower Texture: %s", texname);
  133.         SetColor( BLACK);
  134.         DrawScreenText( -1, -1, "Tex. X offset: %d", SideDefs[ sd1].xoff);
  135.         DrawScreenText( -1, -1, "Tex. Y offset: %d", SideDefs[ sd1].yoff);
  136.             DrawScreenText( -1, -1, "Sector:        #%d", s1);
  137.     }
  138.     else {
  139.         SetColor(LIGHTGRAY);
  140.         DrawScreenText( x0 + 25, y0 + 35, "(No first SideDef)");
  141.     }
  142.     x0 = 448;
  143.     y0 = ScrMaxY - 80;
  144.     if (InfoShown)
  145.         y0 -= 13;
  146.     DrawScreenBox3D( x0, y0, x0 + 192, y0 + 80);
  147.     if (objnum >= 0 && sd2 >= 0) {
  148.         SetColor( YELLOW);
  149.         DrawScreenText( x0 + 5, y0 + 5, "Second SideDef (#%d)", sd2);
  150.         SetColor( BLACK);
  151.         texname[ 8] = '\0';
  152.         strncpy( texname, SideDefs[ sd2].tex3, 8);
  153.         
  154.         DrawScreenText( -1, y0 + 20, "Norm. Texture: %s", texname);
  155.         strncpy( texname, SideDefs[ sd2].tex1, 8);
  156.         if (s1 >= 0 && s2 >= 0 && Sectors[ s2].ceilh > Sectors[ s1].ceilh) {
  157.         if (texname[ 0] == '-' && texname[ 1] == '\0')
  158.             SetColor( RED);
  159.         }
  160.         else
  161.         SetColor(GRAY);
  162.         DrawScreenText( -1, -1, "Upper Texture: %s", texname);
  163.         SetColor( BLACK);
  164.         strncpy( texname, SideDefs[ sd2].tex2, 8);
  165.         if (s1 >= 0 && s2 >= 0 && Sectors[ s2].floorh < Sectors[ s1].floorh) {
  166.         if (texname[ 0] == '-' && texname[ 1] == '\0')
  167.             SetColor( RED);
  168.         }
  169.         else
  170.         SetColor(GRAY);
  171.         DrawScreenText( -1, -1, "Lower Texture: %s", texname);
  172.         SetColor( BLACK);
  173.         DrawScreenText( -1, -1, "Tex. X offset: %d", SideDefs[ sd2].xoff);
  174.         DrawScreenText( -1, -1, "Tex. Y offset: %d", SideDefs[ sd2].yoff);
  175.             DrawScreenText( -1, -1, "Sector:        #%d", s2);
  176.     }
  177.     else {
  178.         SetColor(LIGHTGRAY);
  179.         DrawScreenText( x0 + 25, y0 + 35, "(No second SideDef)");
  180.     }
  181.     break;
  182.     case OBJ_VERTEXES:
  183.     x0 = 0;
  184.     y0 = ScrMaxY - 30;
  185.     if (InfoShown)
  186.         y0 -= 13;
  187.     DrawScreenBox3D( x0, y0, x0 + 220, y0 + 30);
  188.     if (objnum < 0) {
  189.         SetColor(LIGHTGRAY);
  190.         DrawScreenText( x0 + 30, y0 + 12, "(No Vertex selected)");
  191.         break;
  192.     }
  193.     SetColor( YELLOW);
  194.     DrawScreenText( x0 + 5, y0 + 5, "Selected Vertex (#%d)", objnum);
  195.     SetColor( BLACK);
  196.     DrawScreenText( -1, y0 + 20, "Coordinates: (%d, %d)", Vertexes[ objnum].x, Vertexes[ objnum].y);
  197.     break;
  198.     case OBJ_SECTORS:
  199.     x0 = 0;
  200.     y0 = ScrMaxY - 100;
  201.     if (InfoShown)
  202.         y0 -= 13;
  203.     DrawScreenBox3D( x0, y0, x0 + 300, y0 + 100);
  204.     if (objnum < 0) {
  205.         SetColor(LIGHTGRAY);
  206.         DrawScreenText( x0 + 73, y0 + 48, "(No Sector selected)");
  207.         break;
  208.     }
  209.     SetColor( YELLOW);
  210.     DrawScreenText( x0 + 5, y0 + 5, "Selected Sector (#%d)", objnum);
  211.     SetColor( BLACK);
  212.     DrawScreenText( -1, y0 + 20, "Floor Height:    %d", Sectors[ objnum].floorh);
  213.     DrawScreenText( -1, -1, "Ceiling Height:  %d", Sectors[ objnum].ceilh);
  214.     DrawScreenText( -1, -1, "Sector Height:   %d", Sectors[ objnum].ceilh - Sectors[objnum].floorh);
  215.  
  216.     texname[ 8] = '\0';
  217.     strncpy( texname, Sectors[ objnum].floort, 8);
  218.     DrawScreenText( -1, -1, "Floor Texture:   %s", texname);
  219.     strncpy( texname, Sectors[ objnum].ceilt, 8);
  220.     DrawScreenText( -1, -1, "Ceiling Texture: %s", texname);
  221.     DrawScreenText( -1, -1, "Light Level:     %d", Sectors[ objnum].light);
  222.     DrawScreenText( -1, -1, "Type: %3d        %s", Sectors[ objnum].special, GetSectorTypeName( Sectors[ objnum].special));
  223.     tag = Sectors[ objnum].tag;
  224.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  225.     if (tag == 0)
  226.         n = NumLineDefs;
  227.     else
  228.         for (n = 0; n < NumLineDefs; n++)
  229.         if (LineDefs[ n].tag == tag)
  230.             break;
  231.     if (n < NumLineDefs)
  232.             DrawScreenText( -1, -1, "LineDef Tag:     %d (#%d)", tag, n);
  233.     else if (tag == 99 || tag == 999)
  234.             DrawScreenText( -1, -1, "LineDef Tag:     %d (Stairs?)", tag);
  235.     else if (tag == 666)
  236.             DrawScreenText( -1, -1, "LineDef Tag:     %d (Lower at End)", tag);
  237.     else
  238.             DrawScreenText( -1, -1, "LineDef Tag:     %d (none)", tag);
  239.     break;
  240.     }
  241. }
  242.  
  243.  
  244. /*
  245.    ask for an object number and check for maximum valid number
  246.    (this is just like InputIntegerValue, but with a different prompt)
  247.    */
  248.  
  249. BCINT InputObjectNumber( BCINT x0, BCINT y0, BCINT objtype, BCINT curobj)
  250. {
  251.     BCINT val, key;
  252.     char prompt[ 80];
  253.     
  254.     if (UseMouse)
  255.     HideMousePointer();
  256.     sprintf( prompt, "Enter a %s Value between 0 and %d:", GetObjectTypeName( objtype), GetMaxObjectNum( objtype));
  257.     if (x0 < 0)
  258.     x0 = (ScrMaxX - 25 - 8 * strlen( prompt)) / 2;
  259.     if (y0 < 0)
  260.     y0 = (ScrMaxY - 55) / 2;
  261.     DrawScreenBox3D( x0, y0, x0 + 25 + 8 * strlen( prompt), y0 + 55);
  262.     SetColor( WHITE);
  263.     DrawScreenText( x0 + 10, y0 + 8, prompt);
  264.     val = curobj;
  265.     while (((key = InputInteger( x0 + 10, y0 + 28, &val, 0, GetMaxObjectNum( objtype))) & 0x00FF) != 0x000D && (key & 0x00FF) != 0x001B)
  266.     Beep();
  267.     if (UseMouse)
  268.     ShowMousePointer();
  269.     return val;
  270. }
  271.  
  272.  
  273.  
  274. /*
  275.    ask for an object number and display a warning message
  276.    */
  277.  
  278. BCINT InputObjectXRef( BCINT x0, BCINT y0, BCINT objtype, Bool allownone, BCINT curobj)
  279. {
  280.     BCINT val, key;
  281.     char prompt[ 80];
  282.     
  283.     if (UseMouse)
  284.     HideMousePointer();
  285.     sprintf( prompt, "Enter a %s Value between 0 and %d%c", GetObjectTypeName( objtype), GetMaxObjectNum( objtype), allownone ? ',' : ':');
  286.     val = strlen( prompt);
  287.     if (val < 40)
  288.     val = 40;
  289.     if (x0 < 0)
  290.     x0 = (ScrMaxX - 25 - 8 * val) / 2;
  291.     if (y0 < 0)
  292.     y0 = (ScrMaxY - (allownone ? 85 : 75)) / 2;
  293.     DrawScreenBox3D( x0, y0, x0 + 25 + 8 * val, y0 + (allownone ? 85 : 75));
  294.     SetColor( WHITE);
  295.     DrawScreenText( x0 + 10, y0 + 8, prompt);
  296.     if (allownone)
  297.     DrawScreenText( x0 + 10, y0 + 18, "or -1 for none:");
  298.     SetColor( RED);
  299.     DrawScreenText( x0 + 10, y0 + (allownone ? 60 : 50), "Warning: modifying the cross-references");
  300.     DrawScreenText( x0 + 10, y0 + (allownone ? 70 : 60), "between some objects may crash the game.");
  301.     val = curobj;
  302.     while (((key = InputInteger( x0 + 10, y0 + (allownone ? 38 : 28), &val, allownone ? -1 : 0, GetMaxObjectNum( objtype))) & 0x00FF) != 0x000D && (key & 0x00FF) != 0x001B)
  303.     Beep();
  304.     if (UseMouse)
  305.     ShowMousePointer();
  306.     return val;
  307. }
  308.  
  309.  
  310.  
  311. /*
  312.    ask for two vertex numbers and check for maximum valid number
  313.    */
  314.  
  315. Bool Input2VertexNumbers( BCINT x0, BCINT y0, char *prompt1, BCINT *v1, BCINT *v2)
  316. {
  317.     BCINT  key;
  318.     BCINT  maxlen, first;
  319.     Bool ok;
  320.     char prompt2[ 80];
  321.     
  322.     if (UseMouse)
  323.     HideMousePointer();
  324.     sprintf( prompt2, "Enter two numbers between 0 and %d:", NumVertexes - 1);
  325.     if (strlen( prompt1) > strlen( prompt2))
  326.     maxlen = strlen( prompt1);
  327.     else
  328.     maxlen = strlen( prompt2);
  329.     if (x0 < 0)
  330.     x0 = (ScrMaxX - 25 - 8 * maxlen) / 2;
  331.     if (y0 < 0)
  332.     y0 = (ScrMaxY - 75) / 2;
  333.     DrawScreenBox3D( x0, y0, x0 + 25 + 8 * maxlen, y0 + 75);
  334.     DrawScreenText( x0 + 10, y0 + 36, "From this Vertex");
  335.     DrawScreenText( x0 + 180, y0 + 36, "To this Vertex");
  336.     SetColor( WHITE);
  337.     DrawScreenText( x0 + 10, y0 + 8, prompt1);
  338.     DrawScreenText( x0 + 10, y0 + 18, prompt2);
  339.     first = TRUE;
  340.     key = 0;
  341.     for (;;) {
  342.     ok = TRUE;
  343.     DrawScreenBox3D( x0 + 10, y0 + 48, x0 + 71, y0 + 61);
  344.     if (*v1 < 0 || *v1 >= NumVertexes)
  345.         {
  346.         SetColor( DARKGRAY);
  347.         ok = FALSE;
  348.         }
  349.     DrawScreenText( x0 + 14, y0 + 51, "%d", *v1);
  350.     DrawScreenBox3D( x0 + 180, y0 + 48, x0 + 241, y0 + 61);
  351.     if (*v2 < 0 || *v2 >= NumVertexes) {
  352.         SetColor( DARKGRAY);
  353.         ok = FALSE;
  354.     }
  355.     DrawScreenText( x0 + 184, y0 + 51, "%d", *v2);
  356.     if (first)
  357.         key = InputInteger( x0 + 10, y0 + 48, v1, 0, NumVertexes - 1);
  358.     else
  359.         key = InputInteger( x0 + 180, y0 + 48, v2, 0, NumVertexes - 1);
  360.     if ((key & 0xFF00) == 0x4B00 || (key & 0xFF00) == 0x4D00 || (key & 0x00FF) == 0x0009 || (key & 0xFF00) == 0x0F00)
  361.         first = !first;
  362.     else if ((key & 0x00FF) == 0x001B)
  363.         break;
  364.     else if ((key & 0x00FF) == 0x000D) {
  365.         if (first)
  366.         first = FALSE;
  367.         else if (ok)
  368.         break;
  369.         else
  370.         Beep();
  371.     }
  372.     else
  373.         Beep();
  374.     }
  375.     if (UseMouse)
  376.     ShowMousePointer();
  377.     return ((key & 0x00FF) == 0x000D);
  378. }
  379.  
  380.  
  381.  
  382. /*
  383.  */
  384.  
  385. char *GetTaggedLineDefFlag( BCINT linedefnum, BCINT flagndx)
  386. {
  387.     static char ldstr[ 9][ 50];
  388.     
  389.     if ((LineDefs[ linedefnum].flags & (0x01 << (flagndx - 1))) != 0)
  390.     strcpy( ldstr[ flagndx - 1], "\04 ");
  391.     else
  392.     strcpy( ldstr[ flagndx - 1], "  ");
  393.     strcat( ldstr[ flagndx - 1], GetLineDefFlagsLongName( 0x01 << (flagndx - 1)));
  394.     return ldstr[ flagndx - 1];
  395. }
  396.  
  397.  
  398.  
  399. /*
  400.    edit an object or a group of objects
  401.    */
  402.  
  403. void EditObjectsInfo( BCINT x0, BCINT y0, BCINT objtype, SelPtr obj) /* SWAP! */
  404. {
  405.     char  *menustr[ 30];
  406.     BCINT    dummy[ 30];
  407.     char   texname[ 9];
  408.     BCINT    n, val;
  409.     SelPtr cur, sdlist;
  410.     
  411.     ObjectsNeeded( objtype, 0);
  412.     if (obj == NULL)
  413.     return;
  414.     switch (objtype) {
  415.     case OBJ_THINGS:
  416.     for (n = 0; n < 6; n++)
  417.         menustr[ n] = (char*)GetMemory( 60);
  418.     sprintf( menustr[ 5], "Edit Thing #%d", obj->objnum);
  419.         sprintf( menustr[ 0], "Change Type          (Current: %s)", GetThingName( Things[ obj->objnum].type));
  420.         sprintf( menustr[ 1], "Change Angle         (Current: %s)", GetAngleName( Things[ obj->objnum].angle));
  421.     sprintf( menustr[ 2], "Change Flags         (Current: %s)", GetWhenName( Things[ obj->objnum].when));
  422.         sprintf( menustr[ 3], "Change X position    (Current: %d)", Things[ obj->objnum].xpos);
  423.         sprintf( menustr[ 4], "Change Y position    (Current: %d)", Things[ obj->objnum].ypos);
  424.     val = DisplayMenuArray( x0, y0, menustr[ 5], 5, NULL, menustr, dummy);
  425.     for (n = 0; n < 6; n++)
  426.         FreeMemory( menustr[ n]);
  427.     switch (val) {
  428.     case 1:
  429.     {
  430.         thing_class *c;
  431.         thing_type *t;
  432.         char *menuarr[30];
  433.         BCINT dummy[30];
  434.         int i;
  435.         Bool input_integer = FALSE;
  436.  
  437.         c = Thing_classes;
  438.         for(i = 0; (c && i < 30); i++) {
  439.             menuarr[i] = c->name;
  440.             c = c->next;
  441.         }
  442.         menuarr[i++] = "(Enter a Decimal Value)";
  443.             
  444.         val = -1;
  445.         val = DisplayMenuArray( x0 + 84, y0 + 78, "Choose a Thing type:",
  446.                     i, NULL, menuarr, dummy);
  447.  
  448.         if(val == i) {
  449.             input_integer = TRUE;
  450.             val = InputIntegerValue(x0 + 94, y0 + 88,
  451.                     0, 32767, 0);
  452.         }
  453.  
  454.         if(val > 0) {
  455.             if(!input_integer) {
  456.                 c = Thing_classes;
  457.                 while(--val)
  458.                     c = c->next;
  459.                     /* now c points to the class we are
  460.                        going to display a submenu for */
  461.  
  462.                 t = c->types;
  463.                 for(i = 0; (t && i < 30); i++) {
  464.                     menuarr[i] = t->name;
  465.                     t = t->next;
  466.                 }
  467.  
  468.                 if(i == 1) {
  469.                     val = c->types->type;
  470.                 }
  471.                 else {
  472.                     val = -1;
  473.                     val = DisplayMenuArray(x0 + 94, y0 + 88, "Choose a Thing type:",
  474.                             i, NULL, menuarr, dummy);
  475.                 }
  476.             }
  477.  
  478.             if (val > 0) {
  479.                 if(!input_integer) {
  480.                     t = c->types;
  481.                     while(--val)
  482.                         t = t->next;
  483.                     val = t->type;
  484.                 }
  485.  
  486.                 for (cur = obj; cur; cur = cur->next)
  487.                 Things[ cur->objnum].type = val;
  488.                 MadeChanges = TRUE;
  489.             }
  490.         }
  491.     }
  492.     break;
  493.     case 2:
  494.         switch (DisplayMenu( x0 + 42, y0 + 44, "Select Angle",
  495.                 "North",
  496.                 "North East",
  497.                 "East",
  498.                 "South East",
  499.                 "South",
  500.                 "South West",
  501.                 "West",
  502.                 "North West",
  503.                 NULL)) {
  504.         case 1:
  505.         for (cur = obj; cur; cur = cur->next)
  506.             Things[ cur->objnum].angle = 90;
  507.         MadeChanges = TRUE;
  508.         break;
  509.         case 2:
  510.         for (cur = obj; cur; cur = cur->next)
  511.             Things[ cur->objnum].angle = 45;
  512.         MadeChanges = TRUE;
  513.         break;
  514.         case 3:
  515.         for (cur = obj; cur; cur = cur->next)
  516.             Things[ cur->objnum].angle = 0;
  517.         MadeChanges = TRUE;
  518.         break;
  519.         case 4:
  520.         for (cur = obj; cur; cur = cur->next)
  521.             Things[ cur->objnum].angle = 315;
  522.         MadeChanges = TRUE;
  523.         break;
  524.         case 5:
  525.         for (cur = obj; cur; cur = cur->next)
  526.             Things[ cur->objnum].angle = 270;
  527.         MadeChanges = TRUE;
  528.         break;
  529.         case 6:
  530.         for (cur = obj; cur; cur = cur->next)
  531.             Things[ cur->objnum].angle = 225;
  532.         MadeChanges = TRUE;
  533.         break;
  534.         case 7:
  535.         for (cur = obj; cur; cur = cur->next)
  536.             Things[ cur->objnum].angle = 180;
  537.         MadeChanges = TRUE;
  538.         break;
  539.         case 8:
  540.         for (cur = obj; cur; cur = cur->next)
  541.             Things[ cur->objnum].angle = 135;
  542.         MadeChanges = TRUE;
  543.         break;
  544.         }
  545.         break;
  546.         
  547.     case 3:
  548.         val = DisplayMenu( x0 + 42, y0 + 54, "Choose the Difficulty Level(s)",
  549.                               "12     Easy",
  550.                               "  3    Medium",
  551.                               "123    Easy and Medium",
  552.                   "   45  Hard",
  553.                   "12 45  Easy and Hard",
  554.                   "  345  Medium and Hard",
  555.                   "12345  Easy, Medium and Hard",
  556.                   "Toggle Deaf bit",
  557.                   "Toggle Multi-player bit",
  558.                   "(Enter a Decimal Value)",
  559.                   NULL);
  560.         switch (val)
  561.         {
  562.         case 1:
  563.         case 2:
  564.         case 3:
  565.         case 4:
  566.         case 5:
  567.         case 6:
  568.         case 7:
  569.             for (cur = obj; cur; cur = cur->next)
  570.             Things[ cur->objnum].when = (Things[ cur->objnum].when & 0x18) | val;
  571.             MadeChanges = TRUE;
  572.             break;
  573.         case 8:
  574.             for (cur = obj; cur; cur = cur->next)
  575.             Things[ cur->objnum].when ^= 0x08;
  576.             MadeChanges = TRUE;
  577.             break;
  578.         case 9:
  579.             for (cur = obj; cur; cur = cur->next)
  580.             Things[ cur->objnum].when ^= 0x10;
  581.             MadeChanges = TRUE;
  582.             break;
  583.         case 10:
  584.             val = InputIntegerValue( x0 + 84, y0 + 158, 1, 31, Things[ obj->objnum].when);
  585.             if (val > 0) {
  586.             for (cur = obj; cur; cur = cur->next)
  587.                 Things[ cur->objnum].when = val;
  588.             MadeChanges = TRUE;
  589.             }
  590.             break;
  591.         }
  592.         break;
  593.         
  594.     case 4:
  595.         val = InputIntegerValue( x0 + 42, y0 + 64, MapMinX, MapMaxX, Things[ obj->objnum].xpos);
  596.         if (val >= MapMinX) {
  597.         n = val - Things[ obj->objnum].xpos;
  598.         for (cur = obj; cur; cur = cur->next)
  599.             Things[ cur->objnum].xpos += n;
  600.         MadeChanges = TRUE;
  601.         }
  602.         break;
  603.         
  604.     case 5:
  605.         val = InputIntegerValue( x0 + 42, y0 + 74, MapMinY, MapMaxY, Things[ obj->objnum].ypos);
  606.         if (val >= MapMinY) {
  607.         n = val - Things[ obj->objnum].ypos;
  608.         for (cur = obj; cur; cur = cur->next)
  609.             Things[ cur->objnum].ypos += n;
  610.         MadeChanges = TRUE;
  611.         }
  612.         break;
  613.     }
  614.     break;
  615.     
  616.     case OBJ_VERTEXES:
  617.     for (n = 0; n < 3; n++)
  618.         menustr[ n] = (char*)GetMemory( 60);
  619.     sprintf( menustr[ 2], "Edit Vertex #%d", obj->objnum);
  620.     sprintf( menustr[ 0], "Change X position (Current: %d)", Vertexes[ obj->objnum].x);
  621.     sprintf( menustr[ 1], "Change Y position (Current: %d)", Vertexes[ obj->objnum].y);
  622.     val = DisplayMenuArray( 0, 30, menustr[ 2], 2, NULL, menustr, dummy);
  623.     for (n = 0; n < 3; n++)
  624.         FreeMemory( menustr[ n]);
  625.     switch (val) {
  626.     case 1:
  627.         val = InputIntegerValue( x0 + 42, y0 + 34, min( MapMinX, -10000), max( MapMaxX, 10000), Vertexes[ obj->objnum].x);
  628.         if (val >= min( MapMinX, -10000)) {
  629.         n = val - Vertexes[ obj->objnum].x;
  630.         for (cur = obj; cur; cur = cur->next)
  631.             Vertexes[ cur->objnum].x += n;
  632.         MadeChanges = TRUE;
  633.         MadeMapChanges = TRUE;
  634.         }
  635.         break;
  636.         
  637.     case 2:
  638.         val = InputIntegerValue( x0 + 42, y0 + 44, min( MapMinY, -10000), max( MapMaxY, 10000), Vertexes[ obj->objnum].y);
  639.         if (val >= min( MapMinY, -10000)) {
  640.         n = val - Vertexes[ obj->objnum].y;
  641.         for (cur = obj; cur; cur = cur->next)
  642.             Vertexes[ cur->objnum].y += n;
  643.         MadeChanges = TRUE;
  644.         MadeMapChanges = TRUE;
  645.         }
  646.         break;
  647.     }         
  648.     break;
  649.     
  650.     case OBJ_LINEDEFS:
  651.     switch (DisplayMenu( x0, y0, "Choose the object to edit:",
  652.                 "Edit the LineDef",
  653.                 (LineDefs[ obj->objnum].sidedef1 >= 0) ? "Edit the 1st SideDef" : "Add a 1st SideDef",
  654.                 (LineDefs[ obj->objnum].sidedef2 >= 0) ? "Edit the 2nd SideDef" : "Add a 2nd SideDef",
  655.                 NULL)) {
  656.     case 1:
  657.         for (n = 0; n < 8; n++)
  658.         menustr[ n] = (char*)GetMemory( 60);
  659.         sprintf( menustr[ 7], "Edit LineDef #%d", obj->objnum);
  660.             sprintf( menustr[ 0], "Change Flags            (Current: %d)", LineDefs[ obj->objnum].flags);
  661.             sprintf( menustr[ 1], "Change Type             (Current: %d)", LineDefs[ obj->objnum].type);
  662.             sprintf( menustr[ 2], "Change Sector Tag       (Current: %d)", LineDefs[ obj->objnum].tag);
  663.         sprintf( menustr[ 3], "Change Starting Vertex  (Current: #%d)", LineDefs[ obj->objnum].start);
  664.             sprintf( menustr[ 4], "Change Ending Vertex    (Current: #%d)", LineDefs[ obj->objnum].end);
  665.         sprintf( menustr[ 5], "Change 1st SideDef ref. (Current: #%d)", LineDefs[ obj->objnum].sidedef1);
  666.         sprintf( menustr[ 6], "Change 2nd SideDef ref. (Current: #%d)", LineDefs[ obj->objnum].sidedef2);
  667.         val = DisplayMenuArray( x0 + 42, y0 + 34, menustr[ 7], 7, NULL, menustr, dummy);
  668.         for (n = 0; n < 8; n++)
  669.         FreeMemory( menustr[ n]);
  670.         switch (val) {
  671.         case 1:
  672.         do {
  673.             MadeChanges = FALSE;
  674.             val = DisplayMenu( x0 + 84, y0 + 68, "Toggle the flags:",
  675.                       GetTaggedLineDefFlag( obj->objnum, 1),
  676.                       GetTaggedLineDefFlag( obj->objnum, 2),
  677.                       GetTaggedLineDefFlag( obj->objnum, 3),
  678.                       GetTaggedLineDefFlag( obj->objnum, 4),
  679.                       GetTaggedLineDefFlag( obj->objnum, 5),
  680.                       GetTaggedLineDefFlag( obj->objnum, 6),
  681.                       GetTaggedLineDefFlag( obj->objnum, 7),
  682.                       GetTaggedLineDefFlag( obj->objnum, 8),
  683.                       GetTaggedLineDefFlag( obj->objnum, 9),
  684.                       "(Enter a Decimal Value)",
  685.                       NULL);
  686.             if (val >= 1 && val <= 9) {
  687.             for (cur = obj; cur; cur = cur->next)
  688.                 LineDefs[ cur->objnum].flags ^= 0x01 << (val - 1);
  689.             MadeChanges = TRUE;
  690.             }
  691.             else if (val == 10) {                                           
  692.             val = InputIntegerValue( x0 + 126, y0 + 182, 0, 511, LineDefs[ obj->objnum].flags);
  693.             if (val >= 0) {
  694.                 for (cur = obj; cur; cur = cur->next)
  695.                 LineDefs[ cur->objnum].flags = val;
  696.                 MadeChanges = TRUE;
  697.             }
  698.             }
  699.         } while (MadeChanges == TRUE);
  700.         break;
  701.         case 2:
  702.         {
  703.             ld_class *c;
  704.             ld_type *t;
  705.             char *menuarr[30];
  706.             BCINT dummy[30];
  707.             int i;
  708.             Bool input_integer = FALSE;
  709.  
  710.             c = Linedef_classes;
  711.             for(i = 0; (c && i < 30); i++) {
  712.                 menuarr[i] = c->name;
  713.                 c = c->next;
  714.             }
  715.             menuarr[i++] = "(Enter a Decimal Value)";
  716.             
  717.             val = DisplayMenuArray( x0 + 84, y0 + 78, "Choose a LineDef type:",
  718.                         i, NULL, menuarr, dummy);
  719.             if(val == 0)
  720.                 val = -1;
  721.  
  722.             if(i == val) {
  723.                 input_integer = TRUE;
  724.                 val = InputIntegerValue(x0 + 94, y0 + 88,
  725.                             0, 32767, 0);
  726.             }
  727.  
  728.             if(val > 0) {
  729.                 if(!input_integer) {
  730.                     c = Linedef_classes;
  731.                     while(--val)
  732.                     c = c->next;
  733.                         /* now c points to the class we are
  734.                            going to display a submenu for */
  735.  
  736.                 t = c->types;
  737.                 for(i = 0; (t && i < 30); t = t->next) {
  738.                     menuarr[i++] = t->longname;
  739.                 }
  740.  
  741.                 if(i == 1) {
  742.                     val = c->types->type;
  743.                 }
  744.                 else {
  745.                     val = DisplayMenuArray(x0 + 94, y0 + 88, "Choose a LineDef type:",
  746.                         i, NULL, menuarr, dummy);
  747.                     if(val == 0)
  748.                         val = -1;
  749.                 }
  750.             }
  751.  
  752.             if (val >= 0) {
  753.                 if(!input_integer) {
  754.                     t = c->types;
  755.                     while(--val)
  756.                     t = t->next;
  757.                     val = t->type;
  758.                 }
  759.  
  760.                     for (cur = obj; cur; cur = cur->next)
  761.                         LineDefs[ cur->objnum].type = val;
  762.                     MadeChanges = TRUE;
  763.             }
  764.             }
  765.         }
  766.         break;
  767.         case 3:
  768.         val = InputIntegerValue( x0 + 84, y0 + 88, 0, 255, LineDefs[ obj->objnum].tag);
  769.         if (val >= 0) {
  770.             for (cur = obj; cur; cur = cur->next)
  771.             LineDefs[ cur->objnum].tag = val;
  772.             MadeChanges = TRUE;
  773.         }
  774.         break;
  775.         case 4:
  776.         val = InputObjectXRef( x0 + 84, y0 + 98, OBJ_VERTEXES, FALSE, LineDefs[ obj->objnum].start);
  777.         if (val >= 0) {
  778.             for (cur = obj; cur; cur = cur->next)
  779.             LineDefs[ cur->objnum].start = val;
  780.             MadeChanges = TRUE;
  781.             MadeMapChanges = TRUE;
  782.         }
  783.         break;
  784.         case 5:
  785.         val = InputObjectXRef( x0 + 84, y0 + 108, OBJ_VERTEXES, FALSE, LineDefs[ obj->objnum].end);
  786.         if (val >= 0) {
  787.             for (cur = obj; cur; cur = cur->next)
  788.             LineDefs[ cur->objnum].end = val;
  789.             MadeChanges = TRUE;
  790.             MadeMapChanges = TRUE;
  791.         }
  792.         break;
  793.         case 6:
  794.         val = InputObjectXRef( x0 + 84, y0 + 118, OBJ_SIDEDEFS, TRUE, LineDefs[ obj->objnum].sidedef1);
  795.         if (val >= -1) {
  796.             for (cur = obj; cur; cur = cur->next)
  797.             LineDefs[ cur->objnum].sidedef1 = val;
  798.             MadeChanges = TRUE;
  799.             MadeMapChanges = TRUE;
  800.         }
  801.         break;
  802.         case 7:
  803.         val = InputObjectXRef( x0 + 84, y0 + 128, OBJ_SIDEDEFS, TRUE, LineDefs[ obj->objnum].sidedef2);
  804.         if (val >= -1) {
  805.             for (cur = obj; cur; cur = cur->next)
  806.             LineDefs[ cur->objnum].sidedef2 = val;
  807.             MadeChanges = TRUE;
  808.             MadeMapChanges = TRUE;
  809.         }
  810.         break;
  811.         }
  812.         break;
  813.         
  814.         /* edit or add the first SideDef */
  815.     case 2:
  816.         ObjectsNeeded( OBJ_LINEDEFS, OBJ_SIDEDEFS, 0);
  817.         if (LineDefs[ obj->objnum].sidedef1 >= 0) {
  818.         /* build a new selection list with the first SideDefs */
  819.         objtype = OBJ_SIDEDEFS;
  820.         sdlist = NULL;
  821.         for (cur = obj; cur; cur = cur->next)
  822.             if (LineDefs[ cur->objnum].sidedef1 >= 0)
  823.             SelectObject( &sdlist, LineDefs[ cur->objnum].sidedef1);
  824.         }
  825.         else {
  826.         /* add a new first SideDef */
  827.         for (cur = obj; cur; cur = cur->next)
  828.             if (LineDefs[ cur->objnum].sidedef1 == -1) {
  829.             InsertObject( OBJ_SIDEDEFS, -1, 0, 0);
  830.             LineDefs[ cur->objnum].sidedef1 = NumSideDefs - 1;
  831.             }
  832.         break;
  833.         }
  834.         /* no break here */
  835.         
  836.         /* edit or add the second SideDef */
  837.     case 3:
  838.         if (objtype != OBJ_SIDEDEFS) {
  839.         if (LineDefs[ obj->objnum].sidedef2 >= 0) {
  840.             /* build a new selection list with the second (or first) SideDefs */
  841.             objtype = OBJ_SIDEDEFS;
  842.             sdlist = NULL;
  843.             for (cur = obj; cur; cur = cur->next)
  844.             if (LineDefs[ cur->objnum].sidedef2 >= 0)
  845.                 SelectObject( &sdlist, LineDefs[ cur->objnum].sidedef2);
  846.             else if (LineDefs[ cur->objnum].sidedef1 >= 0)
  847.                 SelectObject( &sdlist, LineDefs[ cur->objnum].sidedef1);
  848.         }
  849.         else {
  850.             /* add a new second (or first) SideDef */
  851.             for (cur = obj; cur; cur = cur->next)
  852.             if (LineDefs[ cur->objnum].sidedef1 == -1) {
  853.                 InsertObject( OBJ_SIDEDEFS, -1, 0, 0);
  854.                 ObjectsNeeded( OBJ_LINEDEFS, 0);
  855.                 LineDefs[ cur->objnum].sidedef1 = NumSideDefs - 1;
  856.             }
  857.             else if (LineDefs[ cur->objnum].sidedef2 == -1) {
  858.                 n = LineDefs[ cur->objnum].sidedef1;
  859.                 InsertObject( OBJ_SIDEDEFS, -1, 0, 0);
  860.                 strncpy( SideDefs[ NumSideDefs - 1].tex3, "-", 8);
  861.                 strncpy( SideDefs[ n].tex3, "-", 8);
  862.                 ObjectsNeeded( OBJ_LINEDEFS, 0);
  863.                 LineDefs[ cur->objnum].sidedef2 = NumSideDefs - 1;
  864.                 LineDefs[ cur->objnum].flags = 4;
  865.             }
  866.             break;
  867.         }
  868.         }
  869.         ObjectsNeeded( OBJ_SIDEDEFS, 0);
  870.         for (n = 0; n < 7; n++)
  871.         menustr[ n] = (char*)GetMemory( 60);
  872.         sprintf( menustr[ 6], "Edit SideDef #%d", sdlist->objnum);
  873.         texname[ 8] = '\0';
  874.         strncpy( texname, SideDefs[ sdlist->objnum].tex3, 8);
  875.         sprintf( menustr[ 0], "Change Normal Texture   (Current: %s)", texname);
  876.         strncpy( texname, SideDefs[ sdlist->objnum].tex1, 8);
  877.             sprintf( menustr[ 1], "Change Upper Texture    (Current: %s)", texname);
  878.         strncpy( texname, SideDefs[ sdlist->objnum].tex2, 8);
  879.             sprintf( menustr[ 2], "Change Lower Texture    (Current: %s)", texname);
  880.         sprintf( menustr[ 3], "Change Texture X offset (Current: %d)", SideDefs[ sdlist->objnum].xoff);
  881.         sprintf( menustr[ 4], "Change Texture Y offset (Current: %d)", SideDefs[ sdlist->objnum].yoff);
  882.             sprintf( menustr[ 5], "Change Sector ref.      (Current: #%d)", SideDefs[ sdlist->objnum].sector);
  883.         val = DisplayMenuArray( x0 + 42, y0 + 54, menustr[ 6], 6, NULL, menustr, dummy);
  884.         for (n = 0; n < 7; n++)
  885.         FreeMemory( menustr[ n]);
  886.         switch (val) {
  887.         case 1:
  888.         strncpy( texname, SideDefs[ sdlist->objnum].tex3, 8);
  889.         ObjectsNeeded( 0);
  890.         ChooseWallTexture( x0 + 84, y0 + 88, "Choose a wall texture", NumWTexture, WTexture, texname);
  891.         ObjectsNeeded( OBJ_SIDEDEFS, 0);
  892.         if (strlen(texname) > 0) {
  893.             for (cur = sdlist; cur; cur = cur->next)
  894.             if (cur->objnum >= 0)
  895.                 strncpy( SideDefs[ cur->objnum].tex3, texname, 8);
  896.             MadeChanges = TRUE;
  897.         }
  898.         break;
  899.         case 2:
  900.         strncpy( texname, SideDefs[ sdlist->objnum].tex1, 8);
  901.         ObjectsNeeded( 0);
  902.         ChooseWallTexture( x0 + 84, y0 + 98, "Choose a wall texture", NumWTexture, WTexture, texname);
  903.         ObjectsNeeded( OBJ_SIDEDEFS, 0);
  904.         if (strlen(texname) > 0) {
  905.             for (cur = sdlist; cur; cur = cur->next)
  906.             if (cur->objnum >= 0)
  907.                 strncpy( SideDefs[ cur->objnum].tex1, texname, 8);
  908.             MadeChanges = TRUE;
  909.         }
  910.         break;
  911.         case 3:
  912.         strncpy( texname, SideDefs[ sdlist->objnum].tex2, 8);
  913.         ObjectsNeeded( 0);
  914.         ChooseWallTexture( x0 + 84, y0 + 108, "Choose a wall texture", NumWTexture, WTexture, texname);
  915.         ObjectsNeeded( OBJ_SIDEDEFS, 0);
  916.         if (strlen(texname) > 0) {
  917.             for (cur = sdlist; cur; cur = cur->next)
  918.             if (cur->objnum >= 0)
  919.                 strncpy( SideDefs[ cur->objnum].tex2, texname, 8);
  920.             MadeChanges = TRUE;
  921.         }
  922.         break;
  923.         case 4:
  924.         val = InputIntegerValue( x0 + 84, y0 + 118, -255, 255, SideDefs[ sdlist->objnum].xoff);
  925.         if (val >= -255) {
  926.             for (cur = sdlist; cur; cur = cur->next)
  927.             if (cur->objnum >= 0)
  928.                 SideDefs[ cur->objnum].xoff = val;
  929.             MadeChanges = TRUE;
  930.         }
  931.         break;
  932.         case 5:
  933.         val = InputIntegerValue( x0 + 84, y0 + 128, -255, 255, SideDefs[ sdlist->objnum].yoff);
  934.         if (val >= -255) {
  935.             for (cur = sdlist; cur; cur = cur->next)
  936.             if (cur->objnum >= 0)
  937.                 SideDefs[ cur->objnum].yoff = val;
  938.             MadeChanges = TRUE;
  939.         }
  940.         break;
  941.         case 6:
  942.         val = InputObjectXRef( x0 + 84, y0 + 138, OBJ_SECTORS, FALSE, SideDefs[ sdlist->objnum].sector);
  943.         if (val >= 0) {
  944.             for (cur = sdlist; cur; cur = cur->next)
  945.             if (cur->objnum >= 0)
  946.                 SideDefs[ cur->objnum].sector = val;
  947.             MadeChanges = TRUE;
  948.         }
  949.         break;
  950.         }
  951.         ForgetSelection( &sdlist);
  952.         break;
  953.         
  954.     }
  955.     break;
  956.     
  957.     case OBJ_SECTORS:
  958.     for (n = 0; n < 8; n++)
  959.         menustr[ n] = (char*)GetMemory( 60);
  960.     sprintf( menustr[ 7], "Edit Sector #%d", obj->objnum);
  961.         sprintf( menustr[ 0], "Change Floor Height     (Current: %d)", Sectors[ obj->objnum].floorh);
  962.     sprintf( menustr[ 1], "Change Ceiling Height   (Current: %d)", Sectors[ obj->objnum].ceilh);
  963.     texname[ 8] = '\0';
  964.     strncpy( texname, Sectors[ obj->objnum].floort, 8);
  965.         sprintf( menustr[ 2], "Change Floor Texture    (Current: %s)", texname);
  966.     strncpy( texname, Sectors[ obj->objnum].ceilt, 8);
  967.     sprintf( menustr[ 3], "Change Ceiling Texture  (Current: %s)", texname);
  968.         sprintf( menustr[ 4], "Change Light Level      (Current: %d)", Sectors[ obj->objnum].light);
  969.         sprintf( menustr[ 5], "Change Type             (Current: %d)", Sectors[ obj->objnum].special);
  970.         sprintf( menustr[ 6], "Change LineDef Tag      (Current: %d)", Sectors[ obj->objnum].tag);
  971.     val = DisplayMenuArray( x0, y0, menustr[ 7], 7, NULL, menustr, dummy);
  972.     for (n = 0; n < 8; n++)
  973.         FreeMemory( menustr[ n]);
  974.     switch (val) {
  975.     case 1:
  976.         val = InputIntegerValue( x0 + 42, y0 + 34, -16384, 16383, Sectors[ obj->objnum].floorh);
  977.         if (val >= -16384) {
  978.         for (cur = obj; cur; cur = cur->next)
  979.             Sectors[ cur->objnum].floorh = val;
  980.         MadeChanges = TRUE;
  981.         }
  982.         break;
  983.     case 2:
  984.         val = InputIntegerValue( x0 + 42, y0 + 44, -16384, 16383, Sectors[ obj->objnum].ceilh);
  985.         if (val >= -16384) {
  986.         for (cur = obj; cur; cur = cur->next)
  987.             Sectors[ cur->objnum].ceilh = val;
  988.         MadeChanges = TRUE;
  989.         }
  990.         break;
  991.     case 3:
  992.         strncpy( texname, Sectors[ obj->objnum].floort, 8);
  993.         ObjectsNeeded( 0);
  994.         ChooseFloorTexture( x0 + 42, y0 + 54, "Choose a Floor Texture", NumFTexture, FTexture, texname);
  995.         ObjectsNeeded( OBJ_SECTORS, 0);
  996.         if (strlen(texname) > 0) {
  997.         for (cur = obj; cur; cur = cur->next)
  998.             strncpy( Sectors[ cur->objnum].floort, texname, 8);
  999.         MadeChanges = TRUE;
  1000.         }
  1001.         break;
  1002.     case 4:
  1003.         strncpy( texname, Sectors[ obj->objnum].ceilt, 8);
  1004.         ObjectsNeeded( 0);
  1005.         ChooseFloorTexture( x0 + 42, y0 + 64, "Choose a Ceiling Texture", NumFTexture, FTexture, texname);
  1006.         ObjectsNeeded( OBJ_SECTORS, 0);
  1007.         if (strlen(texname) > 0) {
  1008.         for (cur = obj; cur; cur = cur->next)
  1009.             strncpy( Sectors[ cur->objnum].ceilt, texname, 8);
  1010.         MadeChanges = TRUE;
  1011.         }
  1012.         break;
  1013.     case 5:
  1014.         val = InputIntegerValue( x0 + 42, y0 + 74, 0, 255, Sectors[ obj->objnum].light);
  1015.         if (val >= 0) {
  1016.         for (cur = obj; cur; cur = cur->next)
  1017.             Sectors[ cur->objnum].light = val;
  1018.         MadeChanges = TRUE;
  1019.         }
  1020.         break;
  1021.     case 6:
  1022.     /* Choose a sector type */
  1023.     {
  1024.         sector_class *c;
  1025.         sector_type *t;
  1026.         char *menuarr[30];
  1027.         BCINT dummy[30];
  1028.         int i;
  1029.         Bool input_integer = FALSE;
  1030.  
  1031.         c = Sector_classes;
  1032.         for(i = 0; (c && i < 29); i++) {
  1033.             menuarr[i] = c->name;
  1034.             c = c->next;
  1035.         }
  1036.         menuarr[i++] = "(Enter a Decimal Value)";
  1037.             
  1038.         val = -1;
  1039.         val = DisplayMenuArray( x0 + 84, y0 + 78, "Choose a Sector type:",
  1040.                     i, NULL, menuarr, dummy);
  1041.  
  1042.         if(val == i) {
  1043.             input_integer = TRUE;
  1044.             val = InputIntegerValue(x0 + 94, y0 + 88, 0, 32767, 0);
  1045.         }
  1046.  
  1047.         if(val > 0) {
  1048.             if(!input_integer) {
  1049.                 c = Sector_classes;
  1050.                 while(--val)
  1051.                     c = c->next;
  1052.                     /* now c points to the class we are
  1053.                        going to display a submenu for */
  1054.     
  1055.                 t = c->types;
  1056.                 for(i = 0; (t && i < 30); i++) {
  1057.                     menuarr[i] = t->longname;
  1058.                     t = t->next;
  1059.                 }
  1060.  
  1061.                 if(i == 1) {
  1062.                     val = c->types->type;
  1063.                 }
  1064.                 else {
  1065.                     val = -1;
  1066.                     val = DisplayMenuArray(x0 + 94, y0 + 88, "Choose a Sector type:",
  1067.                         i, NULL, menuarr, dummy);
  1068.                 }
  1069.             }
  1070.  
  1071.             if (val >= 0) {
  1072.                 if(!input_integer) {
  1073.                     t = c->types;
  1074.                     while(--val)
  1075.                         t = t->next;
  1076.                     val = t->type;
  1077.                 }
  1078.  
  1079.                 for (cur = obj; cur; cur = cur->next)
  1080.                 Sectors[ cur->objnum].special = val;
  1081.                 MadeChanges = TRUE;
  1082.             }
  1083.         }
  1084.     }
  1085.     break;
  1086.     case 7:
  1087.         val = InputIntegerValue( x0 + 42, y0 + 94, 0, 999, Sectors[ obj->objnum].tag);
  1088.         if (val >= 0) {
  1089.         for (cur = obj; cur; cur = cur->next)
  1090.             Sectors[ cur->objnum].tag = val;
  1091.         MadeChanges = TRUE;
  1092.         }
  1093.         break;
  1094.     }
  1095.     break;
  1096.     }
  1097. }
  1098.  
  1099.  
  1100.  
  1101. /*
  1102.    Yuck!  Dirty piece of code...
  1103.    */
  1104.  
  1105. Bool Input2Numbers( BCINT x0, BCINT y0, char *name1, char *name2, BCINT v1max, BCINT v2max, BCINT *v1, BCINT *v2)
  1106. {
  1107.     BCINT  key;
  1108.     BCINT  maxlen, first;
  1109.     Bool ok;
  1110.     char prompt[ 80];
  1111.     
  1112.     if (UseMouse)
  1113.     HideMousePointer();
  1114.     sprintf( prompt, "Give the %s and %s for the object:", name1, name2);
  1115.     maxlen = strlen( prompt);
  1116.     if (x0 < 0)
  1117.     x0 = (ScrMaxX - 25 - 8 * maxlen) / 2;
  1118.     if (y0 < 0)
  1119.     y0 = (ScrMaxY - 75) / 2;
  1120.     DrawScreenBox3D( x0, y0, x0 + 25 + 8 * maxlen, y0 + 75);
  1121.     DrawScreenText( x0 + 10, y0 + 26, name1);
  1122.     DrawScreenText( x0 + 180, y0 + 26, name2);
  1123.     DrawScreenText( x0 + 10, y0 + 58, "(0-%d)", v1max);
  1124.     DrawScreenText( x0 + 180, y0 + 58, "(0-%d)", v2max);
  1125.     SetColor( WHITE);
  1126.     DrawScreenText( x0 + 10, y0 + 8, prompt);
  1127.     first = TRUE;
  1128.     key = 0;
  1129.     for (;;) {
  1130.     ok = TRUE;
  1131.     DrawScreenBox3D( x0 + 10, y0 + 38, x0 + 71, y0 + 51);
  1132.     if (*v1 < 0 || *v1 > v1max) {
  1133.         SetColor( DARKGRAY);
  1134.         ok = FALSE;
  1135.     }
  1136.     DrawScreenText( x0 + 14, y0 + 41, "%d", *v1);
  1137.     DrawScreenBox3D( x0 + 180, y0 + 38, x0 + 241, y0 + 51);
  1138.     if (*v2 < 0 || *v2 > v2max) {
  1139.         SetColor( DARKGRAY);
  1140.         ok = FALSE;
  1141.     }
  1142.     DrawScreenText( x0 + 184, y0 + 41, "%d", *v2);
  1143.     if (first)
  1144.         key = InputInteger( x0 + 10, y0 + 38, v1, 0, v1max);
  1145.     else
  1146.         key = InputInteger( x0 + 180, y0 + 38, v2, 0, v2max);
  1147.     if ((key & 0xFF00) == 0x4B00 || (key & 0xFF00) == 0x4D00 || (key & 0x00FF) == 0x0009 || (key & 0xFF00) == 0x0F00)
  1148.         first = !first;
  1149.     else if ((key & 0x00FF) == 0x001B)
  1150.         break;
  1151.     else if ((key & 0x00FF) == 0x000D) {
  1152.         if (first)
  1153.         first = FALSE;
  1154.         else if (ok)
  1155.         break;
  1156.         else
  1157.         Beep();
  1158.     }
  1159.     else
  1160.         Beep();
  1161.     }
  1162.     if (UseMouse)
  1163.     ShowMousePointer();
  1164.     return ((key & 0x00FF) == 0x000D);
  1165. }
  1166.  
  1167.  
  1168.  
  1169. /*
  1170.    display number of objects, etc.
  1171.    */
  1172.  
  1173. void Statistics( BCINT x0, BCINT y0)
  1174. {
  1175.     if (x0 < 0)
  1176.     x0 = (ScrMaxX - 270) / 2;
  1177.     if (y0 < 0)
  1178.     y0 = (ScrMaxY - 100) / 2;
  1179.     if (UseMouse)
  1180.     HideMousePointer();
  1181.     DrawScreenBox3D( x0, y0, x0 + 270, y0 + 100);
  1182.     SetColor( WHITE);
  1183.     DrawScreenText( x0 + 10, y0 + 5, "Statistics");
  1184.     if (Things == NULL)
  1185.     SetColor( DARKGRAY);
  1186.     else
  1187.     SetColor( BLACK);
  1188.     DrawScreenText( -1, y0 + 25, "Number of Things:   %4d (%lu K)",
  1189.            NumThings, ((unsigned long) NumThings * sizeof( struct Thing) + 512L) / 1024L);
  1190.     if (Vertexes == NULL)
  1191.     SetColor( DARKGRAY);
  1192.     else
  1193.     SetColor( BLACK);
  1194.     DrawScreenText( -1, -1, "Number of Vertices: %4d (%lu K)",
  1195.            NumVertexes, ((unsigned long) NumVertexes * sizeof( struct Vertex) + 512L) / 1024L);
  1196.     if (LineDefs == NULL)
  1197.     SetColor( DARKGRAY);
  1198.     else
  1199.     SetColor( BLACK);
  1200.     DrawScreenText( -1, -1, "Number of LineDefs: %4d (%lu K)",
  1201.            NumLineDefs, ((unsigned long) NumLineDefs * sizeof( struct LineDef) + 512L) / 1024L);
  1202.     if (SideDefs == NULL)
  1203.     SetColor( DARKGRAY);
  1204.     else
  1205.     SetColor( BLACK);
  1206.     DrawScreenText( -1, -1, "Number of SideDefs: %4d (%lu K)",
  1207.            NumSideDefs, ((unsigned long) NumSideDefs * sizeof( struct SideDef) + 512L) / 1024L);
  1208.     if (Sectors == NULL)
  1209.     SetColor( DARKGRAY);
  1210.     else
  1211.     SetColor( BLACK);
  1212.     DrawScreenText( -1, -1, "Number of Sectors:  %4d (%lu K)",
  1213.            NumSectors, ((unsigned long) NumSectors * sizeof( struct Sector) + 512L) / 1024L);
  1214.     SetColor( YELLOW);
  1215.     DrawScreenText( x0 + 10, y0 + 85, "Press any key to continue...");
  1216.     bioskey( 0);
  1217.     if (UseMouse)
  1218.     ShowMousePointer();
  1219. }
  1220.  
  1221.  
  1222.  
  1223. /*
  1224.    display a message while the user is waiting...
  1225.    */
  1226.  
  1227. void CheckingObjects( BCINT x0, BCINT y0)
  1228. {
  1229.     if (UseMouse)
  1230.     HideMousePointer();
  1231.     if (x0 < 0)
  1232.     x0 = (ScrMaxX - 172) / 2;
  1233.     if (y0 < 0)
  1234.     y0 = (ScrMaxY - 30) / 2;
  1235.     DrawScreenBox3D( x0, y0, x0 + 172, y0 + 30);
  1236.     DrawScreenText( x0 + 10, y0 + 5, "Checking objects...");
  1237.     DrawScreenText( x0 + 10, y0 + 15, "   Please wait");
  1238.     if (UseMouse)
  1239.     ShowMousePointer();
  1240. }
  1241.  
  1242.  
  1243. /*
  1244.    display a message, then ask if the check should continue (prompt2 may be NULL)
  1245.    */
  1246.  
  1247. Bool CheckFailed( BCINT x0, BCINT y0, char *prompt1, char *prompt2, Bool fatal)
  1248. {
  1249.     BCINT key;
  1250.     BCINT maxlen;
  1251.     
  1252.     if (UseMouse)
  1253.     HideMousePointer();
  1254.     if (fatal == TRUE)
  1255.     maxlen = 44;
  1256.     else
  1257.     maxlen = 27;
  1258.     if (strlen( prompt1) > maxlen)
  1259.     maxlen = strlen( prompt1);
  1260.     if (prompt2 != NULL && strlen( prompt2) > maxlen)
  1261.     maxlen = strlen( prompt2);
  1262.     if (x0 < 0)
  1263.     x0 = (ScrMaxX - 22 - 8 * maxlen) / 2;
  1264.     if (y0 < 0)
  1265.     y0 = (ScrMaxY - (prompt2 ? 73 : 63)) / 2;
  1266.     DrawScreenBox3D( x0, y0, x0 + 22 + 8 * maxlen, y0 + (prompt2 ? 73 : 63));
  1267.     SetColor( RED);
  1268.     DrawScreenText( x0 + 10, y0 + 8, "Verification failed:");
  1269.     Beep();
  1270.     SetColor( WHITE);
  1271.     DrawScreenText( x0 + 10, y0 + 18, prompt1);
  1272.     LogMessage( "\t%s\n", prompt1);
  1273.     if (prompt2 != NULL) {
  1274.     DrawScreenText( x0 + 10, y0 + 28, prompt2);
  1275.     LogMessage( "\t%s\n", prompt2);
  1276.     }
  1277.     if (fatal == TRUE) {
  1278.     DrawScreenText( x0 + 10, y0 + (prompt2 ? 38 : 28), "The game will crash if you play with this level.");
  1279.     SetColor( YELLOW);
  1280.     DrawScreenText( x0 + 10, y0 + (prompt2 ? 58 : 48), "Press any key to see the object");
  1281.     LogMessage( "\n");
  1282.     }
  1283.     else {
  1284.     SetColor( YELLOW);
  1285.     DrawScreenText( x0 + 10, y0 + (prompt2 ? 48 : 38), "Press Esc to see the object,");
  1286.     DrawScreenText( x0 + 10, y0 + (prompt2 ? 58 : 48), "or any other key to continue");
  1287.     }
  1288.     key = bioskey( 0);
  1289.     if ((key & 0x00FF) != 0x001B) {
  1290.     DrawScreenBox3D( x0, y0, x0 + 22 + 8 * maxlen, y0 + (prompt2 ? 73 : 63));
  1291.     DrawScreenText( x0 + 10 + 4 * (maxlen - 26), y0 + 28, "Verifying other objects...");
  1292.     }
  1293.     if (UseMouse)
  1294.     ShowMousePointer();
  1295.     
  1296.     return ((key & 0x00FF) == 0x001B);
  1297. }
  1298.  
  1299.  
  1300.  
  1301. /*
  1302.    check if all sectors are closed
  1303.    */
  1304.  
  1305. void CheckSectors( void) /* SWAP! */
  1306. {
  1307.     BCINT      s, n, sd;
  1308.     char huge *ends;
  1309.     char       msg1[ 80], msg2[80];
  1310.     
  1311.     CheckingObjects( -1, -1);
  1312.     LogMessage( "\nVerifying Sectors...\n");
  1313.     ObjectsNeeded( OBJ_LINEDEFS, OBJ_SIDEDEFS, 0);
  1314.     ends = GetFarMemory( NumVertexes * sizeof( char));
  1315.     for (s = 0; s < NumSectors; s++) {
  1316.     /* clear the "ends" array */
  1317.     for (n = 0; n < NumVertexes; n++)
  1318.         ends[ n] = 0;
  1319.     /* for each SideDef bound to the Sector, store a "1" in the "ends" */
  1320.     /* array for its starting Vertex, and a "2" for its ending Vertex  */
  1321.     for (n = 0; n < NumLineDefs; n++) {
  1322.         sd = LineDefs[ n].sidedef1;
  1323.         if (sd >= 0 && SideDefs[ sd].sector == s) {
  1324.         ends[ LineDefs[ n].start] |= 1;
  1325.         ends[ LineDefs[ n].end] |= 2;
  1326.         }
  1327.         sd = LineDefs[ n].sidedef2;
  1328.         if (sd >= 0 && SideDefs[ sd].sector == s) {
  1329.         ends[ LineDefs[ n].end] |= 1;
  1330.         ends[ LineDefs[ n].start] |= 2;
  1331.         }
  1332.     }
  1333.     /* every entry in the "ends" array should be "0" or "3" */
  1334.     for (n = 0; n < NumVertexes; n++) {
  1335.         if (ends[ n] == 1) {
  1336.         sprintf( msg1, "Sector #%d is not closed!", s);
  1337.         sprintf( msg2, "There is no SideDef ending at Vertex #%d", n);
  1338.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1339.             GoToObject( OBJ_VERTEXES, n);
  1340.             return;
  1341.         }
  1342.         }
  1343.         if (ends[ n] == 2) {
  1344.         sprintf( msg1, "Sector #%d is not closed!", s);
  1345.         sprintf( msg2, "There is no SideDef starting at Vertex #%d", n);
  1346.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1347.             GoToObject( OBJ_VERTEXES, n);
  1348.             return;
  1349.         }
  1350.         }
  1351.     }
  1352.     }
  1353.     FreeFarMemory( ends);
  1354.     
  1355.     /*
  1356.        Note from RQ:
  1357.        This is a very simple idea, but it works!  The first test (above)
  1358.        checks that all Sectors are closed.  But if a closed set of LineDefs
  1359.        is moved out of a Sector and has all its "external" SideDefs pointing
  1360.        to that Sector instead of the new one, then we need a second test.
  1361.        That's why I check if the SideDefs facing each other are bound to
  1362.        the same Sector.
  1363.        
  1364.        Other note from RQ:
  1365.        Nowadays, what makes the power of a good editor is its automatic tests.
  1366.        So, if you are writing another Doom editor, you will probably want
  1367.        to do the same kind of tests in your program.  Fine, but if you use
  1368.        these ideas, don't forget to credit DEU...  Just a reminder... :-)
  1369.        */
  1370.     
  1371.     /* now check if all SideDefs are facing a SideDef with the same Sector number */
  1372.     for (n = 0; n < NumLineDefs; n++) {
  1373.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  1374.     sd = LineDefs[ n].sidedef1;
  1375.     if (sd >= 0) {
  1376.         s = GetOppositeSector( n, TRUE);
  1377.         ObjectsNeeded( OBJ_SIDEDEFS, 0);
  1378.         if (s < 0 || SideDefs[ sd].sector != s) {
  1379.         if (s < 0) {
  1380.             sprintf( msg1, "Sector #%d is not closed!", SideDefs[ sd].sector);
  1381.             sprintf( msg2, "Check LineDef #%d (first SideDef: #%d)", n, sd);
  1382.         }
  1383.         else {
  1384.             sprintf( msg1, "Sectors #%d and #%d are not closed!", SideDefs[ sd].sector, s);
  1385.             sprintf( msg2, "Check LineDef #%d (first SideDef: #%d) and the one facing it", n, sd);
  1386.         }
  1387.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1388.             GoToObject( OBJ_LINEDEFS, n);
  1389.             return;
  1390.         }
  1391.         }
  1392.     }
  1393.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  1394.     sd = LineDefs[ n].sidedef2;
  1395.     if (sd >= 0) {
  1396.         s = GetOppositeSector( n, FALSE);
  1397.         ObjectsNeeded( OBJ_SIDEDEFS, 0);
  1398.         if (s < 0 || SideDefs[ sd].sector != s) {
  1399.         if (s < 0) {
  1400.             sprintf( msg1, "Sector #%d is not closed!", SideDefs[ sd].sector);
  1401.             sprintf( msg2, "Check LineDef #%d (second SideDef: #%d)", n, sd);
  1402.         }
  1403.         else {
  1404.             sprintf( msg1, "Sectors #%d and #%d are not closed!", SideDefs[ sd].sector, s);
  1405.             sprintf( msg2, "Check LineDef #%d (second SideDef: #%d) and the one facing it", n, sd);
  1406.         }
  1407.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1408.             GoToObject( OBJ_LINEDEFS, n);
  1409.             return;
  1410.         }
  1411.         }
  1412.     }
  1413.     }
  1414. }
  1415.  
  1416.  
  1417.  
  1418. /*
  1419.    check cross-references and delete unused objects
  1420.    */      
  1421.  
  1422. void CheckCrossReferences( void) /* SWAP! */
  1423. {
  1424.     char   msg[ 80];
  1425.     BCINT    n, m;
  1426.     SelPtr cur;
  1427.     
  1428.     CheckingObjects( -1, -1);
  1429.     LogMessage( "\nVerifying cross-references...\n");
  1430.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  1431.     for (n = 0; n < NumLineDefs; n++) {
  1432.     /* check for missing first SideDefs */
  1433.     if (LineDefs[ n].sidedef1 < 0) {
  1434.         sprintf( msg, "ERROR: LineDef #%d has no first SideDef!", n);
  1435.         CheckFailed( -1, -1, msg, NULL, TRUE);
  1436.         GoToObject( OBJ_LINEDEFS, n);
  1437.         return;
  1438.     }
  1439.     /* check for SideDefs used twice in the same LineDef */
  1440.     if (LineDefs[ n].sidedef1 == LineDefs[ n].sidedef2) {
  1441.         sprintf( msg, "ERROR: LineDef #%d uses the same SideDef twice (#%d)", n, LineDefs[ n].sidedef1);
  1442.         CheckFailed( -1, -1, msg, NULL, TRUE);
  1443.         GoToObject( OBJ_LINEDEFS, n);
  1444.         return;
  1445.     }
  1446.     /* check for Vertices used twice in the same LineDef */
  1447.     if (LineDefs[ n].start == LineDefs[ n].end) {
  1448.         sprintf( msg, "ERROR: LineDef #%d uses the same Vertex twice (#%d)", n, LineDefs[ n].start);
  1449.         CheckFailed( -1, -1, msg, NULL, TRUE);
  1450.         GoToObject( OBJ_LINEDEFS, n);
  1451.         return;
  1452.     }
  1453.     }
  1454.     
  1455.     /* check if there aren't two LineDefs between the same Vertices */
  1456.     cur = NULL;
  1457.     for (n = NumLineDefs - 1; n >= 1; n--) {
  1458.     for (m = n - 1; m >= 0; m--)
  1459.         if ((LineDefs[ n].start == LineDefs[ m].start && LineDefs[ n].end == LineDefs[ m].end)
  1460.         || (LineDefs[ n].start == LineDefs[ m].end && LineDefs[ n].end == LineDefs[ m].start)) {
  1461.         SelectObject( &cur, n);
  1462.         break;
  1463.         }
  1464.     }
  1465.     if (cur && (Expert || Confirm(-1, -1, "There are multiple LineDefs between the same Vertices", "Do you want to delete the redundant LineDefs?")))
  1466.     DeleteObjects( OBJ_LINEDEFS, &cur);
  1467.     else
  1468.     ForgetSelection( &cur);
  1469.     
  1470.     CheckingObjects( -1, -1);
  1471.     /* check for invalid flags in the LineDefs */
  1472.     for (n = 0; n < NumLineDefs; n++)
  1473.     if ((LineDefs[ n].flags & 0x01) == 0 && LineDefs[ n].sidedef2 < 0)
  1474.         SelectObject( &cur, n);
  1475.     if (cur && (Expert || Confirm(-1, -1, "Some LineDefs have only one side but their Im bit is not set", "Do you want to set the 'Impassible' flag?"))) {
  1476.     while (cur) {
  1477.         LineDefs[ cur->objnum].flags |= 0x01;
  1478.         UnSelectObject( &cur, cur->objnum);
  1479.     }
  1480.     }
  1481.     else
  1482.     ForgetSelection( &cur);
  1483.     
  1484.     CheckingObjects( -1, -1);
  1485.     for (n = 0; n < NumLineDefs; n++)
  1486.     if ((LineDefs[ n].flags & 0x04) != 0 && LineDefs[ n].sidedef2 < 0)
  1487.         SelectObject( &cur, n);
  1488.     if (cur && (Expert || Confirm(-1, -1, "Some LineDefs have only one side but their 2S bit is set", "Do you want to clear the 'two-sided' flag?"))) {
  1489.     while (cur) {
  1490.         LineDefs[ cur->objnum].flags &= ~0x04;
  1491.         UnSelectObject( &cur, cur->objnum);
  1492.     }
  1493.     }
  1494.     else
  1495.     ForgetSelection( &cur);
  1496.     
  1497.     CheckingObjects( -1, -1);
  1498.     for (n = 0; n < NumLineDefs; n++)
  1499.     if ((LineDefs[ n].flags & 0x04) == 0 && LineDefs[ n].sidedef2 >= 0)
  1500.         SelectObject( &cur, n);
  1501.     if (cur && (Expert || Confirm(-1, -1, "Some LineDefs have two sides but their 2S bit is not set", "Do you want to set the 'two-sided' flag?"))) {
  1502.     while (cur) {
  1503.         LineDefs[ cur->objnum].flags |= 0x04;
  1504.         UnSelectObject( &cur, cur->objnum);
  1505.     }
  1506.     }
  1507.     else
  1508.     ForgetSelection( &cur);
  1509.     
  1510.     CheckingObjects( -1, -1);
  1511.     /* select all Vertices */
  1512.     for (n = 0; n < NumVertexes; n++)
  1513.     SelectObject( &cur, n);
  1514.     /* unselect Vertices used in a LineDef */
  1515.     for (n = 0; n < NumLineDefs; n++) {
  1516.     m = LineDefs[ n].start;
  1517.     if (cur && m >= 0)
  1518.         UnSelectObject( &cur, m);
  1519.     m = LineDefs[ n].end;
  1520.     if (cur && m >= 0)
  1521.         UnSelectObject( &cur, m);
  1522.     continue;
  1523.     }
  1524.     /* check if there are any Vertices left */
  1525.     if (cur && (Expert || Confirm(-1, -1, "Some Vertices are not bound to any LineDef", "Do you want to delete these unused Vertices?"))) {
  1526.     DeleteObjects( OBJ_VERTEXES, &cur);
  1527.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  1528.     }
  1529.     else
  1530.     ForgetSelection( &cur);
  1531.     
  1532.     CheckingObjects( -1, -1);
  1533.     /* select all SideDefs */
  1534.     for (n = 0; n < NumSideDefs; n++)
  1535.     SelectObject( &cur, n);
  1536.     /* unselect SideDefs bound to a LineDef */
  1537.     for (n = 0; n < NumLineDefs; n++) {
  1538.     m = LineDefs[ n].sidedef1;
  1539.     if (cur && m >= 0)
  1540.         UnSelectObject( &cur, m);
  1541.     m = LineDefs[ n].sidedef2;
  1542.     if (cur && m >= 0)
  1543.         UnSelectObject( &cur, m);
  1544.     continue;
  1545.     }
  1546.     /* check if there are any SideDefs left */
  1547.     if (cur && (Expert || Confirm(-1, -1, "Some SideDefs are not bound to any LineDef", "Do you want to delete these unused SideDefs?")))
  1548.     DeleteObjects( OBJ_SIDEDEFS, &cur);
  1549.     else
  1550.     ForgetSelection( &cur);
  1551.     
  1552.     CheckingObjects( -1, -1);
  1553.     /* select all Sectors */
  1554.     for (n = 0; n < NumSectors; n++)
  1555.     SelectObject( &cur, n);
  1556.     /* unselect Sectors bound to a SideDef */
  1557.     for (n = 0; n < NumLineDefs; n++) {
  1558.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  1559.     m = LineDefs[ n].sidedef1;
  1560.     ObjectsNeeded( OBJ_SIDEDEFS, 0);
  1561.     if (cur && m >= 0 && SideDefs[ m].sector >= 0)
  1562.         UnSelectObject( &cur, SideDefs[ m].sector);
  1563.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  1564.     m = LineDefs[ n].sidedef2;
  1565.     ObjectsNeeded( OBJ_SIDEDEFS, 0);
  1566.     if (cur && m >= 0 && SideDefs[ m].sector >= 0)
  1567.         UnSelectObject( &cur, SideDefs[ m].sector);
  1568.     continue;
  1569.     }
  1570.     /* check if there are any Sectors left */
  1571.     if (cur && (Expert || Confirm(-1, -1, "Some Sectors are not bound to any SideDef", "Do you want to delete these unused Sectors?")))
  1572.     DeleteObjects( OBJ_SECTORS, &cur);
  1573.     else
  1574.     ForgetSelection( &cur);
  1575. }
  1576.  
  1577.  
  1578.  
  1579. /*
  1580.    check for missing textures
  1581.    */
  1582.  
  1583. void CheckTextures( void) /* SWAP! */
  1584. {
  1585.     BCINT  n;
  1586.     BCINT  sd1, sd2;
  1587.     BCINT  s1, s2;
  1588.     char msg1[ 80], msg2[ 80];
  1589.     
  1590.     CheckingObjects( -1, -1);
  1591.     LogMessage( "\nVerifying Textures...\n");
  1592.     ObjectsNeeded( OBJ_SECTORS, 0);
  1593.     for (n = 0; n < NumSectors; n++) {
  1594.     if (Sectors[ n].ceilt[ 0] == '-' && Sectors[ n].ceilt == '\0') {
  1595.         sprintf( msg1, "Error: Sector #%d has no Ceiling Texture", n);
  1596.         sprintf( msg2, "You probaly used a brain-damaged editor to do that...");
  1597.         CheckFailed( -1, -1, msg1, msg2, TRUE);
  1598.         GoToObject( OBJ_SECTORS, n);
  1599.         return;
  1600.     }
  1601.     if (Sectors[ n].floort[ 0] == '-' && Sectors[ n].floort == '\0') {
  1602.         sprintf( msg1, "Error: Sector #%d has no Floor Texture", n);
  1603.         sprintf( msg2, "You probaly used a brain-damaged editor to do that...");
  1604.         CheckFailed( -1, -1, msg1, msg2, TRUE);
  1605.         GoToObject( OBJ_SECTORS, n);
  1606.         return;
  1607.     }
  1608.     if (Sectors[ n].ceilh < Sectors[ n].floorh) {
  1609.         sprintf( msg1, "Error: Sector #%d has its Ceiling lower than its Floor", n);
  1610.         sprintf( msg2, "The textures will never be displayed if you cannot go there");
  1611.         CheckFailed( -1, -1, msg1, msg2, TRUE);
  1612.         GoToObject( OBJ_SECTORS, n);
  1613.         return;
  1614.     }
  1615.     if (Sectors[ n].ceilh - Sectors[ n].floorh > 1023) {
  1616.         sprintf( msg1, "Error: Sector #%d has its Ceiling too high", n);
  1617.         sprintf( msg2, "The maximum difference allowed is 1023 (ceiling - floor)");
  1618.         CheckFailed( -1, -1, msg1, msg2, TRUE);
  1619.         GoToObject( OBJ_SECTORS, n);
  1620.         return;
  1621.     }
  1622.     }
  1623.     for (n = 0; n < NumLineDefs; n++) {
  1624.     ObjectsNeeded( OBJ_LINEDEFS, 0);
  1625.     sd1 = LineDefs[ n].sidedef1;
  1626.     sd2 = LineDefs[ n].sidedef2;
  1627.     ObjectsNeeded( OBJ_SIDEDEFS, OBJ_SECTORS, 0);
  1628.     if (sd1 >= 0)
  1629.         s1 = SideDefs[ sd1].sector;
  1630.     else
  1631.         s1 = -1;
  1632.     if (sd2 >= 0)
  1633.         s2 = SideDefs[ sd2].sector;
  1634.     else
  1635.         s2 = -1;
  1636.     if (s1 >= 0 && s2 < 0) {
  1637.         if (SideDefs[ sd1].tex3[ 0] == '-' && SideDefs[ sd1].tex3[ 1] == '\0') {
  1638.         sprintf( msg1, "Error in one-sided Linedef #%d: SideDef #%d has no normal texture", n, sd1);
  1639.         sprintf( msg2, "Do you want to set the texture to \"%s\" and continue?", DefaultWallTexture);
  1640.         if (CheckFailed( -1, -1, msg1, msg2, FALSE))
  1641.             {
  1642.             GoToObject( OBJ_LINEDEFS, n);
  1643.             return;
  1644.             }
  1645.         strncpy( SideDefs[ sd1].tex3, DefaultWallTexture, 8);
  1646.         CheckingObjects( -1, -1);
  1647.         }
  1648.     }
  1649.     if (s1 >= 0 && s2 >= 0 && Sectors[ s1].ceilh > Sectors[ s2].ceilh) {
  1650.         if (SideDefs[ sd1].tex1[ 0] == '-' && SideDefs[ sd1].tex1[ 1] == '\0'
  1651.         && (strncmp( Sectors[ s1].ceilt, "F_SKY1", 8) || strncmp( Sectors[ s2].ceilt, "F_SKY1", 8))) {
  1652.         sprintf( msg1, "Error in first SideDef of Linedef #%d: SideDef #%d has no upper texture", n, sd1);
  1653.         sprintf( msg2, "Do you want to set the texture to \"%s\" and continue?", DefaultUpperTexture);
  1654.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1655.             GoToObject( OBJ_LINEDEFS, n);
  1656.             return;
  1657.         }
  1658.         strncpy( SideDefs[ sd1].tex1, DefaultUpperTexture, 8);
  1659.         CheckingObjects( -1, -1);
  1660.         }
  1661.     }
  1662.     if (s1 >= 0 && s2 >= 0 && Sectors[ s1].floorh < Sectors[ s2].floorh) {
  1663.         if (SideDefs[ sd1].tex2[ 0] == '-' && SideDefs[ sd1].tex2[ 1] == '\0') {
  1664.         sprintf( msg1, "Error in first SideDef of Linedef #%d: SideDef #%d has no lower texture", n, sd1);
  1665.         sprintf( msg2, "Do you want to set the texture to \"%s\" and continue?", DefaultLowerTexture);
  1666.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1667.             GoToObject( OBJ_LINEDEFS, n);
  1668.             return;
  1669.         }
  1670.         strncpy( SideDefs[ sd1].tex2, DefaultLowerTexture, 8);
  1671.         CheckingObjects( -1, -1);
  1672.         }
  1673.     }
  1674.     if (s1 >= 0 && s2 >= 0 && Sectors[ s2].ceilh > Sectors[ s1].ceilh) {
  1675.         if (SideDefs[ sd2].tex1[ 0] == '-' && SideDefs[ sd2].tex1[ 1] == '\0'
  1676.         && (strncmp( Sectors[ s1].ceilt, "F_SKY1", 8) || strncmp( Sectors[ s2].ceilt, "F_SKY1", 8))) {
  1677.         sprintf( msg1, "Error in second SideDef of Linedef #%d: SideDef #%d has no upper texture", n, sd2);
  1678.         sprintf( msg2, "Do you want to set the texture to \"%s\" and continue?", DefaultUpperTexture);
  1679.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1680.             GoToObject( OBJ_LINEDEFS, n);
  1681.             return;
  1682.         }
  1683.         strncpy( SideDefs[ sd2].tex1, DefaultUpperTexture, 8);
  1684.         CheckingObjects( -1, -1);
  1685.         }
  1686.     }
  1687.     if (s1 >= 0 && s2 >= 0 && Sectors[ s2].floorh < Sectors[ s1].floorh) {
  1688.         if (SideDefs[ sd2].tex2[ 0] == '-' && SideDefs[ sd2].tex2[ 1] == '\0') {
  1689.         sprintf( msg1, "Error in second SideDef of Linedef #%d: SideDef #%d has no lower texture", n, sd2);
  1690.         
  1691.         sprintf( msg2, "Do you want to set the texture to \"%s\" and continue?", DefaultLowerTexture);
  1692.         if(CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1693.             GoToObject( OBJ_LINEDEFS, n);
  1694.             return;
  1695.         }
  1696.         strncpy( SideDefs[ sd2].tex2, DefaultUpperTexture, 8);
  1697.         CheckingObjects( -1, -1);
  1698.         }
  1699.     }
  1700.     }
  1701. }
  1702.  
  1703.  
  1704.  
  1705. /*
  1706.    check if a texture name matches one of the elements of a list
  1707.    */
  1708.  
  1709. Bool IsTextureNameInList( char *name, char **list, BCINT numelems)
  1710. {
  1711.     BCINT n;
  1712.     
  1713.     for (n = 0; n < numelems; n++)
  1714.     if (! strnicmp( name, list[ n], 8))
  1715.         return TRUE;
  1716.     return FALSE;
  1717. }
  1718.  
  1719.  
  1720.  
  1721. /*
  1722.    check for invalid texture names
  1723.    */
  1724.  
  1725. void CheckTextureNames( void) /* SWAP! */
  1726. {
  1727.     BCINT  n;
  1728.     char msg1[ 80], msg2[ 80];
  1729.     
  1730.     LogMessage( "\nVerifying texture names...\n");
  1731.     if (FindMasterDir( MasterDir, "F2_START") == NULL)
  1732.     NumThings--;
  1733.     ObjectsNeeded( OBJ_SECTORS, 0);
  1734.     for (n = 0; n < NumSectors; n++) {
  1735.     if (! IsTextureNameInList( Sectors[ n].ceilt, FTexture, NumFTexture)) {
  1736.         sprintf( msg1, "Invalid Ceiling Texture in Sector #%d", n);
  1737.         sprintf( msg2, "The name \"%s\" is not a Floor/Ceiling Texture", Sectors[ n].ceilt);
  1738.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1739.         GoToObject( OBJ_SECTORS, n);
  1740.         return;
  1741.         }                           
  1742.         CheckingObjects( -1, -1);
  1743.     }
  1744.     if (! IsTextureNameInList( Sectors[ n].floort, FTexture, NumFTexture)) {
  1745.         sprintf( msg1, "Invalid Floor Texture in Sector #%d", n);
  1746.         sprintf( msg2, "The name \"%s\" is not a Floor/Ceiling Texture", Sectors[ n].floort);
  1747.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1748.         GoToObject( OBJ_SECTORS, n);
  1749.         return;
  1750.         }                        
  1751.         CheckingObjects( -1, -1);
  1752.     }
  1753.     }
  1754.     ObjectsNeeded( OBJ_SIDEDEFS, 0);
  1755.     for (n = 0; n < NumSideDefs; n++) {
  1756.     if (! IsTextureNameInList( SideDefs[ n].tex1, WTexture, NumWTexture)) {
  1757.         sprintf( msg1, "Invalid Upper Texture in SideDef #%d", n);
  1758.         sprintf( msg2, "The name \"%s\" is not a wall texture", SideDefs[ n].tex1);
  1759.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1760.         GoToObject( OBJ_SIDEDEFS, n);
  1761.         return;               
  1762.         }
  1763.         CheckingObjects( -1, -1);
  1764.     }
  1765.     if (! IsTextureNameInList( SideDefs[ n].tex2, WTexture, NumWTexture)) {
  1766.         sprintf( msg1, "Invalid Lower Texture in SideDef #%d", n);
  1767.         sprintf( msg2, "The name \"%s\" is not a wall Texture", SideDefs[ n].tex2);
  1768.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1769.         GoToObject( OBJ_SIDEDEFS, n);
  1770.         return;
  1771.         }                        
  1772.         CheckingObjects( -1, -1);
  1773.     }
  1774.     if (! IsTextureNameInList( SideDefs[ n].tex3, WTexture, NumWTexture)) {
  1775.         sprintf( msg1, "Invalid Normal Texture in SideDef #%d", n);
  1776.         sprintf( msg2, "The name \"%s\" is not a wall Texture", SideDefs[ n].tex3);
  1777.         if (CheckFailed( -1, -1, msg1, msg2, FALSE)) {
  1778.         GoToObject( OBJ_SIDEDEFS, n);
  1779.         return;
  1780.         }
  1781.         CheckingObjects( -1, -1);
  1782.     }
  1783.     }
  1784. }
  1785.  
  1786.  
  1787.  
  1788. /*
  1789.    check the level consistency
  1790.    */                                
  1791.  
  1792. void CheckLevel( BCINT x0, BCINT y0) /* SWAP! */
  1793. {
  1794.     switch (DisplayMenu( x0, y0, ((x0 == -1) ? "Check Level Consistency" : NULL),
  1795.             "Number of Objects",
  1796.             "Check if all Sectors are Closed",
  1797.             "Check all Cross-references",
  1798.             "Check for missing Textures",
  1799.             "Check texture names",
  1800.             NULL)) {
  1801.     case 1:
  1802.     Statistics( -1, -1);
  1803.     break;
  1804.     case 2:
  1805.     CheckSectors();
  1806.     break;
  1807.     case 3:
  1808.     CheckCrossReferences();
  1809.     break;
  1810.     case 4:
  1811.     CheckTextures();
  1812.     break;
  1813.     case 5:
  1814.     CheckTextureNames();
  1815.     break;
  1816.     }
  1817. }
  1818.  
  1819.  
  1820.  
  1821. /*
  1822.    check for players starting points
  1823.    */
  1824.  
  1825. Bool CheckStartingPos() /* SWAP! */
  1826. {
  1827.     return TRUE;
  1828. }
  1829.  
  1830.  
  1831.  
  1832. /*
  1833.    insert a standard object at given position
  1834.    */
  1835.  
  1836. void InsertStandardObject( BCINT x0, BCINT y0, BCINT xpos, BCINT ypos) /* SWAP! */
  1837. {
  1838.     BCINT sector;
  1839.     BCINT choice, n;
  1840.     BCINT a, b;
  1841.     
  1842.     /* show where the object will be inserted */
  1843.     if (UseMouse)
  1844.     HideMousePointer();
  1845.     DrawPointer( TRUE);
  1846.     if (UseMouse)
  1847.     ShowMousePointer();
  1848.     /* are we inside a Sector? */
  1849.     sector = GetCurObject( OBJ_SECTORS, xpos, ypos, xpos, ypos);
  1850.     if (sector >= 0)
  1851.     choice = DisplayMenu( x0, y0, ((x0 == -1) ? "Insert a pre-defined object (inside a Sector)" : NULL),
  1852.                  "Rectangle",
  1853.                  "Polygon (N sides)",
  1854. /*                 "Stairs",
  1855.                  "Hidden stairs", */
  1856.                  NULL);
  1857.     else
  1858.     choice = DisplayMenu( x0, y0, ((x0 == -1) ? "Insert a pre-defined object (outside)" : NULL),
  1859.                  "Rectangle",
  1860.                  "Polygon (N sides)",
  1861.                  NULL);
  1862.     /* !!!! Should also check for overlapping objects (Sectors) !!!! */
  1863.     switch (choice) {
  1864.     case 1:
  1865.     a = 256;
  1866.     b = 128;
  1867.     if (Input2Numbers( -1, -1, "Width", "Height", 2000, 2000, &a, &b)) {
  1868.         if (a < 8)
  1869.         a = 8;
  1870.         if (b < 8)
  1871.         b = 8;
  1872.         xpos = xpos - a / 2;
  1873.         ypos = ypos - b / 2;
  1874.         InsertObject( OBJ_VERTEXES, -1, xpos, ypos);
  1875.         InsertObject( OBJ_VERTEXES, -1, xpos + a, ypos);
  1876.         InsertObject( OBJ_VERTEXES, -1, xpos + a, ypos + b);
  1877.         InsertObject( OBJ_VERTEXES, -1, xpos, ypos + b);
  1878.         if (sector < 0)
  1879.         InsertObject( OBJ_SECTORS, -1, 0, 0);
  1880.         for (n = 0; n < 4; n++) {
  1881.         InsertObject( OBJ_LINEDEFS, -1, 0, 0);
  1882.         LineDefs[ NumLineDefs - 1].sidedef1 = NumSideDefs;
  1883.         InsertObject( OBJ_SIDEDEFS, -1, 0, 0);
  1884.         if (sector >= 0)
  1885.             SideDefs[ NumSideDefs - 1].sector = sector;
  1886.         }
  1887.         ObjectsNeeded( OBJ_LINEDEFS, 0);
  1888.         if (sector >= 0) {
  1889.         LineDefs[ NumLineDefs - 4].start = NumVertexes - 4;
  1890.         LineDefs[ NumLineDefs - 4].end = NumVertexes - 3;
  1891.         LineDefs[ NumLineDefs - 3].start = NumVertexes - 3;
  1892.         LineDefs[ NumLineDefs - 3].end = NumVertexes - 2;
  1893.         LineDefs[ NumLineDefs - 2].start = NumVertexes - 2;
  1894.         LineDefs[ NumLineDefs - 2].end = NumVertexes - 1;
  1895.         LineDefs[ NumLineDefs - 1].start = NumVertexes - 1;
  1896.         LineDefs[ NumLineDefs - 1].end = NumVertexes - 4;
  1897.         }
  1898.         else {
  1899.         LineDefs[ NumLineDefs - 4].start = NumVertexes - 1;
  1900.         LineDefs[ NumLineDefs - 4].end = NumVertexes - 2;
  1901.         LineDefs[ NumLineDefs - 3].start = NumVertexes - 2;
  1902.         LineDefs[ NumLineDefs - 3].end = NumVertexes - 3;
  1903.         LineDefs[ NumLineDefs - 2].start = NumVertexes - 3;
  1904.         LineDefs[ NumLineDefs - 2].end = NumVertexes - 4;
  1905.         LineDefs[ NumLineDefs - 1].start = NumVertexes - 4;
  1906.         LineDefs[ NumLineDefs - 1].end = NumVertexes - 1;
  1907.         }
  1908.     }
  1909.     break;
  1910.     case 2:
  1911.     a = 8;
  1912.     b = 128;
  1913.     if (Input2Numbers( -1, -1, "Number of Sides", "Radius", 32, 2000, &a, &b)) {
  1914.         if (a < 3)
  1915.         a = 3;
  1916.         if (b < 8)
  1917.         b = 8;
  1918.         InsertPolygonVertices( xpos, ypos, a, b);
  1919.         if (sector < 0)
  1920.         InsertObject( OBJ_SECTORS, -1, 0, 0);
  1921.         for (n = 0; n < a; n++) {
  1922.         InsertObject( OBJ_LINEDEFS, -1, 0, 0);
  1923.         LineDefs[ NumLineDefs - 1].sidedef1 = NumSideDefs;
  1924.         InsertObject( OBJ_SIDEDEFS, -1, 0, 0);
  1925.         if (sector >= 0)
  1926.             SideDefs[ NumSideDefs - 1].sector = sector;
  1927.         }
  1928.         ObjectsNeeded( OBJ_LINEDEFS, 0);
  1929.         if (sector >= 0) {
  1930.         LineDefs[ NumLineDefs - 1].start = NumVertexes - 1;
  1931.         LineDefs[ NumLineDefs - 1].end = NumVertexes - a;
  1932.         for (n = 2; n <= a; n++) {
  1933.             LineDefs[ NumLineDefs - n].start = NumVertexes - n;
  1934.             LineDefs[ NumLineDefs - n].end = NumVertexes - n + 1;
  1935.         }
  1936.         }
  1937.         else {
  1938.         LineDefs[ NumLineDefs - 1].start = NumVertexes - a;
  1939.         LineDefs[ NumLineDefs - 1].end = NumVertexes - 1;
  1940.         for (n = 2; n <= a; n++) {
  1941.             LineDefs[ NumLineDefs - n].start = NumVertexes - n + 1;
  1942.             LineDefs[ NumLineDefs - n].end = NumVertexes - n;
  1943.         }
  1944.         }
  1945.     }
  1946.     break;
  1947.     case 3:
  1948.     /*
  1949.        a = 6;
  1950.        b = 16;
  1951.        if (Input2Numbers( -1, -1, "Number of Steps", "Step Height", 32, 48, &a, &b)) {
  1952.        if (a < 2)
  1953.        a = 2;
  1954.        ObjectsNeeded( OBJ_SECTORS, 0);
  1955.        n = Sectors[ sector].ceilh;
  1956.        h = Sectors[ sector].floorh;
  1957.        if (a * b < n - h) {
  1958.        Beep();
  1959.        Notify( -1, -1, "The Stairs are too high for this Sector", NULL);
  1960.        return;
  1961.        }
  1962.        xpos = xpos - 32;
  1963.        ypos = ypos - 32 * a;
  1964.        for (n = 0; n < a; n++) {
  1965.        InsertObject( OBJ_VERTEXES, -1, xpos, ypos);
  1966.        InsertObject( OBJ_VERTEXES, -1, xpos + 64, ypos);
  1967.        InsertObject( OBJ_VERTEXES, -1, xpos + 64, ypos + 64);
  1968.        InsertObject( OBJ_VERTEXES, -1, xpos, ypos + 64);
  1969.        ypos += 64;
  1970.        InsertObject( OBJ_SECTORS, sector, 0, 0);
  1971.        h += b;
  1972.        Sectors[ NumSectors - 1].floorh = h;
  1973.        
  1974.        InsertObject( OBJ_LINEDEFS, -1, 0, 0);
  1975.        LineDefs[ NumLineDefs - 1].sidedef1 = NumSideDefs;
  1976.        LineDefs[ NumLineDefs - 1].sidedef2 = NumSideDefs + 1;
  1977.        InsertObject( OBJ_SIDEDEFS, -1, 0, 0);
  1978.        SideDefs[ NumSideDefs - 1].sector = sector;
  1979.        InsertObject( OBJ_SIDEDEFS, -1, 0, 0);
  1980.        
  1981.        ObjectsNeeded( OBJ_LINEDEFS, 0);
  1982.        LineDefs[ NumLineDefs - 4].start = NumVertexes - 4;
  1983.        LineDefs[ NumLineDefs - 4].end = NumVertexes - 3;
  1984.        LineDefs[ NumLineDefs - 3].start = NumVertexes - 3;
  1985.        LineDefs[ NumLineDefs - 3].end = NumVertexes - 2;
  1986.        LineDefs[ NumLineDefs - 2].start = NumVertexes - 2;
  1987.        LineDefs[ NumLineDefs - 2].end = NumVertexes - 1;
  1988.        LineDefs[ NumLineDefs - 1].start = NumVertexes - 1;
  1989.        LineDefs[ NumLineDefs - 1].end = NumVertexes - 4;
  1990.        }
  1991.        }
  1992.        break;
  1993.        */
  1994.     case 4:
  1995.     NotImplemented();
  1996.     break;
  1997.     }
  1998. }
  1999.  
  2000.  
  2001.  
  2002. /*
  2003.    menu of miscellaneous operations
  2004.    */
  2005.  
  2006. void MiscOperations( BCINT x0, BCINT y0, BCINT objtype, SelPtr *list)
  2007. {
  2008.     char   msg[ 80];
  2009.     BCINT    val;
  2010.     BCINT    angle, scale;
  2011.     
  2012.     sprintf( msg, "Rotate and scale %s", GetEditModeName( objtype));
  2013.     if (objtype == OBJ_VERTEXES) {
  2014.     val = DisplayMenu( x0, y0, ((x0 == -1) ? "Misc. Operations" : NULL),
  2015.               "Find first free tag number",
  2016.               msg,
  2017.               "Delete Vertex and join LineDefs",
  2018.               "Merge several Vertices into one",
  2019.               "Add a LineDef and split Sector",
  2020.               NULL);
  2021.     }
  2022.     else if (objtype == OBJ_LINEDEFS) {
  2023.     val = DisplayMenu( x0, y0, ((x0 == -1) ? "Misc. Operations" : NULL),
  2024.               "Find first free Tag number",
  2025.               msg,
  2026.               "Split LineDef (add new Vertex)",
  2027.               "Split LineDefs and add a Sector",
  2028.               "Delete LineDefs and join Sectors",
  2029.               "Flip LineDef",
  2030.               "Swap SideDefs",
  2031.               "Align Textures Intelligently on Y",
  2032.               "Align Textures Intelligently on X",
  2033.               NULL);
  2034.     }
  2035.     else if (objtype == OBJ_SECTORS) {
  2036.     val = DisplayMenu( x0, y0, ((x0 == -1) ? "Misc. Operations" : NULL),
  2037.               "Find first free tag number",
  2038.               msg,
  2039.               "Make Door from Sector",
  2040.               "Make Lift from Sector",
  2041.               "Distribute Sector Floor Heights",
  2042.               "Distribute Sector Ceiling Heights",
  2043.               "Distribute Sector Light Levels",
  2044.               NULL);
  2045.     }                                                         
  2046.     else {
  2047.     val = DisplayMenu( x0, y0, ((x0 == -1) ? "Misc. Operations" : NULL),
  2048.               "Find First Free Tag Number",
  2049.               msg,
  2050.               NULL);
  2051.     }
  2052.     if (val > 1 && *list == NULL) {
  2053.     Beep();
  2054.     sprintf( msg, "You must select at least one %s", GetObjectTypeName( objtype));
  2055.     Notify( -1, -1, msg, NULL);
  2056.     return;
  2057.     }
  2058.     switch (val) {
  2059.     case 1:
  2060.     sprintf( msg, "First Free Tag Number: %d", FindFreeTag());
  2061.     Notify( -1, -1, msg, NULL);
  2062.     break;
  2063.     case 2:
  2064.     if ((objtype == OBJ_THINGS || objtype == OBJ_VERTEXES) && (*list)->next == NULL) {
  2065.         Beep();
  2066.         sprintf( msg, "You must select more than one %s", GetObjectTypeName( objtype));
  2067.         Notify( -1, -1, msg, NULL);
  2068.         return;
  2069.     }
  2070.     angle = 0;
  2071.     scale = 100;
  2072.     if (Input2Numbers( -1, -1, "Rotation angle (°)", "Scale (%)", 360, 1000, &angle, &scale))
  2073.         RotateAndScaleObjects( objtype, *list, (double) angle * 0.0174533, (double) scale * 0.01);
  2074.     break;
  2075.     case 3:
  2076.     if (objtype == OBJ_VERTEXES) {
  2077.         DeleteVerticesJoinLineDefs( *list);
  2078.         ForgetSelection( list);
  2079.     }
  2080.     else if (objtype == OBJ_LINEDEFS) {
  2081.         SplitLineDefs( *list);
  2082.     }
  2083.     else if (objtype == OBJ_SECTORS) {
  2084.         if ((*list)->next != NULL) {
  2085.         Beep();
  2086.         Notify( -1, -1, "You must select exactly one Sector", NULL);
  2087.         }
  2088.         else {
  2089.         MakeDoorFromSector( (*list)->objnum);
  2090.         }
  2091.     }
  2092.     break;
  2093.     case 4:
  2094.     if (objtype == OBJ_VERTEXES) {
  2095.         MergeVertices( list);
  2096.     }
  2097.     else if (objtype == OBJ_LINEDEFS) {
  2098.         if ((*list)->next == NULL || (*list)->next->next != NULL) {
  2099.         Beep();
  2100.         Notify( -1, -1, "You must select exactly two LineDefs", NULL);
  2101.         }
  2102.         else {
  2103.         SplitLineDefsAndSector( (*list)->objnum, (*list)->next->objnum);
  2104.         ForgetSelection( list);
  2105.         }
  2106.     }
  2107.     else if (objtype == OBJ_SECTORS) {
  2108.         if ((*list)->next != NULL) {
  2109.         Beep();
  2110.         Notify( -1, -1, "You must select exactly one Sector", NULL);
  2111.         }
  2112.         else {
  2113.         MakeLiftFromSector( (*list)->objnum);
  2114.         }
  2115.     }
  2116.     break;
  2117.     case 5:
  2118.     if (objtype == OBJ_VERTEXES) {
  2119.         if ((*list)->next == NULL || (*list)->next->next != NULL) {
  2120.         Beep();
  2121.         Notify( -1, -1, "You must select exactly two Vertices", NULL);
  2122.         }
  2123.         else {
  2124.         SplitSector( (*list)->objnum, (*list)->next->objnum);
  2125.         ForgetSelection( list);
  2126.         }
  2127.     }
  2128.     else if (objtype == OBJ_LINEDEFS) {
  2129.         DeleteLineDefsJoinSectors( list);
  2130.     }
  2131.     else if (objtype == OBJ_SECTORS) {
  2132.         if ((*list)->next == NULL || (*list)->next->next == NULL) {
  2133.         Beep();
  2134.         Notify( -1, -1, "You must select three or more Sectors", NULL);
  2135.         }
  2136.         else {
  2137.         DistributeSectorFloors( *list);
  2138.         }
  2139.     }
  2140.     break;
  2141.     case 6:
  2142.     if (objtype == OBJ_LINEDEFS) {
  2143.         FlipLineDefs( *list, TRUE);
  2144.     }
  2145.     else if (objtype == OBJ_SECTORS) {
  2146.         if ((*list)->next == NULL || (*list)->next->next == NULL) {
  2147.         Beep();
  2148.         Notify( -1, -1, "You must select three or more Sectors", NULL);
  2149.         }
  2150.         else {
  2151.         DistributeSectorCeilings( *list);
  2152.         }
  2153.     }
  2154.     break;
  2155.     case 7:
  2156.     if (objtype == OBJ_LINEDEFS) {
  2157.         if (Expert || Confirm( -1, -1, "Warning: the Sector references are also swapped", "You may get strange results if you don't know what you are doing..."))
  2158.         FlipLineDefs( *list, FALSE);
  2159.     }
  2160.     else if (objtype == OBJ_SECTORS) {
  2161.         if ((*list)->next == NULL || (*list)->next->next == NULL) {
  2162.         Beep();
  2163.         Notify( -1, -1, "You must select three or more Sectors", NULL);
  2164.         }
  2165.         else {
  2166.         DistributeLightLevels( *list);
  2167.         }
  2168.     }
  2169.     break;
  2170.     case 8:
  2171.     if (objtype == OBJ_LINEDEFS) {
  2172.         char    *menustr[ 30];
  2173.         BCINT    dummy[ 30];
  2174.         BCINT    n, val;
  2175.         
  2176.         x0 = (ScrMaxX - 29 - 8 * 44) / 2;
  2177.         y0 = (ScrMaxY - 24 - 10 * 5) / 2;
  2178.         for (n = 0; n < 5; n++)
  2179.         menustr[ n] = (char*)GetMemory( 80);
  2180.         strcpy( menustr[ 4], "Y Texture Alignment");
  2181.         strcpy( menustr[ 0], "Align Y with Texture checking");
  2182.         strcpy( menustr[ 1], "Align Y with Texture checking and Initial offset");
  2183.         strcpy( menustr[ 2], "Align Y without Texture checking");
  2184.         strcpy( menustr[ 3], "Align Y without Texture checking and Initial offset");
  2185.         val = DisplayMenuArray( x0, y0, menustr[ 4], 4, NULL, menustr, dummy);
  2186.         for (n = 0; n < 5; n++)
  2187.         FreeMemory( menustr[ n]);
  2188.  
  2189.         if(val >= 1 && val <= 4) {
  2190.             val--;
  2191.             AlignTexturesY(list, /* list of linedefs */
  2192.                             (val & 2) ? TRUE : FALSE,     /* NoChecking */
  2193.                             (val & 1) ? TRUE : FALSE);    /* Initial offset */
  2194.         }
  2195.     }
  2196.     break;
  2197.     case 9:
  2198.     if (objtype == OBJ_LINEDEFS) {
  2199.         char    *menustr[ 30];
  2200.         BCINT    dummy[ 30];
  2201.         BCINT    n, val;
  2202.         
  2203.         x0 = (ScrMaxX - 29 - 8 * 44) / 2;
  2204.         y0 = (ScrMaxY - 24 - 10 * 5) / 2;
  2205.         for (n = 0; n < 5; n++)
  2206.         menustr[ n] = (char*)GetMemory( 80);
  2207.         strcpy( menustr[ 4], "X Texture Alignment");
  2208.         strcpy( menustr[ 0], "Align X with Texture checking");
  2209.         strcpy( menustr[ 1], "Align X with Texture checking and Initial offset");
  2210.         strcpy( menustr[ 2], "Align X without Texture checking");
  2211.         strcpy( menustr[ 3], "Align X without Texture checking and Initial offset");
  2212.         val = DisplayMenuArray( x0, y0, menustr[ 4], 4, NULL, menustr, dummy);
  2213.         for (n = 0; n < 5; n++)
  2214.         FreeMemory( menustr[ n]);
  2215.  
  2216.         if(val >= 1 && val <= 4) {
  2217.             val--;
  2218.             AlignTexturesX(list, /* list of linedefs */
  2219.                             (val & 2) ? TRUE : FALSE,     /* NoChecking */
  2220.                             (val & 1) ? TRUE : FALSE);    /* Initial offset */
  2221.         }
  2222.        
  2223.     }
  2224.     break;
  2225.     }
  2226. }
  2227.  
  2228.  
  2229.  
  2230. /*
  2231.    display a "Preferences" menu (change default textures, etc.)
  2232.    */
  2233.  
  2234. void Preferences( BCINT x0, BCINT y0)
  2235. {
  2236.     char   *menustr[ 30];
  2237.     BCINT     dummy[ 30];
  2238.     BCINT     n, val;
  2239.     char    texname[ 9];
  2240.     
  2241.     if (x0 < 0)
  2242.     x0 = (ScrMaxX - 50 * 8 - 19) / 2;
  2243.     if (y0 < 0)
  2244.     y0 = (ScrMaxY - 5 * 10 - 28) / 2;
  2245.     for (n = 0; n < 10; n++)
  2246.     menustr[ n] = (char*)GetMemory( 80);
  2247.     sprintf( menustr[ 9], "Preferences");
  2248.     sprintf( menustr[ 0], "Change default Wall Texture    (Current: %s)", DefaultWallTexture);
  2249.     sprintf( menustr[ 1], "Change default Upper Texture (Current: %s)", DefaultUpperTexture);
  2250.     sprintf( menustr[ 2], "Change default Lower Texture (Current: %s)", DefaultLowerTexture);
  2251.     sprintf( menustr[ 3], "Change default Floor Texture   (Current: %s)", DefaultFloorTexture);
  2252.     sprintf( menustr[ 4], "Change default Ceiling Texture (Current: %s)", DefaultCeilingTexture);
  2253.     sprintf( menustr[ 5], "Change default Floor Height    (Current: %d)", (int)DefaultFloorHeight & 0xffff);
  2254.     sprintf( menustr[ 6], "Change default Ceiling Height  (Current: %d)", (int)DefaultCeilingHeight & 0xffff);
  2255.     sprintf( menustr[ 7], "Change default Door Track      (Current: %s)", DefaultDoorTrack);
  2256.     sprintf( menustr[ 8], "Change default Door Texture    (Current: %s)", DefaultDoorTexture);
  2257.     val = DisplayMenuArray( x0, y0, menustr[ 9], 9, NULL, menustr, dummy);
  2258.     for (n = 0; n < 10; n++)
  2259.     FreeMemory( menustr[ n]);
  2260.     switch (val) {
  2261.     case 1:
  2262.     strcpy( texname, DefaultWallTexture);
  2263.     ChooseWallTexture( x0 + 42, y0 + 34, "Choose Normal Texture", NumWTexture, WTexture, texname);
  2264.     if (strlen( texname) > 0)
  2265.         strcpy( DefaultWallTexture, texname);
  2266.     break;
  2267.     case 2:
  2268.     strcpy( texname, DefaultUpperTexture);
  2269.     ChooseWallTexture( x0 + 42, y0 + 34, "Choose Upper Texture ", NumWTexture, WTexture, texname);
  2270.     if (strlen( texname) > 0)
  2271.         strcpy( DefaultUpperTexture, texname);
  2272.     break;
  2273.     case 3:
  2274.     strcpy( texname, DefaultLowerTexture);
  2275.     ChooseWallTexture( x0 + 42, y0 + 34, "Choose Lower Texture ", NumWTexture, WTexture, texname);
  2276.     if (strlen( texname) > 0)
  2277.         strcpy( DefaultLowerTexture, texname);
  2278.     break;
  2279.     case 4:
  2280.     strcpy( texname, DefaultFloorTexture);
  2281.     ChooseFloorTexture( x0 + 42, y0 + 44, "Choose a Floor Texture", NumFTexture, FTexture, texname);
  2282.     if (strlen( texname) > 0)
  2283.         strcpy( DefaultFloorTexture, texname);
  2284.     break;
  2285.     case 5:
  2286.     strcpy( texname, DefaultCeilingTexture);
  2287.     ChooseFloorTexture( x0 + 42, y0 + 54, "Choose a Ceiling Texture", NumFTexture, FTexture, texname);
  2288.     if (strlen( texname) > 0)
  2289.         strcpy( DefaultCeilingTexture, texname);
  2290.     break;
  2291.     case 6:
  2292.     val = InputIntegerValue( x0 + 42, y0 + 64, -512, 511, DefaultFloorHeight);
  2293.     if (val >= -512)
  2294.         DefaultFloorHeight = val;
  2295.     break;
  2296.     case 7:
  2297.     val = InputIntegerValue( x0 + 42, y0 + 74, -512, 511, DefaultCeilingHeight);
  2298.     if (val >= -512)
  2299.         DefaultCeilingHeight = val;
  2300.     break;
  2301.     case 8:
  2302.     strcpy( texname, DefaultDoorTrack);
  2303.     ChooseWallTexture( x0 + 42, y0 + 84, "Choose a Door Track  ", NumWTexture, WTexture, texname);
  2304.     if (strlen( texname) > 0)
  2305.         strcpy( DefaultDoorTrack, texname);
  2306.     break;
  2307.     case 9:
  2308.     strcpy( texname, DefaultDoorTexture);
  2309.     ChooseWallTexture( x0 + 42, y0 + 94, "Choose a Door Texture", NumWTexture, WTexture, texname);
  2310.     if (strlen( texname) > 0)
  2311.         strcpy( DefaultDoorTexture, texname);
  2312.     break;
  2313.     }               
  2314. }
  2315.  
  2316. /* end of file */
  2317.