home *** CD-ROM | disk | FTP | other *** search
/ Toolkit for DOOM / DOOMTOOL.ISO / editors / dme301.zip / SOURCE.ZIP / TEMPLATE.C < prev    next >
C/C++ Source or Header  |  1994-07-16  |  16KB  |  867 lines
  1. /*
  2.     This is a DMapEdit source code module.  Though it is copyrighted, you
  3.     may modify it and use it for your own personal use, meaning that new
  4.     modified code and anything derived from it (such as exe files) doesn't
  5.     get distributed to anyone, unless you get my permission first.  Code
  6.     from this file, or code based on ideas from this file may be used with
  7.     other programs, provided that you give credit for it in the source code,
  8.     documentation, and 'about' windows or screens, if one exists, for the
  9.     programs using it.  Giving credit means something like this:
  10.  
  11.     Code from DMapEdit was used in this program
  12.  
  13.                               or
  14.  
  15.     Some code for this program was based on ideas presented in DMapEdit
  16.  
  17.     Whatever.  Just be sure to mention "DMapEdit" in such a way that it's
  18.     self-evident how it was useful to the new program, and be sure to have
  19.     "DMapEdit is a trademark of Jason Hoffoss" in the docs.  That's all..
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <graphics.h>
  24. #include "dme.h"
  25. #include "dme2.h"
  26.  
  27. int toggle_item(int num, int far * far *list);
  28. void mark_line_vertexes(void);
  29. int unmark_item(int num, int far * far *ptr);
  30. int mark_item(int num, int far * far *ptr);
  31. void mark_thing(int num);
  32. void mark_sector(int num);
  33. int mark_sectors(int mode, int total);
  34.  
  35. int old_mark_color=0;
  36.  
  37. void make_lists(void)
  38. {
  39.     mthings = get_farmem(4L, "marked thing list");
  40.     *mthings = 0;
  41.     mthings[1] = 2;
  42.     mvertexes = get_farmem(4L, "marked vertex list");
  43.     *mvertexes = 0;
  44.     mvertexes[1] = 2;
  45.     mlinedefs = get_farmem(4L, "marked line list");
  46.     *mlinedefs = 0;
  47.     mlinedefs[1] = 2;
  48.     msidedefs = get_farmem(4L, "marked sidedef list");
  49.     *msidedefs = 0;
  50.     msidedefs[1] = 2;
  51.     msectors = get_farmem(4L, "marked sector list");
  52.     *msectors = 0;
  53.     msectors[1] = 2;
  54.  
  55.     marked = 0;
  56.     return;
  57. }
  58.  
  59. void sort_marked(int far *list)
  60. {
  61.     int i, j, temp;
  62.     int far *list2;
  63.  
  64.     if (*list < 2)
  65.         return; /* no sorting needed */
  66.  
  67.     list2 = list + 2;
  68.     for (i=1; i<*list; i++)
  69.     {
  70.         temp = list2[i];
  71.         j = i;
  72.         while (j-- && temp < list2[j])
  73.             list2[j+1] = list2[j];
  74.  
  75.         j++;
  76.         list2[j] = temp;
  77.     }
  78.     return;
  79. }
  80.  
  81. void unmark_all(void)
  82. {
  83.     *mthings = 0;
  84.     mthings[1] = 2;
  85.     mthings = resize_farmem(mthings, 4L, "marked thing list");
  86.  
  87.     *mvertexes = 0;
  88.     mvertexes[1] = 2;
  89.     mvertexes = resize_farmem(mvertexes, 4L, "marked vertex list");
  90.  
  91.     *mlinedefs = 0;
  92.     mlinedefs[1] = 2;
  93.     mlinedefs = resize_farmem(mlinedefs, 4L, "marked line list");
  94.  
  95.     *msidedefs = 0;
  96.     msidedefs[1] = 2;
  97.     msidedefs = resize_farmem(msidedefs, 4L, "marked sidedef list");
  98.  
  99.     *msectors = 0;
  100.     msectors[1] = 2;
  101.     msectors = resize_farmem(msectors, 4L, "marked sector list");
  102.  
  103.     marked = 0;
  104.     return;
  105. }
  106.  
  107. int toggle_item(int num, int far * far *ptr)
  108. {
  109.     int i, j, size;
  110.     int far *list;
  111.  
  112.     list = *ptr;
  113.     size = *list;
  114.  
  115.     for (i=0; i<size; i++)
  116.         if (list[i+2] == num)
  117.         {
  118.             for (j=i+1; j<size; j++)
  119.                 list[j+1] = list[j+2];
  120.             (*list)--;
  121.             marked = *mthings | *mvertexes | *mlinedefs | *msidedefs | *msectors;
  122.             return 0;
  123.         }
  124.  
  125.     if (size + 2 == list[1])
  126.         *ptr = list = resize_farmem(list, (list[1] += 256)*2, "marked list");
  127.     list[size + 2] = num;
  128.     (*list)++;
  129.     marked = 1;
  130.     return 1;
  131. }
  132.  
  133. int mark_item(int num, int far * far *ptr)
  134. {
  135.     int i, j, size;
  136.     int far *list;
  137.  
  138.     list = *ptr;
  139.     size = *list;
  140.  
  141.     for (i=0; i<size; i++)
  142.         if (list[i+2] == num)
  143.             return 0;
  144.  
  145.     if (size + 2 == list[1])
  146.         *ptr = list = resize_farmem(list, (list[1] += 256)*2, "marked list");
  147.     list[size + 2] = num;
  148.     (*list)++;
  149.     marked = 1;
  150.     return 1;
  151. }
  152.  
  153. int unmark_item(int num, int far * far *ptr)
  154. {
  155.     int i, j, size;
  156.     int far *list;
  157.  
  158.     list = *ptr;
  159.     size = *list;
  160.  
  161.     for (i=0; i<size; i++)
  162.         if (list[i+2] == num)
  163.         {
  164.             for (j=i+1; j<size; j++)
  165.                 list[j+1] = list[j+2];
  166.             (*list)--;
  167.             marked = *mthings | *mvertexes | *mlinedefs | *msidedefs | *msectors;
  168.             return 1;
  169.         }
  170.  
  171.     return 0;
  172. }
  173.  
  174. int check_marked(int num, int far *list)
  175. {
  176.     int i, size;
  177.  
  178.     size = *list;
  179.  
  180.     for (i=0; i<size; i++)
  181.         if (list[i+2] == num)
  182.             return 1;
  183.  
  184.     return 0;
  185. }
  186.  
  187. void mark_vertex(int num)
  188. {
  189.     if (!toggle_item(num, &mvertexes))
  190.         draw_point(adjvx[num], adjvy[num], maxx - point_size * 2,
  191.             maxy - point_size * 2);
  192.     return;
  193. }
  194.  
  195. void mark_line_vertexes(void)
  196. {
  197.     uchar *bits, flags[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
  198.     int i, v, z, max, mindex;
  199.  
  200.     if (!max_vertex)
  201.         return;
  202.  
  203.     i = (max_vertex + 7) / 8;
  204.     bits = get_mem(i, "Sector marking list");
  205.     while (i--)
  206.         bits[i] = 0;
  207.  
  208.     for (i=0; i<*mlinedefs; i++)
  209.     {
  210.         z = mlinedefs[i+2];
  211.         v = linedefs[z].v1;
  212.         bits[v >> 3] |= flags[v & 7];
  213.  
  214.         v = linedefs[z].v2;
  215.         bits[v >> 3] |= flags[v & 7];
  216.     }
  217.  
  218.     sort_marked(mvertexes);
  219.     mindex = 2;
  220.     max = *mvertexes + 2;
  221.     for (i=0; i<max_vertex; i++)
  222.     {
  223.         if (mvertexes[mindex] == i && mindex < max )
  224.         {
  225.             if (!(bits[i >> 3] & flags[i & 7]))
  226.             {
  227.                 if (unmark_item(i, &mvertexes))
  228.                 draw_point(adjvx[i], adjvy[i], maxx - point_size * 2,
  229.                     maxy - point_size * 2);
  230.                 max--;
  231.             } else
  232.                 mindex++;
  233.  
  234.         } else
  235.             if (bits[i >> 3] & flags[i & 7])
  236.                 mark_item(i, &mvertexes);
  237.     }
  238.     return;
  239. }
  240.  
  241. void mark_line(int num)
  242. {
  243.     int sd1, sd2, sec1, sec2;
  244.  
  245.     sd1 = linedefs[num].sd1;
  246.     if (sd1 != -1)
  247.         sec1 = sidedefs[sd1].sector;
  248.  
  249.     sd2 = linedefs[num].sd2;
  250.     if (sd2 != -1)
  251.         sec2 = sidedefs[sd2].sector;
  252.  
  253.     if (toggle_item(num, &mlinedefs))
  254.     {
  255.         if (sec1 != -1)
  256.             mark_item(sd1, &msidedefs);
  257.         if (sec2 != -1)
  258.             mark_item(sd2, &msidedefs);
  259.         mark_item(linedefs[num].v1, &mvertexes);
  260.         mark_item(linedefs[num].v2, &mvertexes);
  261.  
  262.     } else {
  263.         wall_color(num);
  264.         draw_line(num, SOLID_LINE);
  265.         if (sec1 != -1)
  266.             unmark_item(sd1, &msidedefs);
  267.         if (sec2 != -1)
  268.             unmark_item(sd2, &msidedefs);
  269.     }
  270.  
  271.     return;
  272. }
  273.  
  274. void mark_sector(int num)
  275. {
  276.     int i, z, test, test2, sd, sec;
  277.  
  278.     z = toggle_item(num, &msectors);
  279.  
  280.     for (i=0; i<l_size; i++)
  281.     {
  282.         test = test2 = 0;
  283.         sd = linedefs[i].sd1;
  284.         if (sd != -1)
  285.         {
  286.             sec = sidedefs[sd].sector;
  287.             if (sec == num)
  288.             {
  289.                 test++;
  290.                 if (z)
  291.                     mark_item(sec, &msidedefs);
  292.                 else
  293.                     unmark_item(sec, &msidedefs);
  294.             } else
  295.                 test2 = check_marked(sec, msectors);
  296.         }
  297.  
  298.         sd = linedefs[i].sd2;
  299.         if (sd != -1)
  300.         {
  301.             sec = sidedefs[sd].sector;
  302.             if (sec == num)
  303.             {
  304.                 test++;
  305.                 if (z)
  306.                     mark_item(sec, &msidedefs);
  307.                 else
  308.                     unmark_item(sec, &msidedefs);
  309.             } else
  310.                 test2 += check_marked(sec, msectors);
  311.         }
  312.  
  313.         if (test)
  314.         {
  315.             if (z || test2)
  316.                 mark_item(i, &mlinedefs);
  317.             else
  318.                 unmark_item(i, &mlinedefs);
  319.         }
  320.     }
  321.  
  322.     mark_line_vertexes();
  323.     return;
  324. }
  325.  
  326. int mark_sectors(int mode, int total)
  327. {
  328.     uchar *bits, flags[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
  329.     int i, mindex, max, sd, sec, total2=0;
  330.  
  331.     if (!sec_size)
  332.         goto skip;
  333.  
  334.     i = (sec_size + 7) / 8;
  335.     bits = get_mem(i, "Sector marking list");
  336.     while (i--)
  337.         bits[i] = 0;
  338.  
  339.     sort_marked(mlinedefs);
  340.     mindex = 2;
  341.     max = *mlinedefs + 2;
  342.     for (i=0; i<l_size; i++)
  343.     {
  344.         if (mlinedefs[mindex] == i && mindex < max)
  345.         {
  346.             mindex++;
  347.             continue;
  348.         }
  349.  
  350.         sd = linedefs[i].sd1;
  351.         if (sd != -1)
  352.         {
  353.             sec = sidedefs[sd].sector;
  354.             if (sec != -1)
  355.                 bits[sec >> 3] |= flags[sec & 7];
  356.         }
  357.  
  358.         sd = linedefs[i].sd2;
  359.         if (sd != -1)
  360.         {
  361.             sec = sidedefs[sd].sector;
  362.             if (sec != -1)
  363.                 bits[sec >> 3] |= flags[sec & 7];
  364.         }
  365.     }
  366.  
  367.     for (i=0; i<sec_size; i++)
  368.         if (!(bits[i >> 3] & flags[i & 7]))
  369.         {
  370.             toggle_item(i, &msectors);
  371.             total2++;
  372.         }
  373.  
  374.     if (mode == 5 || mode == 6)
  375.     {
  376.         total = total2;
  377.         for (i=0; i<(sec_size + 7) / 8; i++)
  378.             bits[i] = 0;
  379.  
  380.         for (i=0; i<*msectors; i++)
  381.         {
  382.             sec = msectors[i+2];
  383.             bits[sec >> 3] |= flags[sec & 7];
  384.         }
  385.  
  386.         for (i=0; i<l_size; i++)
  387.         {
  388.             max = 0;
  389.             sd = linedefs[i].sd1;
  390.             if (sd != -1)
  391.             {
  392.                 sec = sidedefs[sd].sector;
  393.                 if (sec != -1 && bits[sec >> 3] & flags[sec & 7])
  394.                 {
  395.                     max++;
  396.                     mark_item(sd, &msidedefs);
  397.  
  398.                 } else
  399.                     unmark_item(sd, &msidedefs);
  400.             }
  401.  
  402.             sd = linedefs[i].sd2;
  403.             if (sd != -1)
  404.             {
  405.                 sec = sidedefs[sd].sector;
  406.                 if (sec != -1 && bits[sec >> 3] & flags[sec & 7])
  407.                 {
  408.                     max++;
  409.                     mark_item(sd, &msidedefs);
  410.  
  411.                 } else
  412.                     unmark_item(sd, &msidedefs);
  413.             }
  414.  
  415.             if (max)
  416.                 mark_item(i, &mlinedefs);
  417.             else
  418.                 unmark_item(i, &mlinedefs);
  419.         }
  420.     }
  421.  
  422.     free_mem(bits, "Sector marking list");
  423.  
  424. skip:
  425.     mark_line_vertexes();
  426.     return total;
  427. }
  428.  
  429. void mark_thing(int num)
  430. {
  431.     toggle_item(lthing_num[num], &mthings);
  432.     setcolor(old_mark_color);
  433.     box_local_thing(num);
  434. }
  435.  
  436. int boxmark(int mode)
  437. {
  438.     int i, xx, yy, x1, y1, x, y, z, temp, total=0;
  439.  
  440.     xx = x1 = mousex;
  441.     yy = y1 = mousey;
  442.     setwritemode(XOR_PUT);
  443.     setlinestyle(DOTTED_LINE, 0, 1);
  444.     setcolor(255);
  445.     sync_time();
  446.  
  447.     while(mouse_check() & 8)
  448.     {
  449.         if (wait(8))
  450.         {
  451.             setwritemode(COPY_PUT);
  452.             setlinestyle(SOLID_LINE, 0, 1);
  453.             plot_marked(-1);
  454.             setwritemode(XOR_PUT);
  455.             setlinestyle(DOTTED_LINE, 0, 1);
  456.             setcolor(255);
  457.         }
  458.  
  459.         if (mousex == x1 && mousey == y1)
  460.             continue;
  461.  
  462.         mouse_off();
  463.         if (x1 != xx || y1 != yy)
  464.         {
  465.             line(xx, yy, x1, yy);
  466.             line(xx, yy, xx, y1);
  467.             line(x1, yy, x1, y1);
  468.             line(xx, y1, x1, y1);
  469.         }
  470.  
  471.         x1 = mousex;
  472.         y1 = mousey;
  473.         if (x1 != xx || y1 != yy)
  474.         {
  475.             line(xx, yy, x1, yy);
  476.             line(xx, yy, xx, y1);
  477.             line(x1, yy, x1, y1);
  478.             line(xx, y1, x1, y1);
  479.         }
  480.         mouse_on();
  481.     }
  482.  
  483.     mouse_off();
  484.     if (x1 != xx || y1 != yy)
  485.     {
  486.         line(xx, yy, x1, yy);
  487.         line(xx, yy, xx, y1);
  488.         line(x1, yy, x1, y1);
  489.         line(xx, y1, x1, y1);
  490.     }
  491.     setlinestyle(SOLID_LINE, 0, 1);
  492.     setwritemode(COPY_PUT);
  493.  
  494.     if (x1 < xx)
  495.     {
  496.         temp = x1;
  497.         x1 = xx;
  498.         xx = temp;
  499.     }
  500.  
  501.     if (y1 < yy)
  502.     {
  503.         temp = y1;
  504.         y1 = yy;
  505.         yy = temp;
  506.     }
  507.  
  508.     if (mode == 5 || mode == 6)
  509.         *mlinedefs = 0;
  510.  
  511.     switch (mode)
  512.     {
  513.         case 0:
  514.             for (i=0; i<max_vertex; i++)
  515.             {
  516.                 x = adjvx[i];
  517.                 y = adjvy[i];
  518.  
  519.                 if (x > xx && y > yy && x < x1 && y < y1)
  520.                 {
  521.                     mark_vertex(i);
  522.                     total++;
  523.                 }
  524.             }
  525.             break;
  526.  
  527.         case 1:
  528.         case 5:
  529.             for (i=0; i<l_size; i++)
  530.             {
  531.                 z = linedefs[i].v1;
  532.                 x = adjvx[z];
  533.                 y = adjvy[z];
  534.  
  535.                 if (x > xx && y > yy && x < x1 && y < y1)
  536.                 {
  537.                     z = linedefs[i].v2;
  538.                     x = adjvx[z];
  539.                     y = adjvy[z];
  540.  
  541.                     if (x > xx && y > yy && x < x1 && y < y1)
  542.                     {
  543.                         mark_line(i);
  544.                         total++;
  545.                     }
  546.                 }
  547.             }
  548.             total = mark_sectors(mode, total);
  549.             break;
  550.  
  551.         case 2:
  552.         case 6:
  553.             for (i=0; i<l_size; i++)
  554.             {
  555.                 z = linedefs[i].v1;
  556.                 x = adjvx[z];
  557.                 y = adjvy[z];
  558.  
  559.                 if (x > xx && y > yy && x < x1 && y < y1)
  560.                 {
  561.                     mark_line(i);
  562.                     total++;
  563.                     continue;
  564.                 }
  565.  
  566.                 z = linedefs[i].v2;
  567.                 x = adjvx[z];
  568.                 y = adjvy[z];
  569.  
  570.                 if (x > xx && y > yy && x < x1 && y < y1)
  571.                 {
  572.                     mark_line(i);
  573.                     total++;
  574.                 }
  575.             }
  576.             total = mark_sectors(mode, total);
  577.             break;
  578.  
  579.         case 3:
  580.         case 4:
  581.             for (i=0; i<lthing_count; i++)
  582.             {
  583.                 x = lthingx[i];
  584.                 y = lthingy[i];
  585.  
  586.                 if (x > xx && y > yy && x < x1 && y < y1)
  587.                 {
  588.                     mark_thing(i);
  589.                     total++;
  590.                 }
  591.             }
  592.             break;
  593.     }
  594.     return total;
  595. }
  596.  
  597. void move_marked(void)
  598. {
  599.     int i, z, dx, dy, x, y, origx, origy, oldx, oldy;
  600.  
  601.     origx = oldx = re_x();
  602.     origy = oldy = re_y();
  603.  
  604.     sync_time();
  605.     while(1)
  606.     {
  607.         mouse_check();
  608.         x = re_x();
  609.         y = re_y();
  610.  
  611.         if (x != oldx || y != oldy)
  612.         {
  613.             dx = x - oldx;
  614.             dy = y - oldy;
  615.             oldx = x;
  616.             oldy = y;
  617.  
  618.             if (*mvertexes)
  619.             {
  620.                 for (i=0; i<*mvertexes; i++)
  621.                 {
  622.                     z = mvertexes[i+2];
  623.                     vertexes[z].x += dx;
  624.                     vertexes[z].y += dy;
  625.                 }
  626.                 draw_map();
  627.                 mouse_on();
  628.             }
  629. /* for all edit mode
  630.             for (i=0; i<*mthings; i++)
  631.             {
  632.                 z = mthings[i+2];
  633.                 things[z].x += dx;
  634.                 things[z].y += dy;
  635.             } */
  636.         }
  637.  
  638.         if (wait(8))
  639.             plot_marked(-1);
  640.  
  641.         if (!(button_status & 1))
  642.         {
  643.             mouse_off();
  644.             return;
  645.         }
  646.  
  647.         if (button_status & 2)
  648.         {
  649.             dx = origx - x;
  650.             dy = origy - y;
  651.  
  652.             for (i=0; i<*mvertexes; i++)
  653.             {
  654.                 z = mvertexes[i+2];
  655.                 vertexes[z].x += dx;
  656.                 vertexes[z].y += dy;
  657.             }
  658.  
  659.             ignore_button |= true_button;
  660.             draw_map();
  661.             return;
  662.         }
  663.     }
  664. }
  665. /*
  666. int thing_drag(void)
  667. {
  668.     int i, j, z, x, y, dx, dy, dx2, dy2, origx, origy;
  669.  
  670.     origx = x = crossx + 2;
  671.     origy = y = crossy + 2;
  672.  
  673.     while (1)
  674.     {
  675.         if (crossx+2 != x || crossy+2 != y)
  676.         {
  677.             dx = crossx + 2 - x;
  678.             dy = crossy + 2 - y;
  679.             dx2 = dx * scalers[scale];
  680.             dy2 = dy * scalers[scale];
  681.             x = crossx + 2;
  682.             y = crossy + 2;
  683.  
  684.             if (marked)
  685.             {
  686.                 if (*mvertexes)
  687.                 {
  688.                     for (i=0; i<*mthings; i++)
  689.                     {
  690.                         z = mthings[i+2];
  691.                         things[z].x += dx2;
  692.                         things[z].y -= dy2;
  693.                     }
  694.  
  695.                     for (i=0; i<*mvertexes; i++)
  696.                     {
  697.                         z = mvertexes[i+2];
  698.                         vertexes[z].x += dx2;
  699.                         vertexes[z].y -= dy2;
  700.                     }
  701.                     draw_map();
  702.                     old_mark_color = 0;
  703.                     mouse_on();
  704.  
  705.                 } else {
  706.                     plot_marked(0);
  707.                     for (i=0; i<*mthings; i++)
  708.                     {
  709.                         z = mthings[i+2];
  710.                         things[z].x += dx2;
  711.                         things[z].y -= dy2;
  712.  
  713.                         for (j=0; j<lthing_count; j++)
  714.                             if (lthing_num[j] == z)
  715.                             {
  716.                                 lthingx[j] += dx;
  717.                                 lthingy[j] += dy;
  718.                                 break;
  719.                             }
  720.                     }
  721.                     color_num--;
  722.                     plot_marked(-1);
  723.                 }
  724.  
  725.             } else {
  726.                 mouse_off();
  727.                 setcolor(cur_box_color);
  728.                 box_local_thing(cur_drag);
  729.  
  730.                 lthingx[cur_drag] += dx;
  731.                 lthingy[cur_drag] += dy;
  732.                 box_local_thing(cur_drag);
  733.                 mouse_on();
  734.  
  735.                 z = lthing_num[cur_drag];
  736.                 things[z].x += dx2;
  737.                 things[z].y -= dy2;
  738.             }
  739.         }
  740.  
  741.         if (wait(8))
  742.         {
  743.             if (marked)
  744.                 plot_marked(-1);
  745.  
  746.             else {
  747.                 i = rand_color();
  748.                 setcolor(i ^ cur_box_color);
  749.                 cur_box_color = i;
  750.                 box_local_thing(cur_drag);
  751.             }
  752.         }
  753.  
  754.         if (!(mouse_check() & 1))
  755.         {
  756.             draw_map();
  757.             old_mark_color = edit_mode = 0;
  758.             return 0;
  759.         }
  760.  
  761.         if (button_status & 2)
  762.         {
  763.             del_thing(cur_drag);
  764.             mouse_off();
  765.             draw_map();
  766.             await_release();
  767.             edit_mode = 0;
  768.             return 0;
  769.         }
  770.     }
  771. } */
  772.  
  773. void plot_marked(int color)
  774. {
  775.     char image[125];
  776.     int i, j, x, y, z, m, pmaxx, pmaxy, cross_status, color2;
  777.  
  778.     m = mouse;
  779.     color2 = color;
  780.     if (color == -1)
  781.     {
  782.         color_num++;
  783.         switch (color_num %= 6)
  784.         {
  785.             case 0:
  786.                 color = 137;
  787.                 color2 = 143;
  788.                 break;
  789.             case 1:
  790.             case 5:
  791.                 color = 139;
  792.                 color2 = 141;
  793.                 break;
  794.             case 2:
  795.             case 4:
  796.                 color = 141;
  797.                 color2 = 139;
  798.                 break;
  799.             case 3:
  800.                 color = 143;
  801.                 color2 = 137;
  802.         }
  803.     }
  804.  
  805.     if (mark_mask & 2)
  806.     {
  807.         if (color == 255)
  808.             for (i=0; i<*mlinedefs; i++)
  809.             {
  810.                 z = mlinedefs[i+2];
  811.                 wall_color(z);
  812.                 draw_line(z, SOLID_LINE);
  813.             }
  814.         else {
  815.             setcolor(color);
  816.             for (i=0; i<*mlinedefs; i++)
  817.                 draw_line(mlinedefs[i+2], SOLID_LINE);
  818.         }
  819.     }
  820.  
  821.     if (mark_mask & 1)
  822.     {
  823.         for (i=0; i<4; i++)
  824.             image[i] = point_ptr[point_size-1][i];
  825.         for (i=4; i<125; i++)
  826.         {
  827.             if (point_ptr[point_size-1][i])
  828.                 image[i] = color2;
  829.             else
  830.                 image[i] = 0;
  831.         }
  832.  
  833.         pmaxx = maxx - point_size * 2;
  834.         pmaxy = maxy - point_size * 2;
  835.         for (i=0; i<*mvertexes; i++)
  836.         {
  837.             z = mvertexes[i+2];
  838.             x = adjvx[z] - point_size;
  839.             y = adjvy[z] - point_size;
  840.             if (x >= 0 && y >= 0 && x < pmaxx && y < pmaxy)
  841.                 putimage(x, y, image, 0);
  842.         }
  843.     }
  844.  
  845.     if (mark_mask & 4)
  846.     {
  847.         if (m)
  848.             mouse_off();
  849.         setcolor(color ^ old_mark_color);
  850.         for (i=0; i<*mthings; i++)
  851.         {
  852.             z = mthings[i+2];
  853.             for (j=0; j<lthing_count; j++)
  854.                 if (lthing_num[j] == z)
  855.                 {
  856.                     box_local_thing(j);
  857.                     break;
  858.                 }
  859.         }
  860.     }
  861.  
  862.     if (m)
  863.         mouse_redraw();
  864.     old_mark_color = color;
  865.     return;
  866. }
  867.