4943 lines
141 KiB
C
4943 lines
141 KiB
C
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include <SDL/SDL.h>
|
|
#include <SDL/SDL_keysym.h>
|
|
|
|
#include "netmapr.h"
|
|
#include "constants.h"
|
|
|
|
SDL_Surface *screen, *buffer;
|
|
SDL_Surface *emptyimg;
|
|
SDL_Event event;
|
|
|
|
SDL_Color white = { 255, 255, 255, 0};
|
|
SDL_Color black = { 0, 0, 0, 0};
|
|
SDL_Color red = { 255, 0, 0, 0};
|
|
SDL_Color green = { 0, 255, 0, 0};
|
|
SDL_Color blue = { 0, 0, 255, 0};
|
|
SDL_Color yellow = { 255, 255, 0, 0};
|
|
SDL_Color cyan = { 0, 255, 255, 0};
|
|
SDL_Color purple = { 255, 0, 255, 0};
|
|
SDL_Color grey = { 90, 90, 90, 0};
|
|
SDL_Color grey2 = { 70, 70, 70, 0};
|
|
SDL_Color grey3 = { 50, 50, 50, 0};
|
|
SDL_Color grey4 = { 30, 30, 30, 0};
|
|
|
|
SDL_Cursor *normalmouse;
|
|
SDL_Cursor *objmouse;
|
|
SDL_Cursor *textmouse;
|
|
|
|
|
|
xy_t fillstack[MAXFILLSTACK];
|
|
int fillstackptr = 0;
|
|
|
|
SDL_Color fgcol;
|
|
SDL_Color objfillcol;
|
|
|
|
int modified = FALSE;
|
|
|
|
int numobjtypes = 0;
|
|
int numletters = 0;
|
|
int numbuttons = 0;
|
|
int nummaps = 1;
|
|
|
|
int history[MAXHISTORY];
|
|
int numhistory = 0;
|
|
|
|
int children[MAXCHILDREN];
|
|
int numchildren = 0;
|
|
|
|
|
|
char currentfilename[BUFLEN];
|
|
int state = S_NONE;
|
|
SDL_Surface *bg; /* background for temp images*/
|
|
int *linebg; /* background for temp lines */
|
|
int bgx,bgy;
|
|
int bgw,bgh;
|
|
int xoff,yoff;
|
|
SDL_Rect temparea;
|
|
char statustext[BUFLEN];
|
|
|
|
int curmap = 0;
|
|
|
|
int startx,starty;
|
|
int textanchor;
|
|
char text[BUFLEN];
|
|
int startobj,endobj;
|
|
|
|
char progdir[BUFLEN];
|
|
|
|
int shift;
|
|
|
|
int main (int argc, char **argv) {
|
|
int done;
|
|
int c;
|
|
int mod;
|
|
int o;
|
|
Uint32 oldticks = 0;
|
|
Uint32 ticks;
|
|
int doubleclick = FALSE;
|
|
int autoload = FALSE;
|
|
|
|
if (argc == 2) {
|
|
strcpy(text, argv[1]);
|
|
autoload = TRUE;
|
|
}
|
|
|
|
if (getenv("NETMAPRDIR") != NULL) {
|
|
strncpy(progdir, getenv("NETMAPRDIR"), BUFLEN);
|
|
} else {
|
|
strcpy(progdir, "/usr/local/share/netmapr");
|
|
}
|
|
|
|
if (initgraphics()) {
|
|
printf("Error initialising graphics.\n");
|
|
exit(1);
|
|
}
|
|
atexit(cleanup);
|
|
|
|
/* TEST */
|
|
|
|
if (autoload) {
|
|
loadmap();
|
|
strcpy(text, "");
|
|
}
|
|
|
|
drawscreen();
|
|
|
|
/* main loop */
|
|
done = 0;
|
|
|
|
while (!done) {
|
|
/* check for input */
|
|
while (SDL_PollEvent(&event)) {
|
|
switch (event.type) {
|
|
case SDL_MOUSEBUTTONDOWN:
|
|
if (isonmap(event.button.x, event.button.y)) {
|
|
if (state == S_NONE) {
|
|
mod = SDL_GetModState();
|
|
if ((event.button.button == SDL_BUTTON_LEFT) && ((mod & KMOD_CTRL) == 0)) {
|
|
/* is there a selected link? if so check for it first */
|
|
if ((map[curmap].selecteditemtype == T_LINK) && (map[curmap].selecteditem != -1) &&
|
|
(isonlinkdst(map[curmap].selecteditem, event.button.x,event.button.y)) ) {
|
|
|
|
map[curmap].curlink = map[curmap].selecteditem;
|
|
startlinkdstmove(event.button.x, event.button.y);
|
|
} else if ((map[curmap].selecteditemtype == T_LINK) && (map[curmap].selecteditem != -1) &&
|
|
(isonlinksrc(map[curmap].selecteditem, event.button.x,event.button.y)) ) {
|
|
map[curmap].curlink = map[curmap].selecteditem;
|
|
startlinksrcmove(event.button.x, event.button.y);
|
|
} else if ( ((map[curmap].selecteditemtype == T_LINK) || (map[curmap].selecteditemtype == T_LINKPOINT))
|
|
&& (map[curmap].selecteditem != -1) &&
|
|
(isonlinkpoint(map[curmap].selecteditem, event.button.x,event.button.y) != -1) ) {
|
|
map[curmap].curlink = map[curmap].selecteditem;
|
|
map[curmap].curlinkpoint = isonlinkpoint(map[curmap].selecteditem, event.button.x,event.button.y);
|
|
startlinkpointmove(event.button.x, event.button.y);
|
|
} else {
|
|
// move/select object
|
|
o = thingat(event.button.x, event.button.y);
|
|
if (o != -1) {
|
|
switch (map[curmap].thing[o].type) {
|
|
case T_OBJECT:
|
|
map[curmap].curobj = map[curmap].thing[o].id;
|
|
startobjmove(event.button.x,event.button.y);
|
|
break;
|
|
case T_LINK:
|
|
map[curmap].curlink = map[curmap].thing[o].id;
|
|
startlinkmove(event.button.x, event.button.y);
|
|
break;
|
|
case T_TEXT:
|
|
map[curmap].curtext = map[curmap].thing[o].id;
|
|
starttextmove(event.button.x, event.button.y);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
} else if ((event.button.button == SDL_BUTTON_MIDDLE) ||
|
|
((event.button.button == SDL_BUTTON_LEFT) && (mod & KMOD_CTRL))) {
|
|
// if we're over an object, start drawing a new link
|
|
o = objat(event.button.x, event.button.y);
|
|
if (o != -1) {
|
|
map[curmap].curobj = o;
|
|
startlink(event.button.x,event.button.y);
|
|
}
|
|
} else if (event.button.button == SDL_BUTTON_RIGHT) {
|
|
// resize object
|
|
o = objat(event.button.x, event.button.y);
|
|
if (o != -1) {
|
|
map[curmap].curobj = o;
|
|
startresize(event.button.x,event.button.y);
|
|
} else {
|
|
// resize text
|
|
o = textat(event.button.x, event.button.y);
|
|
if (o != -1) {
|
|
map[curmap].curtext = o;
|
|
startresizetext(event.button.x,event.button.y);
|
|
}
|
|
}
|
|
} else if (event.button.button == SDL_BUTTON_WHEELUP) {
|
|
if (map[curmap].selecteditem != -1) {
|
|
/* raise the selected object */
|
|
raiseselected();
|
|
}
|
|
} else if (event.button.button == SDL_BUTTON_WHEELDOWN) {
|
|
if (map[curmap].selecteditem != -1) {
|
|
/* lower the selected object */
|
|
lowerselected();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case SDL_MOUSEBUTTONUP:
|
|
mod = SDL_GetModState();
|
|
if ((event.button.button == SDL_BUTTON_LEFT) && ((mod & KMOD_CTRL) == 0)) {
|
|
ticks = SDL_GetTicks();
|
|
if ((ticks - oldticks) <= DOUBLECLICKTHRES) {
|
|
doubleclick = TRUE;
|
|
} else {
|
|
doubleclick = FALSE;
|
|
}
|
|
oldticks = ticks;
|
|
if (isonmap(event.button.x, event.button.y)) {
|
|
if (state != S_REALLYQUIT) {
|
|
//if ((doubleclick) && (objat(event.button.x, event.button.y) == map[curmap].selecteditem)) {
|
|
if (doubleclick) {
|
|
o = objat(event.button.x, event.button.y);
|
|
|
|
/* only works on an object */
|
|
//if (map[curmap].selecteditem != -1) {
|
|
if (o != -1) {
|
|
/* can't create a new child via double click */
|
|
if (map[curmap].obj[o].child != -1) {
|
|
changestate(S_NONE);
|
|
drillto(map[curmap].obj[o].child);
|
|
} else {
|
|
sprintf(statustext, "Cannot drill down - object has no children (use drill tool to create one).");
|
|
map[curmap].selecteditem = -1;
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (state == S_NONE) {
|
|
if (map[curmap].selecteditem != -1) {
|
|
map[curmap].selecteditem = -1;
|
|
map[curmap].selecteditemtype = T_EMPTY;
|
|
sprintf(statustext,"Objects/lines deselected.\n");
|
|
drawmap();
|
|
}
|
|
} else if (state == S_REALLYQUIT) {
|
|
o = getyn(event.button.x, event.button.y);
|
|
if (o == YES) {
|
|
done = TRUE;
|
|
} else {
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
}
|
|
} else if (state == S_MATCHSIZE) {
|
|
o = objat(event.button.x, event.button.y);
|
|
if (o == -1) {
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "Size match mode aborted.");
|
|
drawstatusbar();
|
|
} else {
|
|
int n;
|
|
/* resize selected item to match one which was clicked */
|
|
map[curmap].obj[map[curmap].selecteditem].w = map[curmap].obj[o].w;
|
|
map[curmap].obj[map[curmap].selecteditem].h = map[curmap].obj[o].h;
|
|
/* adjust offsets on all links to/from object */
|
|
for (n = 0; n < map[curmap].numlinks; n++) {
|
|
if (map[curmap].olink[n].srcobj == map[curmap].selecteditem) {
|
|
map[curmap].olink[n].srcxoff = (map[curmap].obj[o].w / 2);
|
|
map[curmap].olink[n].srcyoff = (map[curmap].obj[o].h / 2);
|
|
}
|
|
if (map[curmap].olink[n].dstobj == map[curmap].selecteditem) {
|
|
map[curmap].olink[n].dstxoff = (map[curmap].obj[o].w / 2);
|
|
map[curmap].olink[n].dstyoff = (map[curmap].obj[o].h / 2);
|
|
}
|
|
}
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "Object #%d resized to match object #%d.",map[curmap].selecteditem,o);
|
|
drawmap();
|
|
}
|
|
} else if (state == S_MATCHX) {
|
|
o = objat(event.button.x, event.button.y);
|
|
if (o == -1) {
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "X position match mode aborted.");
|
|
drawstatusbar();
|
|
} else {
|
|
/* move selected item to match one which was clicked */
|
|
/* match middle of objects! */
|
|
map[curmap].obj[map[curmap].selecteditem].x =
|
|
(map[curmap].obj[o].x + (map[curmap].obj[o].w/2))
|
|
-
|
|
(map[curmap].obj[map[curmap].selecteditem].w/2);
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "Object #%d X relocated to match object #%d.",map[curmap].selecteditem,o);
|
|
drawmap();
|
|
}
|
|
} else if (state == S_MATCHY) {
|
|
o = objat(event.button.x, event.button.y);
|
|
if (o == -1) {
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "Y position match mode aborted.");
|
|
drawstatusbar();
|
|
} else {
|
|
/* move selected item to match one which was clicked */
|
|
map[curmap].obj[map[curmap].selecteditem].y =
|
|
(map[curmap].obj[o].y + (map[curmap].obj[o].h / 2))
|
|
-
|
|
map[curmap].obj[map[curmap].selecteditem].h/2;
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "Object #%d Y relocated to match object #%d.",map[curmap].selecteditem,o);
|
|
drawmap();
|
|
}
|
|
} else if (state == S_OBJMOVING) {
|
|
/* has mouse actually moved? */
|
|
if ((event.button.x == startx) && (event.button.y == starty)) {
|
|
/* select the object */
|
|
map[curmap].selecteditem = map[curmap].curobj;
|
|
map[curmap].selecteditemtype = T_OBJECT;
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "Object #%d (%s) selected.\n",map[curmap].selecteditem, objtype[map[curmap].obj[map[curmap].selecteditem].type].name);
|
|
drawmap();
|
|
} else {
|
|
// actually move the object
|
|
if (!endobjmove(event.button.x, event.button.y)) {
|
|
sprintf(statustext, "Object #%d moved to (%d,%d).\n",map[curmap].curobj,event.button.x, event.button.y);
|
|
}
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
|
|
}
|
|
} else if (state == S_LINKMOVING) {
|
|
/* has mouse actually moved? */
|
|
if ((event.button.x == startx) && (event.button.y == starty)) {
|
|
/* select the link */
|
|
map[curmap].selecteditem = map[curmap].curlink;
|
|
map[curmap].selecteditemtype = T_LINK;
|
|
changestate(S_NONE);
|
|
sprintf(statustext,"Link #%d selected.\n",map[curmap].selecteditem);
|
|
drawmap();
|
|
} else {
|
|
// actually move the link
|
|
endlinkmove(event.button.x, event.button.y);
|
|
changestate(S_NONE);
|
|
sprintf(statustext,"Link #%d moved to (%d,%d).\n",map[curmap].curlink,event.button.x, event.button.y);
|
|
drawmap();
|
|
}
|
|
} else if (state == S_LINKPOINTMOVE) {
|
|
/* has mouse actually moved? */
|
|
if ((event.button.x == startx) && (event.button.y == starty)) {
|
|
/* select the link point */
|
|
map[curmap].selecteditem = map[curmap].curlink;
|
|
map[curmap].selecteditemtype = T_LINKPOINT;
|
|
map[curmap].selectedlinkpoint = map[curmap].curlinkpoint;
|
|
changestate(S_NONE);
|
|
sprintf(statustext,"Link #%d point #%d selected.\n",map[curmap].selecteditem,map[curmap].selectedlinkpoint);
|
|
drawmap();
|
|
} else {
|
|
// actually move the link
|
|
endlinkpointmove(event.button.x, event.button.y);
|
|
changestate(S_NONE);
|
|
sprintf(statustext,"Link #%d moved to (%d,%d).\n",map[curmap].curlink,event.button.x, event.button.y);
|
|
drawmap();
|
|
}
|
|
} else if (state == S_TEXTMOVING) {
|
|
/* has mouse actually moved? */
|
|
if ((event.button.x == startx) && (event.button.y == starty)) {
|
|
/* select the object */
|
|
map[curmap].selecteditem = map[curmap].curtext;
|
|
map[curmap].selecteditemtype = T_TEXT;
|
|
changestate(S_NONE);
|
|
sprintf(statustext,"Text item #%d selected.\n",map[curmap].selecteditem);
|
|
drawmap();
|
|
} else {
|
|
// actually move the text
|
|
if (!endtextmove(event.button.x, event.button.y)) {
|
|
sprintf(statustext,"Text item #%d moved to (%d,%d).\n",map[curmap].curtext,event.button.x, event.button.y);
|
|
}
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
|
|
}
|
|
} else if (state == S_LINKSRCMOVE) {
|
|
// actually move the link src endpoint
|
|
endlinksrcmove(event.button.x, event.button.y);
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else if (state == S_LINKDSTMOVE) {
|
|
// actually move the link dst endpoint
|
|
endlinkdstmove(event.button.x, event.button.y);
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else if (state == S_ADDOBJ) {
|
|
/* create a new object */
|
|
createobject(map[curmap].selectedtype, event.button.x, event.button.y);
|
|
drawmap();
|
|
changestate(S_NONE);
|
|
} else if (state == S_ADDTEXT) {
|
|
/* start listening for text input */
|
|
startx = event.button.x;
|
|
starty = event.button.y;
|
|
textanchor = objat(event.button.x,event.button.y);
|
|
if (textanchor != -1) {
|
|
startx = map[curmap].obj[textanchor].x;
|
|
starty = map[curmap].obj[textanchor].y + map[curmap].obj[textanchor].h+3;
|
|
}
|
|
|
|
strcpy(text, "");
|
|
|
|
bg = NULL;
|
|
updatetextcursor();
|
|
|
|
changestate(S_TYPETEXT);
|
|
} else if (state == S_FGCOL) {
|
|
getcolor(screen, event.button.x, event.button.y, &fgcol);
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_LINK) {
|
|
map[curmap].olink[map[curmap].selecteditem].col = fgcol;
|
|
sprintf(statustext, "Colour of link #%d changed to R=%d,G=%d,B=%d",map[curmap].selecteditem, fgcol.r,fgcol.g,fgcol.b);
|
|
} else if (map[curmap].selecteditemtype == T_TEXT) {
|
|
map[curmap].textob[map[curmap].selecteditem].c = fgcol;
|
|
sprintf(statustext, "Colour of text item #%d changed to R=%d,G=%d,B=%d",map[curmap].selecteditem, fgcol.r,fgcol.g,fgcol.b);
|
|
} else {
|
|
sprintf(statustext, "Foreground colour selected: R=%d,G=%d,B=%d",fgcol.r,fgcol.g,fgcol.b);
|
|
}
|
|
} else {
|
|
sprintf(statustext, "Foreground colour selected: R=%d,G=%d,B=%d",fgcol.r,fgcol.g,fgcol.b);
|
|
}
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else if (state == S_CREATETELE) {
|
|
int pos;
|
|
|
|
if (event.button.y >= 50) {
|
|
pos = (event.button.y - 50) / (DEFTEXTH*2);
|
|
pos--;
|
|
if (pos == -1) {
|
|
map[curmap].obj[map[curmap].selecteditem].child = pos;
|
|
sprintf(statustext, "Map link removed.");
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else if (pos <= (nummaps-1)) {
|
|
if ((map[curmap].selecteditem != -1) && (map[curmap].selecteditemtype == T_OBJECT)) {
|
|
if (pos != curmap) {
|
|
map[curmap].obj[map[curmap].selecteditem].child = pos;
|
|
sprintf(statustext, "Map link created.");
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else {
|
|
sprintf(statustext, "ERROR: Cannot link to current map!");
|
|
drawstatusbar();
|
|
}
|
|
}
|
|
} else { /* mouse is not over a map name */
|
|
sprintf(statustext, "Map link creation cancelled.");
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
}
|
|
} else {
|
|
sprintf(statustext, "Map link creation cancelled.");
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
}
|
|
}
|
|
|
|
} else if (isonobox(event.button.x, event.button.y)) {
|
|
int tempx,tempy;
|
|
|
|
tempx = (event.button.x - obox.x) / obox.gridsize;
|
|
tempy = (event.button.y - obox.y) / obox.gridsize;
|
|
map[curmap].selectedtype = tempy*obox.gridrowlen + tempx + (obox.pos*3);
|
|
if (map[curmap].selectedtype >= numobjtypes) map[curmap].selectedtype = numobjtypes-1;
|
|
sprintf(statustext,"Object type '%s' selected.\n",objtype[map[curmap].selectedtype].name);
|
|
drawstatusbar();
|
|
|
|
drawobox();
|
|
} else if (isongoback(event.button.x, event.button.y)) {
|
|
/* go back */
|
|
goback();
|
|
} else if (isonmapname(event.button.x, event.button.y)) {
|
|
/* rename current map */
|
|
startx = 1;
|
|
starty = (map[curmap].height/2)-2;
|
|
bg = NULL;
|
|
strcpy(text, map[curmap].name);
|
|
changestate(S_MAPNAMING);
|
|
drawmap();
|
|
break;
|
|
} else if (isonmapboxchildren(event.button.x, event.button.y)) {
|
|
int pos;
|
|
/* change to child */
|
|
pos = (event.button.y - (mapbox.y+(DEFTEXTH*2)+2)) / DEFTEXTH;
|
|
if (pos >= numchildren) {
|
|
sprintf(statustext, "ERROR: Invalid child map %d (max is %d).",pos,numchildren);
|
|
drawstatusbar();
|
|
} else {
|
|
drillto(children[pos]);
|
|
}
|
|
break;
|
|
} else if (isontoolbox(event.button.x, event.button.y)) {
|
|
int tempx,tempy, selection;
|
|
|
|
tempx = (event.button.x - toolbox.x) / (toolbox.gridsize+3);
|
|
tempy = (event.button.y - toolbox.y) / (toolbox.gridsize+3);
|
|
selection = tempy*toolbox.gridrowlen + tempx;
|
|
switch (selection) {
|
|
case TB_POINTER:
|
|
/* special case - update sbar */
|
|
sprintf(statustext, "Selection mode entered.");
|
|
drawstatusbar();
|
|
changestate(S_NONE);
|
|
map[curmap].curobj = -1;
|
|
break;
|
|
case TB_ADDOBJ:
|
|
changestate(S_ADDOBJ);
|
|
if (map[curmap].selectedtype < 0) map[curmap].selectedtype = 0;
|
|
break;
|
|
case TB_ADDTEXT:
|
|
changestate(S_ADDTEXT);
|
|
break;
|
|
case TB_NEW:
|
|
initvars();
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
break;
|
|
case TB_MATCHSIZE:
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_OBJECT) {
|
|
changestate(S_MATCHSIZE);
|
|
drawmap();
|
|
}
|
|
}
|
|
break;
|
|
case TB_MATCHX:
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_OBJECT) {
|
|
changestate(S_MATCHX);
|
|
drawmap();
|
|
}
|
|
}
|
|
break;
|
|
case TB_MATCHY:
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_OBJECT) {
|
|
changestate(S_MATCHY);
|
|
drawmap();
|
|
}
|
|
}
|
|
break;
|
|
case TB_FGCOL:
|
|
changestate(S_FGCOL);
|
|
drawmap();
|
|
break;
|
|
case TB_FILLCOL:
|
|
sprintf(statustext, "Select Fill Colour feature not yet implemented.");
|
|
drawstatusbar();
|
|
break;
|
|
case TB_LINESTYLE:
|
|
sprintf(statustext, "Select Line Style feature not yet implemented.");
|
|
drawstatusbar();
|
|
break;
|
|
case TB_DELETEMAP:
|
|
sprintf(statustext, "Delete Current Map feature not yet implemented.");
|
|
drawstatusbar();
|
|
break;
|
|
case TB_CREATETELE:
|
|
if ((map[curmap].selecteditemtype == T_OBJECT) && (map[curmap].selecteditem != -1)) {
|
|
changestate(S_CREATETELE);
|
|
drawmap();
|
|
} else {
|
|
sprintf(statustext,"Cannot create map link - no object selected!");
|
|
drawstatusbar();
|
|
}
|
|
break;
|
|
|
|
case TB_DRILLDOWN:
|
|
if ((map[curmap].selecteditemtype == T_OBJECT) && (map[curmap].selecteditem != -1)) {
|
|
drillto(map[curmap].obj[map[curmap].selecteditem].child);
|
|
} else {
|
|
sprintf(statustext,"Cannot drill down - no object selected!");
|
|
drawstatusbar();
|
|
}
|
|
break;
|
|
case TB_SAVE:
|
|
startx = 1;
|
|
starty = (map[curmap].height/2)-2;
|
|
bg = NULL;
|
|
strcpy(text, currentfilename);
|
|
changestate(S_SAVING);
|
|
drawmap();
|
|
break;
|
|
case TB_LOAD:
|
|
startx = 1;
|
|
starty = (map[curmap].height/2)-2;
|
|
bg = NULL;
|
|
strcpy(text, currentfilename);
|
|
changestate(S_LOADING);
|
|
drawmap();
|
|
break;
|
|
|
|
}
|
|
drawtoolbox();
|
|
} /* end if is on map */
|
|
} else if ((event.button.button == SDL_BUTTON_MIDDLE) ||
|
|
((event.button.button == SDL_BUTTON_LEFT) && (mod & KMOD_CTRL))) {
|
|
if (state == S_DRAWLINK) {
|
|
// finish drawing link
|
|
o = objat(event.button.x, event.button.y);
|
|
if ((o != -1) && (o != startobj)) {
|
|
endobj = o;
|
|
endlink(event.button.x,event.button.y);
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else {
|
|
pasteline(screen,linebg);
|
|
sprintf(statustext,"Aborting link #%d.\n", map[curmap].numlinks);
|
|
drawstatusbar();
|
|
}
|
|
changestate(S_NONE);
|
|
} else if (state == S_NONE) {
|
|
/* are we on a link? if so, add a point to it */
|
|
o = linkat(event.button.x, event.button.y);
|
|
if (o != -1) {
|
|
addlinkpoint(o, event.button.x, event.button.y);
|
|
/* select the link */
|
|
map[curmap].selecteditemtype = T_LINK;
|
|
map[curmap].selecteditem = o;
|
|
drawmap();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
} else if (event.button.button == SDL_BUTTON_RIGHT) {
|
|
if (state == S_RESIZING) {
|
|
// end resize
|
|
endresize(event.button.x, event.button.y);
|
|
changestate(S_NONE);
|
|
} else if (state == S_TEXTRESIZING) {
|
|
// end text resize
|
|
endtextresize(event.button.x, event.button.y);
|
|
changestate(S_NONE);
|
|
}
|
|
}
|
|
break;
|
|
case SDL_MOUSEMOTION:
|
|
switch (state) {
|
|
case S_OBJMOVING:
|
|
updatemoveshadow(event.button.x, event.button.y);
|
|
break;
|
|
case S_RESIZING:
|
|
updateresizeshadow(event.button.x, event.button.y);
|
|
break;
|
|
case S_DRAWLINK:
|
|
updatelinkshadow(event.button.x, event.button.y);
|
|
break;
|
|
case S_TEXTMOVING:
|
|
updatetextshadow(event.button.x, event.button.y);
|
|
break;
|
|
case S_TEXTRESIZING:
|
|
updateresizetextshadow(event.button.x, event.button.y);
|
|
break;
|
|
case S_LINKPOINTMOVE:
|
|
updatelinkpointshadow(event.button.x, event.button.y);
|
|
break;
|
|
|
|
}
|
|
break;
|
|
case SDL_QUIT:
|
|
if (modified) {
|
|
strcpy(text, "Changes not saved - really quit?");
|
|
changestate(S_REALLYQUIT);
|
|
drawmap();
|
|
} else {
|
|
done = TRUE;
|
|
}
|
|
break;
|
|
case SDL_VIDEOEXPOSE:
|
|
/* redraw screen */
|
|
drawscreen();
|
|
break;
|
|
case SDL_KEYDOWN:
|
|
c = event.key.keysym.sym;
|
|
mod = SDL_GetModState();
|
|
/* state independant */
|
|
if (mod & KMOD_SHIFT) {
|
|
if ((c >= 'a') && (c <= 'z')) {
|
|
c -= 32;
|
|
} else if (c == '1') {
|
|
c = '!';
|
|
} else if (c == '2') {
|
|
c = '@';
|
|
} else if (c == '3') {
|
|
c = '#';
|
|
} else if (c == '4') {
|
|
c = '$';
|
|
} else if (c == '5') {
|
|
c = '%';
|
|
} else if (c == '6') {
|
|
c = '^';
|
|
} else if (c == '7') {
|
|
c = '&';
|
|
} else if (c == '8') {
|
|
c = '*';
|
|
} else if (c == '9') {
|
|
c = '(';
|
|
} else if (c == '0') {
|
|
c = ')';
|
|
} else if (c == '-') {
|
|
c = '_';
|
|
} else if (c == '=') {
|
|
c = '+';
|
|
} else if (c == '\\') {
|
|
c = '|';
|
|
} else if (c == ';') {
|
|
c = ':';
|
|
} else if (c == '\'') {
|
|
c = '"';
|
|
} else if (c == ',') {
|
|
c = '<';
|
|
} else if (c == '.') {
|
|
c = '>';
|
|
} else if (c == '/') {
|
|
c = '?';
|
|
}
|
|
}
|
|
/* state dependant */
|
|
if ((state == S_TYPETEXT) || (state == S_SAVING) || (state == S_LOADING) || (state == S_MAPNAMING)) {
|
|
if ((c >= FIRSTLET) && (c <= LASTLET)) {
|
|
char temptext[2];
|
|
sprintf(temptext, "%c", c);
|
|
strcat(text, temptext);
|
|
updatetextcursor();
|
|
} else if (c == SDLK_ESCAPE) {
|
|
sprintf(statustext, "Aborted.");
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else if (c == ' ') {
|
|
strcat(text, " ");
|
|
updatetextcursor();
|
|
} else if (c == SDLK_BACKSPACE) {
|
|
text[strlen(text)-1] = '\0';
|
|
updatetextcursor();
|
|
} else if (c == 13) { /* enter */
|
|
if (state == S_TYPETEXT) {
|
|
endtext();
|
|
} else if (state == S_SAVING) {
|
|
savemap();
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else if (state == S_LOADING) {
|
|
loadmap();
|
|
changestate(S_NONE);
|
|
drawmap();
|
|
} else if (state == S_MAPNAMING) {
|
|
/* rename map */
|
|
strcpy(map[curmap].name,text);
|
|
changestate(S_NONE);
|
|
sprintf(statustext, "Map #%d renamed to '%s'.",curmap,map[curmap].name);
|
|
drawmap();
|
|
}
|
|
}
|
|
} else {
|
|
if (c == 'a') { /* add map[curmap].object */
|
|
if (state == S_NONE) {
|
|
changestate(S_ADDOBJ);
|
|
}
|
|
}
|
|
if (c == 't') { /* add text */
|
|
if (state == S_NONE) {
|
|
changestate(S_ADDTEXT);
|
|
}
|
|
}
|
|
if (c == 's') { /* save */
|
|
startx = 1;
|
|
starty = (map[curmap].height/2)-2;
|
|
bg = NULL;
|
|
strcpy(text, currentfilename);
|
|
changestate(S_SAVING);
|
|
drawmap();
|
|
}
|
|
if ((c == 'l') || (c == 'o')) { /* load, open */
|
|
startx = 1;
|
|
starty = (map[curmap].height/2)-2;
|
|
bg = NULL;
|
|
strcpy(text, currentfilename);
|
|
changestate(S_LOADING);
|
|
drawmap();
|
|
}
|
|
if ((c == ',') || (c == 'q')) { /* scroll object box up */
|
|
if (obox.pos > 0) {
|
|
obox.pos--;
|
|
drawobox();
|
|
}
|
|
}
|
|
if ((c == '.') || (c == 'w')) { /* scroll object box down */
|
|
int fitx,fity,fit;
|
|
|
|
/* figure out how many objects we can fit in the box */
|
|
fitx = (obox.width / obox.gridsize);
|
|
fity = ((obox.height+3) / obox.gridsize);
|
|
fit = fitx * fity;
|
|
|
|
/* check if incrementing position is okay or not */
|
|
if (((obox.pos+1)*3 + fit) <= (numobjtypes+2)) {
|
|
obox.pos++;
|
|
drawobox();
|
|
}
|
|
}
|
|
if (c == 'x') {
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_OBJECT) {
|
|
changestate(S_MATCHX);
|
|
drawmap();
|
|
}
|
|
}
|
|
}
|
|
if (c == 'y') {
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_OBJECT) {
|
|
changestate(S_MATCHY);
|
|
drawmap();
|
|
}
|
|
}
|
|
}
|
|
if (c == 'b') {
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_OBJECT) {
|
|
changestate(S_MATCHSIZE);
|
|
drawmap();
|
|
}
|
|
}
|
|
}
|
|
if (c == 'd') { /* drill down */
|
|
if (state == S_NONE) {
|
|
if ((map[curmap].selecteditemtype == T_OBJECT) && (map[curmap].selecteditem != -1)) {
|
|
drillto(map[curmap].obj[map[curmap].selecteditem].child);
|
|
} else {
|
|
sprintf(statustext,"Cannot drill down - no object selected!");
|
|
drawstatusbar();
|
|
}
|
|
} else {
|
|
sprintf(statustext,"Cannot drill down in state %d.",state);
|
|
drawstatusbar();
|
|
}
|
|
}
|
|
if (c == SDLK_BACKSPACE) {
|
|
goback();
|
|
}
|
|
if (c == SDLK_DELETE) {
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_LINKPOINT) {
|
|
int i;
|
|
for (i = map[curmap].selectedlinkpoint; i < (map[curmap].olink[map[curmap].selecteditem].npoints-1); i++) {
|
|
map[curmap].olink[map[curmap].selecteditem].point[i].x = map[curmap].olink[map[curmap].selecteditem].point[i+1].x;
|
|
map[curmap].olink[map[curmap].selecteditem].point[i].y = map[curmap].olink[map[curmap].selecteditem].point[i+1].y;
|
|
}
|
|
map[curmap].olink[map[curmap].selecteditem].npoints--;
|
|
|
|
/* move selection to next point on same line */
|
|
if (map[curmap].olink[map[curmap].selecteditem].npoints > 0) {
|
|
if (map[curmap].selectedlinkpoint >= map[curmap].olink[map[curmap].selecteditem].npoints) {
|
|
map[curmap].selectedlinkpoint = map[curmap].olink[map[curmap].selecteditem].npoints-1;
|
|
}
|
|
} else {
|
|
/* deselect point (leave link selected) */
|
|
map[curmap].selectedlinkpoint = -1;
|
|
map[curmap].selecteditemtype = T_LINK;
|
|
}
|
|
|
|
sprintf(statustext, "Deleted link #%d point #%d.",map[curmap].selecteditem,map[curmap].selectedlinkpoint);
|
|
drawmap();
|
|
} else {
|
|
deletething(map[curmap].selecteditem,map[curmap].selecteditemtype);
|
|
}
|
|
}
|
|
}
|
|
if (c == ']') { /* raise */
|
|
if (map[curmap].selecteditem != -1) {
|
|
/* raise the selected map[curmap].object */
|
|
raiseselected();
|
|
}
|
|
}
|
|
if (c == '[') { /* lower */
|
|
if (map[curmap].selecteditem != -1) {
|
|
/* lower the selected map[curmap].object */
|
|
lowerselected();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
} /* end main loop */
|
|
|
|
return 0;
|
|
}
|
|
|
|
void addlinkpoint(int linkid, int x, int y) {
|
|
int pos;
|
|
int i;
|
|
|
|
pos = findpointpos(&map[curmap].olink[linkid],x,y);
|
|
|
|
map[curmap].olink[linkid].npoints++;
|
|
|
|
/* shuffle points from that point upwards */
|
|
for (i = (map[curmap].olink[linkid].npoints-1);i > pos ; i--) {
|
|
map[curmap].olink[linkid].point[i] = map[curmap].olink[linkid].point[i-1];
|
|
}
|
|
|
|
map[curmap].olink[linkid].point[pos].x = x;
|
|
map[curmap].olink[linkid].point[pos].y = y;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext, "Point added to link #%d",linkid);
|
|
}
|
|
|
|
int addvector(vectorimg_t *vimg, int type, int x1, int y1, int x2, int y2, SDL_Color *c) {
|
|
|
|
if ((vimg->vnum + 1) >= MAXVECTORSPERIMAGE) return TRUE;
|
|
vimg->vector[vimg->vnum].type = type;
|
|
vimg->vector[vimg->vnum].x1 = x1;
|
|
vimg->vector[vimg->vnum].y1 = y1;
|
|
vimg->vector[vimg->vnum].x2 = x2;
|
|
vimg->vector[vimg->vnum].y2 = y2;
|
|
vimg->vector[vimg->vnum].c.r = c->r;
|
|
vimg->vector[vimg->vnum].c.g = c->g;
|
|
vimg->vector[vimg->vnum].c.b = c->b;
|
|
vimg->vnum = vimg->vnum + 1;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void changestate(int newstate) {
|
|
if (newstate != state) {
|
|
|
|
if ((state == S_ADDOBJ) || (state == S_ADDTEXT)) {
|
|
/* change mouse back to normal */
|
|
SDL_SetCursor(normalmouse);
|
|
}
|
|
if (newstate == S_ADDOBJ) SDL_SetCursor(objmouse);
|
|
if (newstate == S_ADDTEXT) SDL_SetCursor(textmouse);
|
|
|
|
state = newstate;
|
|
drawtoolbox();
|
|
switch (state) {
|
|
case S_NONE:
|
|
//sprintf(statustext,"Selection mode enabled.\n"); fflush(stdout);
|
|
break;
|
|
case S_ADDOBJ:
|
|
sprintf(statustext,"Object creation mode enabled.\n"); fflush(stdout);
|
|
break;
|
|
case S_ADDTEXT:
|
|
sprintf(statustext,"Text creation mode entered.\n"); fflush(stdout);
|
|
break;
|
|
case S_TYPETEXT:
|
|
sprintf(statustext,"Text entry mode entered.\n"); fflush(stdout);
|
|
break;
|
|
case S_MATCHSIZE:
|
|
sprintf(statustext,"Size-matching mode entered - select object to copy size from...\n"); fflush(stdout);
|
|
break;
|
|
case S_MATCHX:
|
|
sprintf(statustext,"X-matching mode entered - select object to align with...\n"); fflush(stdout);
|
|
break;
|
|
case S_MATCHY:
|
|
sprintf(statustext,"Y-matching mode entered - select object to align with...\n"); fflush(stdout);
|
|
break;
|
|
case S_MAPNAMING:
|
|
sprintf(statustext,"Map rename mode entered.\n"); fflush(stdout);
|
|
break;
|
|
case S_SAVING:
|
|
sprintf(statustext,"Save mode entered.\n"); fflush(stdout);
|
|
break;
|
|
case S_LOADING:
|
|
sprintf(statustext,"Load mode entered.\n"); fflush(stdout);
|
|
break;
|
|
}
|
|
drawstatusbar();
|
|
}
|
|
}
|
|
|
|
void cleanup(void) {
|
|
SDL_FreeCursor(textmouse);
|
|
SDL_FreeCursor(objmouse);
|
|
SDL_Quit();
|
|
}
|
|
|
|
int createobject(int type, int x, int y) {
|
|
map[curmap].obj[map[curmap].numobjects].type = type;
|
|
map[curmap].obj[map[curmap].numobjects].w = objtype[type].defw;
|
|
map[curmap].obj[map[curmap].numobjects].h = objtype[type].defh;
|
|
if ((x + map[curmap].obj[map[curmap].numobjects].w) >= map[curmap].width) {
|
|
x = map[curmap].width - map[curmap].obj[map[curmap].numobjects].w - 1;
|
|
}
|
|
if ((y + map[curmap].obj[map[curmap].numobjects].h) >= map[curmap].height) {
|
|
y = map[curmap].height - map[curmap].obj[map[curmap].numobjects].h - 1;
|
|
}
|
|
map[curmap].obj[map[curmap].numobjects].x = x;
|
|
map[curmap].obj[map[curmap].numobjects].y = y;
|
|
|
|
map[curmap].obj[map[curmap].numobjects].child = -1;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Object #%d (%s) created at (%d,%d).\n",map[curmap].numobjects, objtype[type].name, x, y);
|
|
drawstatusbar();
|
|
|
|
|
|
/* add to 'thing' list */
|
|
map[curmap].thing[map[curmap].numthings].type = T_OBJECT;
|
|
map[curmap].thing[map[curmap].numthings].id = map[curmap].numobjects;
|
|
|
|
map[curmap].numobjects++;
|
|
map[curmap].numthings++;
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
void copyline(SDL_Surface *screen,int x1, int y1, int x2, int y2, int *lbuf) {
|
|
int deltax, deltay;
|
|
int numpixels;
|
|
int d;
|
|
int dinc1,dinc2,xinc1,xinc2,yinc1,yinc2;
|
|
int i;
|
|
int x;
|
|
int y;
|
|
SDL_Color bgcol;
|
|
|
|
/* store coords */
|
|
lbuf[0] = x1;
|
|
lbuf[1] = y1;
|
|
lbuf[2] = x2;
|
|
lbuf[3] = y2;
|
|
|
|
deltax = (x2 - x1);
|
|
if (deltax < 0) deltax = -deltax;
|
|
deltay = (y2 - y1);
|
|
if (deltay < 0) deltay = -deltay;
|
|
|
|
if (deltax >= deltay) {
|
|
numpixels = deltax + 1;
|
|
d = (deltay*2) - deltax;
|
|
dinc1 = deltay << 1;
|
|
dinc2 = (deltay-deltax) << 1;
|
|
xinc1 = 1;
|
|
xinc2 = 1;
|
|
yinc1 = 0;
|
|
yinc2 = 1;
|
|
} else {
|
|
numpixels = deltay + 1;
|
|
d = (deltax*2) - deltay;
|
|
dinc1 = deltax << 1;
|
|
dinc2 = (deltax - deltay) << 1;
|
|
xinc1 = 0;
|
|
xinc2 = 1;
|
|
yinc1 = 1;
|
|
yinc2 = 1;
|
|
}
|
|
|
|
if (x1 > x2) {
|
|
xinc1 = - xinc1;
|
|
xinc2 = - xinc2;
|
|
}
|
|
if (y1 > y2) {
|
|
yinc1 = - yinc1;
|
|
yinc2 = - yinc2;
|
|
}
|
|
|
|
x = x1; y = y1;
|
|
|
|
for (i = 0; i < numpixels; i++) {
|
|
getcolor(screen, x, y, &bgcol);
|
|
lbuf[i+4] = SDL_MapRGB(screen->format, bgcol.r, bgcol.g, bgcol.b);
|
|
|
|
if (d < 0) {
|
|
d += dinc1;
|
|
x += xinc1;
|
|
y += yinc1;
|
|
} else {
|
|
d += dinc2;
|
|
x += xinc2;
|
|
y += yinc2;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void deletething(int id, int type) {
|
|
int i;
|
|
int found;
|
|
|
|
|
|
if (type == T_LINK) {
|
|
/* remove the link*/
|
|
deletelink(id);
|
|
} else if (type == T_TEXT) {
|
|
deletetext(id);
|
|
} else if (type == T_OBJECT) {
|
|
/* remove any links connecting to this map[curmap].object */
|
|
found = 0;
|
|
while (found >= 0 ) {
|
|
found = -1;
|
|
for (i = 0; i < map[curmap].numlinks; i++) {
|
|
if ((map[curmap].olink[i].srcobj == id) || (map[curmap].olink[i].dstobj == id)) {
|
|
found = i;
|
|
break;
|
|
}
|
|
}
|
|
if (found >= 0) {
|
|
deletelink(found);
|
|
}
|
|
}
|
|
|
|
/* remove any text anchored to this map[curmap].object */
|
|
found = 0;
|
|
while (found >= 0 ) {
|
|
found = -1;
|
|
for (i = 0; i < map[curmap].numtext; i++) {
|
|
if (map[curmap].textob[i].anchor == id) {
|
|
found = i;
|
|
break;
|
|
}
|
|
}
|
|
if (found >= 0) {
|
|
deletetext(found);
|
|
}
|
|
}
|
|
/* remove the map[curmap].object */
|
|
deleteobject(id);
|
|
/* shuffle ids on any link referencing this object */
|
|
for (i = 0; i < map[curmap].numlinks; i++) {
|
|
if (map[curmap].olink[i].srcobj > id) {
|
|
map[curmap].olink[i].srcobj--;
|
|
}
|
|
if (map[curmap].olink[i].dstobj > id) {
|
|
map[curmap].olink[i].dstobj--;
|
|
}
|
|
}
|
|
/* shuffle ids on any text referencing this object */
|
|
for (i = 0; i < map[curmap].numtext; i++) {
|
|
if (map[curmap].textob[i].anchor > id) {
|
|
map[curmap].textob[i].anchor--;
|
|
}
|
|
}
|
|
}
|
|
modified = TRUE;
|
|
map[curmap].selecteditem = -1;
|
|
map[curmap].selecteditemtype = -1;
|
|
drawmap();
|
|
}
|
|
|
|
void deletelink(int linkid) {
|
|
int i;
|
|
int n;
|
|
int found;
|
|
|
|
|
|
for (i = linkid; i < (map[curmap].numlinks-1); i++) {
|
|
map[curmap].olink[i] = map[curmap].olink[i+1];
|
|
}
|
|
map[curmap].numlinks--;
|
|
/* shuffle thing # */
|
|
for (n = 0; n < map[curmap].numthings; n++) {
|
|
/* mark for deletion */
|
|
if ((map[curmap].thing[n].id == linkid) && (map[curmap].thing[n].type == T_LINK)) {
|
|
map[curmap].thing[n].id = -1;
|
|
}
|
|
/* shuffle id */
|
|
if ((map[curmap].thing[n].id > linkid) && (map[curmap].thing[n].type == T_LINK)) {
|
|
map[curmap].thing[n].id--;
|
|
}
|
|
}
|
|
|
|
found = -1;
|
|
for (n = 0; n < map[curmap].numthings; n++) {
|
|
if ((map[curmap].thing[n].type == T_LINK) && (map[curmap].thing[n].id == -1)) {
|
|
found = n;
|
|
}
|
|
}
|
|
|
|
if (found != -1) {
|
|
// remove the thing
|
|
for (n = found; n < (map[curmap].numthings-1); n++) {
|
|
map[curmap].thing[n] = map[curmap].thing[n+1];
|
|
}
|
|
map[curmap].numthings--;
|
|
} else {
|
|
sprintf(statustext,"Can't find matching thing for link #%d!\n",linkid);
|
|
}
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Deleted link #%d.\n",linkid);
|
|
drawstatusbar();
|
|
|
|
}
|
|
|
|
|
|
void deleteobject(int oid) {
|
|
int i;
|
|
int n;
|
|
int found;
|
|
|
|
for (i = oid; i < (map[curmap].numobjects-1); i++) {
|
|
map[curmap].obj[i] = map[curmap].obj[i+1];
|
|
}
|
|
map[curmap].numobjects--;
|
|
/* shuffle thing # */
|
|
for (n = 0; n < map[curmap].numthings; n++) {
|
|
if ((map[curmap].thing[n].id == oid) && (map[curmap].thing[n].type == T_OBJECT)) {
|
|
map[curmap].thing[n].id = -1;
|
|
}
|
|
if ((map[curmap].thing[n].id > oid) && (map[curmap].thing[n].type == T_OBJECT)) {
|
|
map[curmap].thing[n].id--;
|
|
}
|
|
}
|
|
|
|
found = -1;
|
|
for (n = 0; n < map[curmap].numthings; n++) {
|
|
if ((map[curmap].thing[n].type == T_OBJECT) && (map[curmap].thing[n].id == -1 )) {
|
|
found = n;
|
|
}
|
|
}
|
|
|
|
if (found != -1) {
|
|
// remove the thing
|
|
for (n = found; n < (map[curmap].numthings-1); n++) {
|
|
map[curmap].thing[n] = map[curmap].thing[n+1];
|
|
}
|
|
map[curmap].numthings--;
|
|
} else {
|
|
sprintf(statustext,"Can't find matching thing for object #%d!\n",oid);
|
|
}
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Deleted object #%d.\n",oid);
|
|
drawstatusbar();
|
|
|
|
|
|
}
|
|
|
|
void deletetext(int textid) {
|
|
int i;
|
|
int n;
|
|
int found;
|
|
|
|
|
|
for (i = textid; i < (map[curmap].numtext-1); i++) {
|
|
map[curmap].textob[i] = map[curmap].textob[i+1];
|
|
}
|
|
map[curmap].numtext--;
|
|
/* shuffle thing # */
|
|
for (n = 0; n < map[curmap].numthings; n++) {
|
|
/* mark for deletion */
|
|
if ((map[curmap].thing[n].id == textid) && (map[curmap].thing[n].type == T_TEXT)) {
|
|
map[curmap].thing[n].id = -1;
|
|
}
|
|
/* shuffle id */
|
|
if ((map[curmap].thing[n].id > textid) && (map[curmap].thing[n].type == T_TEXT)) {
|
|
map[curmap].thing[n].id--;
|
|
}
|
|
}
|
|
|
|
found = -1;
|
|
for (n = 0; n < map[curmap].numthings; n++) {
|
|
if ((map[curmap].thing[n].type == T_TEXT) && (map[curmap].thing[n].id == -1)) {
|
|
found = n;
|
|
}
|
|
}
|
|
|
|
if (found != -1) {
|
|
// remove the thing
|
|
for (n = found; n < (map[curmap].numthings-1); n++) {
|
|
map[curmap].thing[n] = map[curmap].thing[n+1];
|
|
}
|
|
map[curmap].numthings--;
|
|
} else {
|
|
sprintf(statustext,"Can't find matching thing for text item #%d!\n",textid);
|
|
}
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Deleted text item #%d.\n",textid);
|
|
drawstatusbar();
|
|
|
|
}
|
|
|
|
void drawbox(SDL_Surface *screen, int x1, int y1, int x2, int y2, SDL_Color c) {
|
|
drawline(screen,x1,y1,x2,y1,c);
|
|
drawline(screen,x1,y1,x1,y2,c);
|
|
drawline(screen,x1,y2,x2,y2,c);
|
|
drawline(screen,x2,y1,x2,y2,c);
|
|
}
|
|
|
|
void drawcolorchart(SDL_Surface *dest) {
|
|
int x,y;
|
|
int i;
|
|
SDL_Color c;
|
|
int speed;
|
|
int finished = FALSE;
|
|
int size = 18;
|
|
|
|
|
|
c.r = 0;
|
|
c.g = 0;
|
|
c.b = 0;
|
|
|
|
speed = 24 ;
|
|
|
|
for (y = 0; (y < (map[curmap].height-size)) && (!finished); y+= size) {
|
|
for (x = 0; (x < (map[curmap].width-size)) && (!finished); x+= size) {
|
|
drawbox(dest,x,y,x+(size-1),y+(size-1),black);
|
|
/* fill box */
|
|
for (i = 1; i <= (size-2); i++) {
|
|
drawline(dest, x+1, y+i, x+(size-2), y+i, c);
|
|
}
|
|
/* change color */
|
|
|
|
if (c.b + speed > 255) {
|
|
c.b = 0;
|
|
if (c.g + speed > 255) {
|
|
c.g = 0;
|
|
if (c.r + speed > 255) {
|
|
finished = TRUE;
|
|
} else c.r += speed;
|
|
} else c.g += speed;
|
|
} else c.b += speed;
|
|
|
|
if (c.r >= 240) c.r = 255;
|
|
if (c.g >= 240) c.g = 255;
|
|
if (c.b >= 240) c.b = 255;
|
|
}
|
|
}
|
|
SDL_Flip(screen);
|
|
}
|
|
|
|
int drawletter(SDL_Surface *dest,int x, int y, int w, int h, char let, SDL_Color col) {
|
|
if ((let < FIRSTLET) || (let > LASTLET)) {
|
|
return TRUE;
|
|
}
|
|
|
|
drawvector(dest, &letter[let-FIRSTLET].vect, x, y, w,h, &col);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int findpointpos(link_t *l, int px, int py) {
|
|
int i;
|
|
int x,y,x2,y2;
|
|
int pos = 0;
|
|
|
|
x = map[curmap].obj[l->srcobj].x + l->srcxoff;
|
|
y = map[curmap].obj[l->srcobj].y + l->srcyoff;
|
|
|
|
for (i = 0; i < l->npoints; i++) {
|
|
x2 = l->point[i].x;
|
|
y2 = l->point[i].y;
|
|
|
|
if (isonline(px, py, x, y, x2, y2)) {
|
|
return pos;
|
|
}
|
|
pos++;
|
|
|
|
x = x2;
|
|
y = y2;
|
|
}
|
|
|
|
/* draw line to final map[curmap].object */
|
|
x2 = map[curmap].obj[l->dstobj].x + l->dstxoff;
|
|
y2 = map[curmap].obj[l->dstobj].y + l->dstyoff;
|
|
|
|
return pos;
|
|
}
|
|
|
|
|
|
void drawline(SDL_Surface *screen, int x1, int y1, int x2, int y2, SDL_Color c) {
|
|
int deltax, deltay;
|
|
int numpixels;
|
|
int d;
|
|
int dinc1,dinc2,xinc1,xinc2,yinc1,yinc2;
|
|
int i;
|
|
int x;
|
|
int y;
|
|
|
|
deltax = (x2 - x1);
|
|
if (deltax < 0) deltax = -deltax;
|
|
deltay = (y2 - y1);
|
|
if (deltay < 0) deltay = -deltay;
|
|
|
|
if (deltax >= deltay) {
|
|
numpixels = deltax + 1;
|
|
d = (deltay*2) - deltax;
|
|
dinc1 = deltay << 1;
|
|
dinc2 = (deltay-deltax) << 1;
|
|
xinc1 = 1;
|
|
xinc2 = 1;
|
|
yinc1 = 0;
|
|
yinc2 = 1;
|
|
} else {
|
|
numpixels = deltay + 1;
|
|
d = (deltax*2) - deltay;
|
|
dinc1 = deltax << 1;
|
|
dinc2 = (deltax - deltay) << 1;
|
|
xinc1 = 0;
|
|
xinc2 = 1;
|
|
yinc1 = 1;
|
|
yinc2 = 1;
|
|
}
|
|
|
|
if (x1 > x2) {
|
|
xinc1 = - xinc1;
|
|
xinc2 = - xinc2;
|
|
}
|
|
if (y1 > y2) {
|
|
yinc1 = - yinc1;
|
|
yinc2 = - yinc2;
|
|
}
|
|
|
|
x = x1; y = y1;
|
|
|
|
for (i = 0; i < numpixels; i++) {
|
|
drawpixel(screen,x,y,c);
|
|
if (d < 0) {
|
|
d += dinc1;
|
|
x += xinc1;
|
|
y += yinc1;
|
|
} else {
|
|
d += dinc2;
|
|
x += xinc2;
|
|
y += yinc2;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void drawlink(SDL_Surface *dest, link_t *l) {
|
|
int i;
|
|
int x,y,x2,y2;
|
|
|
|
x = map[curmap].obj[l->srcobj].x + l->srcxoff;
|
|
y = map[curmap].obj[l->srcobj].y + l->srcyoff;
|
|
|
|
for (i = 0; i < l->npoints; i++) {
|
|
x2 = l->point[i].x;
|
|
y2 = l->point[i].y;
|
|
|
|
drawline(dest, x,y,x2,y2, l->col);
|
|
|
|
x = x2;
|
|
y = y2;
|
|
}
|
|
|
|
/* draw line to final map[curmap].object */
|
|
x2 = map[curmap].obj[l->dstobj].x + l->dstxoff;
|
|
y2 = map[curmap].obj[l->dstobj].y + l->dstyoff;
|
|
|
|
drawline(dest, x,y,x2,y2, l->col);
|
|
}
|
|
|
|
|
|
void drawobject(SDL_Surface *dest, mapobject_t *o) {
|
|
SDL_Surface *temps;
|
|
SDL_Rect area;
|
|
Uint32 bgcol;
|
|
|
|
/* create temp surface */
|
|
temps = SDL_CreateRGBSurface(SDL_SWSURFACE,(o->w + 3), (o->h + 3),
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
|
|
if (temps == NULL) {
|
|
printf("temp surface is NULL!\n");
|
|
fflush(stdout);
|
|
exit(1);
|
|
}
|
|
|
|
bgcol = SDL_MapRGB(temps->format, map[curmap].bgcol.r,map[curmap].bgcol.g,map[curmap].bgcol.b);
|
|
SDL_FillRect(temps, NULL, bgcol);
|
|
|
|
/* draw onto temp surface */
|
|
drawvector(temps, &objtype[o->type].vimg, 0, 0, o->w, o->h, NULL);
|
|
|
|
/* set transparent colour on temp surface */
|
|
SDL_SetColorKey(temps, SDL_SRCCOLORKEY|SDL_RLEACCEL, bgcol);
|
|
|
|
/* blit to screen */
|
|
/*printf("set area params: x=%d,y=%d w=%d,h=%d x2=%d,y2=%d\n",
|
|
o->x, o->y,o->w,o->h,o->x+o->w,o->y+o->h); fflush(stdout);
|
|
*/
|
|
area.x = o->x;
|
|
area.y = o->y;
|
|
area.w = o->w;
|
|
area.h = o->h;
|
|
SDL_BlitSurface(temps, 0, dest, &area);
|
|
|
|
}
|
|
|
|
void drawpixel(SDL_Surface *screen, int x, int y, SDL_Color c) {
|
|
Uint32 color = SDL_MapRGB(screen->format, c.r, c.g, c.b);
|
|
|
|
/*if ( SDL_MUSTLOCK(screen) ) {
|
|
if ( SDL_LockSurface(screen) < 0 ) {
|
|
return;
|
|
}
|
|
}*/
|
|
switch (screen->format->BytesPerPixel) {
|
|
case 1: { /* Assuming 8-bpp */
|
|
Uint8 *bufp;
|
|
|
|
bufp = (Uint8 *)screen->pixels + y*screen->pitch + x;
|
|
*bufp = color;
|
|
}
|
|
break;
|
|
|
|
case 2: { /* Probably 15-bpp or 16-bpp */
|
|
Uint16 *bufp;
|
|
|
|
bufp = (Uint16 *)screen->pixels + y*screen->pitch/2 + x;
|
|
*bufp = color;
|
|
}
|
|
break;
|
|
|
|
case 3: { /* Slow 24-bpp mode, usually not used */
|
|
Uint8 *bufp;
|
|
|
|
bufp = (Uint8 *)screen->pixels + y*screen->pitch + x * 3;
|
|
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) {
|
|
bufp[0] = color;
|
|
bufp[1] = color >> 8;
|
|
bufp[2] = color >> 16;
|
|
} else {
|
|
bufp[2] = color;
|
|
bufp[1] = color >> 8;
|
|
bufp[0] = color >> 16;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 4: { /* Probably 32-bpp */
|
|
Uint32 *bufp;
|
|
|
|
bufp = (Uint32 *)screen->pixels + y*screen->pitch/4 + x;
|
|
*bufp = color;
|
|
}
|
|
break;
|
|
}
|
|
/*
|
|
if ( SDL_MUSTLOCK(screen) ) {
|
|
SDL_UnlockSurface(screen);
|
|
}
|
|
*/
|
|
//SDL_UpdateRect(screen, x, y, 1, 1);
|
|
}
|
|
|
|
void drawmap(void) {
|
|
int i;
|
|
int testing = 0;
|
|
SDL_Rect area;
|
|
Uint32 fillcol;
|
|
int txoff,tyoff;
|
|
int anchoreditem;
|
|
|
|
if ((state == S_SAVING) || (state == S_LOADING) || (state == S_MAPNAMING)) {
|
|
/* show file dialog */
|
|
showfiledialog();
|
|
return;
|
|
}
|
|
|
|
if (state == S_FGCOL) {
|
|
drawcolorchart(screen);
|
|
return;
|
|
}
|
|
|
|
if (state == S_CREATETELE) {
|
|
drawmaplist(screen);
|
|
return;
|
|
}
|
|
|
|
if (state == S_REALLYQUIT) {
|
|
drawyn(text);
|
|
return;
|
|
}
|
|
|
|
/* clear map */
|
|
fillcol = SDL_MapRGB(buffer->format, map[curmap].bgcol.r,map[curmap].bgcol.g,map[curmap].bgcol.b);
|
|
SDL_FillRect(buffer, NULL, fillcol);
|
|
|
|
/* draw all objects links etc*/
|
|
for (i = 0; i < map[curmap].numthings; i++) {
|
|
if (map[curmap].thing[i].type == T_OBJECT) {
|
|
if (testing) {
|
|
printf("Drawing thing #%d (%d, %s)\n",i,map[curmap].thing[i].id,objtype[map[curmap].obj[map[curmap].thing[i].id].type].name);
|
|
fflush(stdout);
|
|
}
|
|
drawobject(buffer, &map[curmap].obj[map[curmap].thing[i].id]);
|
|
} else if (map[curmap].thing[i].type == T_LINK) {
|
|
if (testing) {
|
|
printf ("Drawing thing #%d (%d, link)\n",i,map[curmap].thing[i].id);
|
|
fflush(stdout);
|
|
}
|
|
drawlink(buffer, &map[curmap].olink[map[curmap].thing[i].id]);
|
|
} else if (map[curmap].thing[i].type == T_TEXT) {
|
|
if (testing) {
|
|
printf ("Drawing thing #%d (%d, text)\n",i,map[curmap].thing[i].id);
|
|
fflush(stdout);
|
|
}
|
|
drawtext(buffer, &map[curmap].textob[map[curmap].thing[i].id]);
|
|
} else {
|
|
printf("WARNING: Thing #%d has unknown type %d!\n",i,map[curmap].thing[i].type);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
|
|
/* highlight the selected object */
|
|
/* by drawing boxes in its corners */
|
|
if (map[curmap].selecteditem != -1) {
|
|
if (map[curmap].selecteditemtype == T_OBJECT) {
|
|
/* 10% of map[curmap].object's size */
|
|
area.w = map[curmap].obj[map[curmap].selecteditem].w / OBJSELHANDLEPCT;
|
|
area.h = map[curmap].obj[map[curmap].selecteditem].h / OBJSELHANDLEPCT;
|
|
if (area.w < 2) area.w = 2;
|
|
if (area.h < 2) area.h = 2;
|
|
|
|
fillcol = SDL_MapRGB(buffer->format, 0, 0, 0);
|
|
|
|
/* top left */
|
|
area.x = map[curmap].obj[map[curmap].selecteditem].x; area.y = map[curmap].obj[map[curmap].selecteditem].y;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* top right */
|
|
area.x = map[curmap].obj[map[curmap].selecteditem].x + map[curmap].obj[map[curmap].selecteditem].w - area.w; area.y = map[curmap].obj[map[curmap].selecteditem].y;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* bottom left */
|
|
area.x = map[curmap].obj[map[curmap].selecteditem].x ; area.y = map[curmap].obj[map[curmap].selecteditem].y + map[curmap].obj[map[curmap].selecteditem].h - area.h;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* bottom right */
|
|
area.x = map[curmap].obj[map[curmap].selecteditem].x + map[curmap].obj[map[curmap].selecteditem].w - area.w; area.y = map[curmap].obj[map[curmap].selecteditem].y + map[curmap].obj[map[curmap].selecteditem].h - area.h;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
} else if (map[curmap].selecteditemtype == T_TEXT) {
|
|
/* 10% of text's size */
|
|
area.w = map[curmap].textob[map[curmap].selecteditem].w / OBJSELHANDLEPCT;
|
|
area.h = map[curmap].textob[map[curmap].selecteditem].h / OBJSELHANDLEPCT;
|
|
if (area.w < 2) area.w = 2;
|
|
if (area.h < 2) area.h = 2;
|
|
|
|
anchoreditem = map[curmap].textob[map[curmap].selecteditem].anchor;
|
|
if (anchoreditem == -1) {
|
|
txoff = 0;
|
|
tyoff = 0;
|
|
} else {
|
|
txoff = map[curmap].obj[anchoreditem].x;
|
|
tyoff = map[curmap].obj[anchoreditem].y;
|
|
}
|
|
|
|
fillcol = SDL_MapRGB(buffer->format, 0, 0, 0);
|
|
|
|
/* top left */
|
|
area.x = map[curmap].textob[map[curmap].selecteditem].x + txoff; area.y = map[curmap].textob[map[curmap].selecteditem].y + tyoff;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* top right */
|
|
area.x = map[curmap].textob[map[curmap].selecteditem].x +txoff + map[curmap].textob[map[curmap].selecteditem].w - area.w; area.y = map[curmap].textob[map[curmap].selecteditem].y + tyoff;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* bottom left */
|
|
area.x = map[curmap].textob[map[curmap].selecteditem].x +txoff ; area.y = map[curmap].textob[map[curmap].selecteditem].y + tyoff +map[curmap].textob[map[curmap].selecteditem].h - area.h;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* bottom right */
|
|
area.x = map[curmap].textob[map[curmap].selecteditem].x+txoff + map[curmap].textob[map[curmap].selecteditem].w - area.w; area.y = map[curmap].textob[map[curmap].selecteditem].y +tyoff+ map[curmap].textob[map[curmap].selecteditem].h - area.h;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
|
|
/* if this text is anchored, highlight the map[curmap].object which it is anchored to */
|
|
if (anchoreditem != -1) {
|
|
area.w = map[curmap].obj[anchoreditem].w / OBJSELHANDLEPCT;
|
|
area.h = map[curmap].obj[anchoreditem].h / OBJSELHANDLEPCT;
|
|
if (area.w < 2) area.w = 2;
|
|
if (area.h < 2) area.h = 2;
|
|
|
|
fillcol = SDL_MapRGB(buffer->format, 0, 255, 0);
|
|
|
|
/* top left */
|
|
area.x = map[curmap].obj[anchoreditem].x; area.y = map[curmap].obj[anchoreditem].y;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* top right */
|
|
area.x = map[curmap].obj[anchoreditem].x + map[curmap].obj[anchoreditem].w - area.w; area.y = map[curmap].obj[anchoreditem].y;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* bottom left */
|
|
area.x = map[curmap].obj[anchoreditem].x ; area.y = map[curmap].obj[anchoreditem].y + map[curmap].obj[anchoreditem].h - area.h;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* bottom right */
|
|
area.x = map[curmap].obj[anchoreditem].x + map[curmap].obj[anchoreditem].w - area.w; area.y = map[curmap].obj[anchoreditem].y + map[curmap].obj[anchoreditem].h - area.h;
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
}
|
|
} else if (map[curmap].selecteditemtype == T_LINK) {
|
|
/* 10% of map[curmap].object's size */
|
|
area.w = LINESELHANDLESIZE;
|
|
area.h = LINESELHANDLESIZE;
|
|
|
|
fillcol = SDL_MapRGB(buffer->format, 0, 0, 0);
|
|
|
|
/* start of line */
|
|
area.x = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].srcobj].x + map[curmap].olink[map[curmap].selecteditem].srcxoff - (LINESELHANDLESIZE/2);
|
|
area.y = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].srcobj].y + map[curmap].olink[map[curmap].selecteditem].srcyoff - (LINESELHANDLESIZE/2);
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* end of line */
|
|
area.x = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].dstobj].x + map[curmap].olink[map[curmap].selecteditem].dstxoff - (LINESELHANDLESIZE/2);
|
|
area.y = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].dstobj].y + map[curmap].olink[map[curmap].selecteditem].dstyoff - (LINESELHANDLESIZE/2);
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
|
|
/* points on the line */
|
|
for (i = 0; i < map[curmap].olink[map[curmap].selecteditem].npoints; i++) {
|
|
area.x = map[curmap].olink[map[curmap].selecteditem].point[i].x - (LINESELHANDLESIZE/2);
|
|
area.y = map[curmap].olink[map[curmap].selecteditem].point[i].y - (LINESELHANDLESIZE/2);
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
}
|
|
} else if (map[curmap].selecteditemtype == T_LINKPOINT) {
|
|
/* highlight the line in green */
|
|
/* 10% of map[curmap].object's size */
|
|
area.w = LINESELHANDLESIZE;
|
|
area.h = LINESELHANDLESIZE;
|
|
|
|
fillcol = SDL_MapRGB(buffer->format, 0, 255, 0);
|
|
|
|
/* start of line */
|
|
area.x = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].srcobj].x + map[curmap].olink[map[curmap].selecteditem].srcxoff - (LINESELHANDLESIZE/2);
|
|
area.y = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].srcobj].y + map[curmap].olink[map[curmap].selecteditem].srcyoff - (LINESELHANDLESIZE/2);
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
/* end of line */
|
|
area.x = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].dstobj].x + map[curmap].olink[map[curmap].selecteditem].dstxoff - (LINESELHANDLESIZE/2);
|
|
area.y = map[curmap].obj[map[curmap].olink[map[curmap].selecteditem].dstobj].y + map[curmap].olink[map[curmap].selecteditem].dstyoff - (LINESELHANDLESIZE/2);
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
|
|
/* points on the line */
|
|
for (i = 0; i < map[curmap].olink[map[curmap].selecteditem].npoints; i++) {
|
|
if (i == map[curmap].selectedlinkpoint) {
|
|
fillcol = SDL_MapRGB(buffer->format, 0, 0, 0);
|
|
} else {
|
|
fillcol = SDL_MapRGB(buffer->format, 0, 255, 0);
|
|
}
|
|
area.x = map[curmap].olink[map[curmap].selecteditem].point[i].x - (LINESELHANDLESIZE/2);
|
|
area.y = map[curmap].olink[map[curmap].selecteditem].point[i].y - (LINESELHANDLESIZE/2);
|
|
SDL_FillRect(buffer, &area, fillcol);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* blit buffer to screen */
|
|
SDL_BlitSurface(buffer, 0, screen,0);
|
|
|
|
drawmapbox();
|
|
|
|
/* draw status bar */
|
|
drawstatusbar();
|
|
|
|
|
|
/* flip */
|
|
SDL_UpdateRect(screen, 0, 0, map[curmap].width, map[curmap].height);
|
|
|
|
}
|
|
|
|
void drawstatusbar(void) {
|
|
//int x,y;
|
|
Uint32 col;
|
|
SDL_Rect area;
|
|
text_t temp;
|
|
|
|
col = SDL_MapRGB(screen->format, map[curmap].bgcol.r, map[curmap].bgcol.g, map[curmap].bgcol.b);
|
|
|
|
area.x = 0;
|
|
area.y = map[curmap].height;
|
|
area.w = map[curmap].width;
|
|
area.h = map[curmap].height + DEFTEXTH + 3;
|
|
|
|
SDL_FillRect(screen, &area, col);
|
|
drawline(screen, 0, map[curmap].height, map[curmap].width, map[curmap].height, blue);
|
|
|
|
/* strip newlines from text */
|
|
if (statustext[strlen(statustext)-1] == '\n')
|
|
statustext[strlen(statustext)-1] = '\0';
|
|
|
|
strcpy(temp.text, statustext);
|
|
temp.x = 2;
|
|
temp.y = map[curmap].height+2;
|
|
temp.w = strlen(temp.text) * DEFTEXTW;
|
|
temp.h = DEFTEXTH;
|
|
temp.c = black;
|
|
temp.anchor = -1;
|
|
drawtext(screen, &temp);
|
|
|
|
/* show modified status */
|
|
if (modified) {
|
|
temp.x = map[curmap].width - 25;
|
|
temp.y = map[curmap].height+2;
|
|
temp.w = 20;
|
|
temp.h = DEFTEXTH;
|
|
temp.c = blue;
|
|
temp.anchor = -1;
|
|
strcpy(temp.text, "MOD");
|
|
drawbox(screen, temp.x-3,temp.y-1,temp.x+temp.w+1,temp.y+temp.h+1,blue);
|
|
drawtext(screen, &temp);
|
|
}
|
|
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
}
|
|
|
|
void drawmapbox(void) {
|
|
text_t temp;
|
|
int x,y;
|
|
int i;
|
|
int lh = DEFTEXTH -2;
|
|
int found;
|
|
int n;
|
|
Uint32 fillcol;
|
|
SDL_Rect area;
|
|
|
|
|
|
x = mapbox.x+1;
|
|
y = mapbox.y+1;
|
|
|
|
/* clear it */
|
|
area.x = mapbox.x;
|
|
area.y = mapbox.y;
|
|
area.w = screen->w - mapbox.x;
|
|
area.h = mapbox.height;
|
|
|
|
fillcol = SDL_MapRGB(screen->format, 90, 90, 90);
|
|
|
|
SDL_FillRect(screen, &area, fillcol);
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
|
|
/* box around edge */
|
|
drawbox(screen, mapbox.x, mapbox.y, mapbox.x + mapbox.width-2,mapbox.y + mapbox.height,white);
|
|
|
|
/* current map */
|
|
sprintf(temp.text, map[curmap].name);
|
|
temp.x = x;
|
|
temp.y = y;
|
|
temp.w = strlen(temp.text) * DEFTEXTW;
|
|
temp.h = lh;
|
|
temp.anchor = -1;
|
|
temp.c = white;
|
|
|
|
drawtext(screen, &temp);
|
|
|
|
y += DEFTEXTH;
|
|
|
|
/* seperator line */
|
|
drawline(screen, x, y, x+mapbox.width-2, y, white);
|
|
y++;
|
|
|
|
/* show .. */
|
|
if (numhistory >= 1) {
|
|
/* draw arrow */
|
|
drawline(screen, x+5,y+(DEFTEXTH/2),x+mapbox.width-15,y+(DEFTEXTH/2),white);
|
|
drawline(screen, x+5,y+(DEFTEXTH/2),x+15,y+1,white);
|
|
drawline(screen, x+5,y+(DEFTEXTH/2),x+15,y+(DEFTEXTH-1),white);
|
|
|
|
}
|
|
y += DEFTEXTH;
|
|
|
|
/* children ... */
|
|
|
|
numchildren = 0;
|
|
for (i = 0; i < map[curmap].numobjects; i++) {
|
|
if (map[curmap].obj[i].child != -1) {
|
|
/* make sure we haven't already drawn this name */
|
|
found = FALSE;
|
|
for (n = 0; n < numchildren; n++) {
|
|
if (children[n] == map[curmap].obj[i].child) {
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
sprintf(temp.text, map[map[curmap].obj[i].child].name);
|
|
//temp.x = x+DEFTEXTW;
|
|
temp.x = x;
|
|
temp.y = y;
|
|
temp.w = strlen(temp.text) * DEFTEXTW;
|
|
temp.h = lh;
|
|
temp.anchor = -1;
|
|
temp.c = white;
|
|
|
|
drawtext(screen, &temp);
|
|
|
|
children[numchildren] = map[curmap].obj[i].child;
|
|
numchildren++;
|
|
|
|
y += DEFTEXTH;
|
|
}
|
|
}
|
|
}
|
|
|
|
SDL_UpdateRect(screen, mapbox.x, mapbox.y, screen->w - mapbox.x,mapbox.height+2);
|
|
//SDL_Flip(screen);
|
|
}
|
|
|
|
void drawmaplist(SDL_Surface *dest) {
|
|
int x,y;
|
|
int i;
|
|
text_t temp;
|
|
Uint32 fillcol;
|
|
SDL_Rect area;
|
|
|
|
/* clear screen*/
|
|
|
|
fillcol = SDL_MapRGB(screen->format, map[curmap].bgcol.r,map[curmap].bgcol.g,map[curmap].bgcol.b);
|
|
area.x = 0;
|
|
area.y = 0;
|
|
area.w = map[curmap].width;
|
|
area.h = map[curmap].height-1;
|
|
SDL_FillRect(screen, &area, fillcol);
|
|
|
|
x = 10;
|
|
y = 10;
|
|
|
|
strcpy(temp.text, "Select map to link to:");
|
|
temp.x = x;
|
|
temp.y = y;
|
|
temp.w = strlen(temp.text) * (DEFTEXTW*2);
|
|
temp.h = DEFTEXTH*2;
|
|
temp.c = black;
|
|
temp.anchor = -1;
|
|
drawtext(dest, &temp);
|
|
|
|
y = 50;
|
|
|
|
|
|
drawbox(dest, x, y, map[curmap].width-1,y+(DEFTEXTH*2),blue);
|
|
strcpy(temp.text, "(none)");
|
|
temp.x = x+1;
|
|
temp.y = y+1;
|
|
temp.w = strlen(temp.text) * (DEFTEXTW*2);
|
|
temp.h = (DEFTEXTH*2)-2;
|
|
temp.c = blue;
|
|
temp.anchor = -1;
|
|
drawtext(dest, &temp);
|
|
|
|
y += (DEFTEXTH*2);
|
|
|
|
for (i = 0; i < nummaps; i++) {
|
|
drawbox(dest, x, y, map[curmap].width-1,y+(DEFTEXTH*2),blue);
|
|
|
|
strcpy(temp.text, map[i].name);
|
|
temp.x = x+1;
|
|
temp.y = y+1;
|
|
temp.w = strlen(temp.text) * (DEFTEXTW*2);
|
|
temp.h = (DEFTEXTH*2)-2;
|
|
temp.c = blue;
|
|
temp.anchor = -1;
|
|
drawtext(dest, &temp);
|
|
|
|
y += (DEFTEXTH*2);
|
|
|
|
}
|
|
|
|
SDL_Flip(screen);
|
|
}
|
|
|
|
void drawobox(void) {
|
|
int x,y,i;
|
|
SDL_Rect area;
|
|
mapobject_t temp;
|
|
Uint32 fillcol;
|
|
SDL_Color outlinecol;
|
|
int outlinepos;
|
|
int fitx,fity,fit;
|
|
|
|
fillcol = SDL_MapRGB(screen->format, obox.bgcol.r,obox.bgcol.g,obox.bgcol.b);
|
|
area.x = obox.x;
|
|
area.y = obox.y;
|
|
area.w = obox.width;
|
|
area.h = obox.height+3;
|
|
SDL_FillRect(screen, &area, fillcol);
|
|
|
|
x = obox.x;
|
|
y = obox.y;
|
|
|
|
|
|
/* calculate how many items we can fit in the obox */
|
|
/* figure out how many objects we can fit in the box */
|
|
fitx = (obox.width / obox.gridsize);
|
|
fity = ((obox.height+3) / obox.gridsize);
|
|
fit = fitx * fity;
|
|
|
|
for (i = (obox.pos*3); i < numobjtypes; i++) {
|
|
if ((x + obox.gridsize) >= (map[curmap].width + SIDEBARW)) {
|
|
x = obox.x;
|
|
if ((y + obox.gridsize) >= (map[curmap].height)) {
|
|
break;
|
|
}
|
|
y += obox.gridsize;
|
|
}
|
|
/* draw box */
|
|
outlinecol = obox.gridcol;
|
|
drawline(screen, x, y,x+obox.gridsize,y,outlinecol); /* top */
|
|
drawline(screen, x, y+obox.gridsize,x+obox.gridsize,y+obox.gridsize,outlinecol); /* bottom */
|
|
drawline(screen, x, y,x,y+obox.gridsize,outlinecol); /* left */
|
|
drawline(screen, x+obox.gridsize, y,x+obox.gridsize,y+obox.gridsize,outlinecol); /* right */
|
|
/* fill it */
|
|
fillcol = SDL_MapRGB(screen->format, obox.gridbgcol.r,obox.gridbgcol.g,obox.gridbgcol.b);
|
|
area.x = x+1;
|
|
area.y = y+1;
|
|
area.w = obox.gridsize-1;
|
|
area.h = obox.gridsize-1;
|
|
SDL_FillRect(screen, &area, fillcol);
|
|
|
|
/* draw map[curmap].object */
|
|
temp.type = i;
|
|
temp.x = x+1;
|
|
temp.y = y+1;
|
|
temp.w = obox.gridsize-2;
|
|
temp.h = obox.gridsize-2;
|
|
drawobject(screen, &temp);
|
|
|
|
//SDL_UpdateRect(screen, x, y, obox.gridsize+1,obox.gridsize+1);
|
|
|
|
x += obox.gridsize;
|
|
|
|
}
|
|
|
|
/* oooo */
|
|
/* draw selector */
|
|
outlinecol = red;
|
|
outlinepos = map[curmap].selectedtype - (obox.pos*3);
|
|
|
|
if ((outlinepos >= 0) && (outlinepos < fit)) {
|
|
y = ((map[curmap].selectedtype - (obox.pos*3)) / obox.gridrowlen) * obox.gridsize + obox.y;
|
|
x = ((map[curmap].selectedtype - (obox.pos*3)) % obox.gridrowlen) * obox.gridsize + obox.x;
|
|
|
|
drawline(screen, x, y,x+obox.gridsize,y,outlinecol); /* top */
|
|
drawline(screen, x, y+obox.gridsize,x+obox.gridsize,y+obox.gridsize,outlinecol); /* bottom */
|
|
drawline(screen, x, y,x,y+obox.gridsize,outlinecol); /* left */
|
|
drawline(screen, x+obox.gridsize, y,x+obox.gridsize,y+obox.gridsize,outlinecol); /* right */
|
|
}
|
|
|
|
//SDL_UpdateRect(screen, x, y, obox.gridsize+1,obox.gridsize+1);
|
|
|
|
SDL_UpdateRect(screen,obox.x, obox.y, obox.width-1, obox.height+3);
|
|
}
|
|
|
|
void drawscreen(void){
|
|
sprintf(statustext, "Welcome to netmapr v%s.", VERSION);
|
|
drawmap();
|
|
drawtoolbox();
|
|
drawobox();
|
|
}
|
|
|
|
void drawtext(SDL_Surface *dest, text_t *t) {
|
|
int x,y;
|
|
int tw,th;
|
|
int i;
|
|
|
|
int txoff,tyoff;
|
|
|
|
if (strlen(t->text) == 0) {
|
|
return;
|
|
}
|
|
|
|
/* calculate letter width, letter height */
|
|
tw = t->w / strlen(t->text);
|
|
//tw = DEFTEXTW;
|
|
th = t->h;
|
|
|
|
if (t->anchor == -1) {
|
|
txoff = 0;
|
|
tyoff = 0;
|
|
} else {
|
|
txoff = map[curmap].obj[t->anchor].x;
|
|
tyoff = map[curmap].obj[t->anchor].y;
|
|
}
|
|
|
|
|
|
//printf("drawtext() of: '%s' (len %d)\n",t->text, strlen(t->text)); fflush(stdout);
|
|
for (i = 0; i < strlen(t->text); i++) {
|
|
x = t->x + (i * tw) + txoff;
|
|
y = t->y + tyoff;
|
|
if (drawletter(dest, x, y, tw, th, t->text[i], t->c) ) {
|
|
if (t->text[i] != ' ') {
|
|
printf("INVALID letter: '%c'\n",t->text[i]); fflush(stdout);
|
|
}
|
|
} else {
|
|
//printf("drawing letter: '%c' at %d,%d\n",t->text[i],x, t->y); fflush(stdout);
|
|
}
|
|
}
|
|
}
|
|
|
|
void drawtoolbox(void) {
|
|
int x,y,i;
|
|
SDL_Rect area;
|
|
Uint32 fillcol;
|
|
Uint32 bcol;
|
|
int z;
|
|
SDL_Color gridhigh = {255, 255, 255, 0};
|
|
SDL_Color gridmiddle = {90, 90, 90, 0};
|
|
SDL_Color gridlow = {50, 50, 50, 0};
|
|
|
|
fillcol = SDL_MapRGB(screen->format, toolbox.bgcol.r,toolbox.bgcol.g,toolbox.bgcol.b);
|
|
area.x = toolbox.x;
|
|
area.y = toolbox.y;
|
|
area.w = toolbox.width;
|
|
area.h = toolbox.height;
|
|
SDL_FillRect(screen, &area, fillcol);
|
|
|
|
x = toolbox.x;
|
|
y = toolbox.y;
|
|
|
|
/* draw each button */
|
|
for (i = 0; i < numbuttons; i++) {
|
|
if ((x + toolbox.gridsize) >= (map[curmap].width + SIDEBARW)) {
|
|
x = toolbox.x;
|
|
y += toolbox.gridsize+3;
|
|
if ((y + toolbox.gridsize) >= (toolbox.height)) {
|
|
break;
|
|
}
|
|
}
|
|
/* draw box */
|
|
drawline(screen, x, y,x+toolbox.gridsize,y,gridhigh); /* top */
|
|
drawline(screen, x, y+1,x+toolbox.gridsize,y+1,gridhigh); /* top */
|
|
|
|
drawline(screen, x, y+toolbox.gridsize-1,x+toolbox.gridsize,y+toolbox.gridsize-1,gridlow); /* bottom */
|
|
drawline(screen, x, y+toolbox.gridsize,x+toolbox.gridsize,y+toolbox.gridsize,gridlow); /* bottom */
|
|
|
|
drawline(screen, x, y,x,y+toolbox.gridsize,gridhigh); /* left */
|
|
drawline(screen, x+1, y,x+1,y+toolbox.gridsize-1,gridhigh); /* left */
|
|
|
|
drawline(screen, x+toolbox.gridsize, y+1,x+toolbox.gridsize,y+toolbox.gridsize,gridlow); /* right */
|
|
drawline(screen, x+toolbox.gridsize-1, y+1,x+toolbox.gridsize-1,y+toolbox.gridsize,gridlow); /* right */
|
|
|
|
for (z = y+2; z < y+toolbox.gridsize;z++) {
|
|
drawline(screen,x+2,z,x+toolbox.gridsize-2,z,gridmiddle);
|
|
}
|
|
|
|
area.x = x+2;
|
|
area.y = y+2;
|
|
area.w = toolbox.gridsize-4;
|
|
area.h = toolbox.gridsize-4;
|
|
|
|
/* set transparent colour on temp surface */
|
|
bcol = SDL_MapRGB(buffer->format, 0, 0, 0);
|
|
|
|
/* blit button image onto button */
|
|
SDL_SetColorKey(button[i].img, SDL_SRCCOLORKEY|SDL_RLEACCEL, bcol);
|
|
SDL_BlitSurface(button[i].img, 0, screen, &area);
|
|
|
|
/* special cases */
|
|
if (i == TB_FGCOL) {
|
|
floodfill(screen, area.x + 5, area.y + 5, fgcol);
|
|
}
|
|
if (i == TB_FILLCOL) {
|
|
floodfill(screen, area.x + 5, area.y + 5, objfillcol);
|
|
}
|
|
|
|
SDL_UpdateRect(screen, x, y, toolbox.gridsize+3,toolbox.gridsize+3);
|
|
|
|
x += toolbox.gridsize+3;
|
|
|
|
}
|
|
|
|
/* draw selectors */
|
|
if (state == S_NONE) drawtoolboxselector(TB_POINTER);
|
|
if (state == S_ADDOBJ) drawtoolboxselector(TB_ADDOBJ);
|
|
if (state == S_ADDTEXT) drawtoolboxselector(TB_ADDTEXT);
|
|
if (state == S_SAVING) drawtoolboxselector(TB_SAVE);
|
|
if (state == S_LOADING) drawtoolboxselector(TB_LOAD);
|
|
if (state == S_MATCHSIZE) drawtoolboxselector(TB_MATCHSIZE);
|
|
if (state == S_MATCHX) drawtoolboxselector(TB_MATCHX);
|
|
if (state == S_MATCHY) drawtoolboxselector(TB_MATCHY);
|
|
if (state == S_CREATETELE) drawtoolboxselector(TB_CREATETELE);
|
|
|
|
|
|
}
|
|
|
|
void drawtoolboxselector(int buttonid) {
|
|
SDL_Color outlinecol;
|
|
int x,y;
|
|
|
|
/* draw selector */
|
|
outlinecol = red;
|
|
y = (buttonid / toolbox.gridrowlen) * (toolbox.gridsize+3) + toolbox.y;
|
|
x = (buttonid % toolbox.gridrowlen) * (toolbox.gridsize+3) + toolbox.x;
|
|
|
|
drawline(screen, x, y,x+toolbox.gridsize,y,outlinecol); /* top */
|
|
drawline(screen, x, y+1,x+toolbox.gridsize,y+1,outlinecol); /* top */
|
|
drawline(screen, x, y+toolbox.gridsize,x+toolbox.gridsize,y+toolbox.gridsize,outlinecol); /* bottom */
|
|
drawline(screen, x, y+toolbox.gridsize-1,x+toolbox.gridsize,y+toolbox.gridsize-1,outlinecol); /* bottom */
|
|
drawline(screen, x, y,x,y+toolbox.gridsize,outlinecol); /* left */
|
|
drawline(screen, x+1, y,x+1,y+toolbox.gridsize,outlinecol); /* left */
|
|
drawline(screen, x+toolbox.gridsize, y,x+toolbox.gridsize,y+toolbox.gridsize,outlinecol); /* right */
|
|
drawline(screen, x+toolbox.gridsize-1, y,x+toolbox.gridsize-1,y+toolbox.gridsize,outlinecol); /* right */
|
|
|
|
SDL_UpdateRect(screen, x, y, toolbox.gridsize+3,toolbox.gridsize+3);
|
|
}
|
|
|
|
|
|
void drawvector(SDL_Surface *dest, vectorimg_t *vimg, int x, int y, int w, int h, SDL_Color *overridefg) {
|
|
float xscale,yscale;
|
|
int realx1, realy1;
|
|
int realx2, realy2;
|
|
int i;
|
|
SDL_Color linecol,fillcol;
|
|
|
|
xscale = (float)w / (float)vimg->w;
|
|
yscale = (float)h / (float)vimg->h;
|
|
|
|
|
|
|
|
for (i = 0; i < vimg->vnum; i++) {
|
|
// select colour
|
|
if (overridefg == NULL) {
|
|
if (vimg->vector[i].c.unused == 255) {
|
|
linecol = fgcol;
|
|
} else {
|
|
linecol = vimg->vector[i].c;
|
|
}
|
|
} else {
|
|
linecol = *overridefg;
|
|
}
|
|
|
|
if (vimg->vector[i].c.unused == 255) {
|
|
fillcol = objfillcol;
|
|
} else {
|
|
fillcol = vimg->vector[i].c;
|
|
}
|
|
|
|
// scale the coords of this vector
|
|
realx1 = x + ((float)vimg->vector[i].x1 * xscale);
|
|
realy1 = y + ((float)vimg->vector[i].y1 * yscale);
|
|
realx2 = x + ((float)vimg->vector[i].x2 * xscale);
|
|
realy2 = y + ((float)vimg->vector[i].y2 * yscale);
|
|
|
|
// draw this vector
|
|
switch (vimg->vector[i].type) {
|
|
case VT_LINE:
|
|
drawline(dest,realx1,realy1, realx2,realy2,linecol);
|
|
break;
|
|
case VT_BOX:
|
|
drawbox(dest,realx1,realy1, realx2,realy2,linecol);
|
|
break;
|
|
case VT_FILL:
|
|
floodfill(dest,realx1,realy1, fillcol);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int endtext(void) {
|
|
SDL_Rect area;
|
|
/* paste old background */
|
|
if (bg != NULL) {
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bg->w;
|
|
area.h = bg->h;
|
|
SDL_BlitSurface(bg,0,screen, &area);
|
|
SDL_UpdateRect(screen, bgx, bgy, bg->w, bg->h);
|
|
// free it
|
|
SDL_FreeSurface(bg);
|
|
}
|
|
|
|
if (strlen(text) == 0) {
|
|
return TRUE;
|
|
}
|
|
|
|
strcpy(map[curmap].textob[map[curmap].numtext].text, text);
|
|
map[curmap].textob[map[curmap].numtext].anchor = textanchor;
|
|
if (map[curmap].textob[map[curmap].numtext].anchor == -1) {
|
|
/* x,y = normal (ie. offset from 0,0) */
|
|
map[curmap].textob[map[curmap].numtext].x = startx;
|
|
map[curmap].textob[map[curmap].numtext].y = starty;
|
|
} else {
|
|
/* x,y = offset from anchor map[curmap].object's coordinates */
|
|
map[curmap].textob[map[curmap].numtext].x = startx - map[curmap].obj[textanchor].x;
|
|
map[curmap].textob[map[curmap].numtext].y = starty - map[curmap].obj[textanchor].y;
|
|
}
|
|
map[curmap].textob[map[curmap].numtext].w = strlen(text) * (DEFTEXTW);
|
|
map[curmap].textob[map[curmap].numtext].h = DEFTEXTH;
|
|
map[curmap].textob[map[curmap].numtext].c = fgcol;
|
|
|
|
/* add to 'thing' list */
|
|
map[curmap].thing[map[curmap].numthings].type = T_TEXT;
|
|
map[curmap].thing[map[curmap].numthings].id = map[curmap].numtext;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Added text object #%d: '%s'\n",map[curmap].numtext, map[curmap].textob[map[curmap].numtext].text);
|
|
drawstatusbar();
|
|
|
|
map[curmap].numtext++;
|
|
map[curmap].numthings++;
|
|
|
|
|
|
changestate(S_NONE);
|
|
|
|
drawmap();
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
int endtextmove(int x, int y) {
|
|
int txoff,tyoff;
|
|
|
|
SDL_FreeSurface(bg);
|
|
|
|
if (map[curmap].textob[map[curmap].curtext].anchor == -1) {
|
|
txoff = 0;
|
|
tyoff = 0;
|
|
} else {
|
|
txoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].x;
|
|
tyoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].y;
|
|
}
|
|
|
|
/* check position */
|
|
if ((map[curmap].textob[map[curmap].curtext].x + txoff + x - startx) >= (map[curmap].width - map[curmap].textob[map[curmap].curtext].w)) {
|
|
return -1;
|
|
}
|
|
if ((map[curmap].textob[map[curmap].curtext].y + tyoff + y - starty) >= (map[curmap].height - map[curmap].textob[map[curmap].curtext].h)) {
|
|
return -1;
|
|
}
|
|
if (map[curmap].textob[map[curmap].curtext].x + txoff <= 0) {
|
|
return -1;
|
|
}
|
|
if (map[curmap].textob[map[curmap].curtext].y + tyoff <= 0) {
|
|
return -1;
|
|
}
|
|
|
|
map[curmap].textob[map[curmap].curtext].x += (x - startx);
|
|
map[curmap].textob[map[curmap].curtext].y += (y - starty);
|
|
|
|
modified = TRUE;
|
|
return 0;
|
|
}
|
|
|
|
void floodfill(SDL_Surface *dest, int x, int y, SDL_Color fillcol) {
|
|
int testing;
|
|
SDL_Color bgcolor;
|
|
|
|
testing = 0;
|
|
|
|
//XXX: testing
|
|
if (testing) {
|
|
drawpixel(dest, x, y, fillcol);
|
|
} else {
|
|
|
|
getcolor(dest, x,y,&bgcolor);
|
|
|
|
if ((bgcolor.r == fillcol.r) && (bgcolor.g == fillcol.g) && (bgcolor.b == fillcol.b)) {
|
|
return;
|
|
}
|
|
floodfill4(dest, x, y, fillcol, bgcolor);
|
|
}
|
|
|
|
}
|
|
|
|
void push(int x, int y) {
|
|
fillstack[fillstackptr].x = x;
|
|
fillstack[fillstackptr].y = y;
|
|
fillstackptr++;
|
|
}
|
|
|
|
void pop(int *x, int *y) {
|
|
fillstackptr--;
|
|
*x = fillstack[fillstackptr].x;
|
|
*y = fillstack[fillstackptr].y;
|
|
}
|
|
|
|
void floodfill4(SDL_Surface *dest, int x, int y, SDL_Color fillcol, SDL_Color bgcol) {
|
|
SDL_Color curcolor;
|
|
|
|
push(x,y);
|
|
|
|
while (fillstackptr != 0) {
|
|
pop(&x,&y);
|
|
|
|
getcolor(dest, x,y,&curcolor);
|
|
if ((curcolor.r == bgcol.r) && (curcolor.g == bgcol.g) && (curcolor.b == bgcol.b)) {
|
|
drawpixel(dest, x, y, fillcol);
|
|
}
|
|
|
|
if (x > 0) {
|
|
getcolor(dest, x-1,y,&curcolor);
|
|
if ((curcolor.r == bgcol.r) && (curcolor.g == bgcol.g) && (curcolor.b == bgcol.b)) {
|
|
push(x-1,y);
|
|
}
|
|
}
|
|
if (y > 0) {
|
|
getcolor(dest, x,y-1,&curcolor);
|
|
if ((curcolor.r == bgcol.r) && (curcolor.g == bgcol.g) && (curcolor.b == bgcol.b)) {
|
|
push(x,y-1);
|
|
}
|
|
}
|
|
if (x < (dest->w -1)) {
|
|
getcolor(dest, x+1,y,&curcolor);
|
|
if ((curcolor.r == bgcol.r) && (curcolor.g == bgcol.g) && (curcolor.b == bgcol.b)) {
|
|
push(x+1,y);
|
|
}
|
|
}
|
|
if (y < (dest->h -1)) {
|
|
getcolor(dest, x,y+1,&curcolor);
|
|
if ((curcolor.r == bgcol.r) && (curcolor.g == bgcol.g) && (curcolor.b == bgcol.b)) {
|
|
push(x,y+1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int getcolor(SDL_Surface *dest, int x, int y, SDL_Color *col) {
|
|
Uint32 *pixel;
|
|
int bpp;
|
|
|
|
/* SHOULD ALWAYS BE 2!! */
|
|
bpp = dest->format->BytesPerPixel;
|
|
|
|
if (bpp != 2) {
|
|
printf("bpp isnt 2!!!\n");
|
|
fflush(stdout);
|
|
}
|
|
|
|
//pixel = (Uint32 *) (dest->pixels + (y * dest->w) + x) ;
|
|
pixel = (Uint32 *) (dest->pixels + y * dest->pitch + x * bpp);
|
|
|
|
|
|
|
|
SDL_GetRGB(*pixel,dest->format,
|
|
&col->r,
|
|
&col->g,
|
|
&col->b );
|
|
|
|
return 0;
|
|
}
|
|
|
|
void drawyn(char *prompt) {
|
|
SDL_Rect area;
|
|
text_t text;
|
|
|
|
/* clear map to red */
|
|
area.x = 0;
|
|
area.y = 0;
|
|
area.w = map[curmap].width;
|
|
area.h = map[curmap].height-1;
|
|
SDL_FillRect(screen, &area, SDL_MapRGB(screen->format, 255, 0, 0));
|
|
|
|
drawbox(screen, 0, 200,399,500,blue);
|
|
drawbox(screen, 400, 200,799,500,blue);
|
|
|
|
text.w = strlen(prompt)*DEFTEXTW*2;
|
|
text.h = 50;
|
|
text.x = (map[curmap].width/2) - (text.w/2);
|
|
text.y = 100;
|
|
text.anchor = -1;
|
|
text.c = blue;
|
|
strcpy(text.text, prompt);
|
|
drawtext(screen, &text);
|
|
|
|
/* draw yes & no */
|
|
text.x = 50;
|
|
text.y = 300;
|
|
text.w = 300;
|
|
text.h = 100;
|
|
text.anchor = -1;
|
|
text.c = blue;
|
|
strcpy(text.text, "Yes");
|
|
drawtext(screen, &text);
|
|
text.x = 500;
|
|
text.y = 300;
|
|
text.w = 200;
|
|
text.h = 100;
|
|
text.anchor = -1;
|
|
text.c = blue;
|
|
strcpy(text.text, "No");
|
|
drawtext(screen, &text);
|
|
|
|
SDL_Flip(screen);
|
|
|
|
}
|
|
|
|
int getyn(int x, int y) {
|
|
if ((x >= 0) && (x <= 399) && (y >= 200) && (y <= 500)) {
|
|
return YES;
|
|
} else if ((x >= 400) && (x <= 799) && (y >= 200) && (y <= 500)) {
|
|
return NO;
|
|
}
|
|
return MAYBE;
|
|
}
|
|
|
|
void goback(void) {
|
|
if (numhistory >= 1) {
|
|
curmap = history[numhistory-1];
|
|
numhistory--;
|
|
sprintf(statustext, "Changed map to map #%d (%s).",curmap,map[curmap].name);
|
|
drawmap();
|
|
} else {
|
|
sprintf(statustext, "Already at top level!");
|
|
drawstatusbar();
|
|
}
|
|
}
|
|
|
|
int linelen(int x1,int y1,int x2,int y2) {
|
|
int deltax, deltay;
|
|
int numpixels;
|
|
int d;
|
|
int dinc1,dinc2,xinc1,xinc2,yinc1,yinc2;
|
|
|
|
deltax = (x2 - x1);
|
|
if (deltax < 0) deltax = -deltax;
|
|
deltay = (y2 - y1);
|
|
if (deltay < 0) deltay = -deltay;
|
|
|
|
if (deltax >= deltay) {
|
|
numpixels = deltax + 1;
|
|
d = (deltay*2) - deltax;
|
|
dinc1 = deltay << 1;
|
|
dinc2 = (deltay-deltax) << 1;
|
|
xinc1 = 1;
|
|
xinc2 = 1;
|
|
yinc1 = 0;
|
|
yinc2 = 1;
|
|
} else {
|
|
numpixels = deltay + 1;
|
|
d = (deltax*2) - deltay;
|
|
dinc1 = deltax << 1;
|
|
dinc2 = (deltax - deltay) << 1;
|
|
xinc1 = 0;
|
|
xinc2 = 1;
|
|
yinc1 = 1;
|
|
yinc2 = 1;
|
|
}
|
|
|
|
return numpixels;
|
|
}
|
|
|
|
int linkat(int x, int y) {
|
|
int i;
|
|
for (i = 0; i < map[curmap].numlinks; i++) {
|
|
/* is (x,y) on the line? */
|
|
if (isonlink(i, x, y)) return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
int loadmap(void) {
|
|
char filename[BUFLEN];
|
|
FILE *f;
|
|
int namelen;
|
|
int i;
|
|
/* TODO: validate */
|
|
strcpy(filename, text);
|
|
|
|
|
|
sprintf(statustext,"Loading map...\n");
|
|
drawstatusbar();
|
|
|
|
f = fopen(filename, "rb");
|
|
if (!f) {
|
|
sprintf(statustext,"ERROR: Cannot open '%s'.\n",filename);
|
|
return TRUE;
|
|
}
|
|
|
|
/* TODO: free() variables! */
|
|
|
|
|
|
/* read in number maps */
|
|
fread(&nummaps, sizeof(int), 1, f);
|
|
|
|
for (i = 0; i < nummaps; i++) {
|
|
fread(&map[i].width, sizeof(int), 1, f);
|
|
fread(&map[i].height, sizeof(int), 1, f);
|
|
fread(&map[i].bpp, sizeof(int), 1, f);
|
|
fread(&map[i].bgcol, sizeof(SDL_Color), 1, f);
|
|
fread(&map[i].boxcol, sizeof(SDL_Color), 1, f);
|
|
fread(&map[i].numthings, sizeof(int), 1, f);
|
|
fread(&map[i].numobjects, sizeof(int), 1, f);
|
|
fread(&map[i].numlinks, sizeof(int), 1, f);
|
|
fread(&map[i].numtext, sizeof(int), 1, f);
|
|
map[i].selecteditem = -1;
|
|
map[i].selecteditemtype = -1;
|
|
map[i].selectedlinkpoint = -1;
|
|
map[i].selectedtype = 0;
|
|
map[i].curobj = -1;
|
|
map[i].curlink = -1;
|
|
map[i].curlinkpoint = -1;
|
|
map[i].curtext = -1;
|
|
map[i].startx = -1;
|
|
map[i].starty = -1;
|
|
map[i].textanchor = -1;
|
|
strcpy(map[i].text, "");
|
|
|
|
fread(&namelen, sizeof(int), 1, f);
|
|
fread(&map[i].name, (namelen+1) * sizeof(char), 1, f);
|
|
|
|
/* read objects */
|
|
fread(&map[i].thing, sizeof(thing_t), map[i].numthings, f);
|
|
fread(&map[i].olink, sizeof(link_t), map[i].numlinks, f);
|
|
fread(&map[i].obj, sizeof(mapobject_t), map[i].numobjects, f);
|
|
fread(&map[i].textob, sizeof(text_t), map[i].numtext, f);
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
curmap = 0;
|
|
|
|
modified = FALSE;
|
|
sprintf(statustext,"Successfully loaded map from '%s' (%d maps).\n",filename,nummaps); fflush(stdout);
|
|
strcpy(currentfilename, filename);
|
|
|
|
drawmap();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void lowerselected(void) {
|
|
int i;
|
|
int temptype,tempid;
|
|
int target;
|
|
/* find map[curmap].object */
|
|
for (i = 0; i < map[curmap].numthings; i++) {
|
|
if ((map[curmap].thing[i].id == map[curmap].selecteditem) && (map[curmap].thing[i].type == map[curmap].selecteditemtype)) {
|
|
/* swap with one below */
|
|
if (i == 0) {
|
|
break;
|
|
} else {
|
|
target = i-1;
|
|
}
|
|
tempid = map[curmap].thing[target].id;
|
|
temptype = map[curmap].thing[target].type;
|
|
map[curmap].thing[target].id = map[curmap].thing[i].id;
|
|
map[curmap].thing[target].type = map[curmap].thing[i].type;
|
|
map[curmap].thing[i].id = tempid;
|
|
map[curmap].thing[i].type = temptype;
|
|
break;
|
|
}
|
|
}
|
|
modified = TRUE;
|
|
/* redraw map */
|
|
drawmap();
|
|
}
|
|
|
|
int objat(int x, int y) {
|
|
int i;
|
|
for (i = 0; i < map[curmap].numobjects; i++) {
|
|
if ( (x >= map[curmap].obj[i].x ) && (x <= (map[curmap].obj[i].x + map[curmap].obj[i].w)) &&
|
|
(y >= map[curmap].obj[i].y ) && (y <= (map[curmap].obj[i].y + map[curmap].obj[i].h)) ) {
|
|
return i;
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
void pasteline(SDL_Surface *screen, int *lbuf) {
|
|
int deltax, deltay;
|
|
int numpixels;
|
|
int d;
|
|
int dinc1,dinc2,xinc1,xinc2,yinc1,yinc2;
|
|
int i;
|
|
int x;
|
|
int y;
|
|
SDL_Color bgcol;
|
|
int x1,y1,x2,y2;
|
|
int tlx,tly,w,h;
|
|
|
|
|
|
|
|
x1 = lbuf[0];
|
|
y1 = lbuf[1];
|
|
x2 = lbuf[2];
|
|
y2 = lbuf[3];
|
|
|
|
deltax = (x2 - x1);
|
|
if (deltax < 0) deltax = -deltax;
|
|
deltay = (y2 - y1);
|
|
if (deltay < 0) deltay = -deltay;
|
|
|
|
if (deltax >= deltay) {
|
|
numpixels = deltax + 1;
|
|
d = (deltay*2) - deltax;
|
|
dinc1 = deltay << 1;
|
|
dinc2 = (deltay-deltax) << 1;
|
|
xinc1 = 1;
|
|
xinc2 = 1;
|
|
yinc1 = 0;
|
|
yinc2 = 1;
|
|
} else {
|
|
numpixels = deltay + 1;
|
|
d = (deltax*2) - deltay;
|
|
dinc1 = deltax << 1;
|
|
dinc2 = (deltax - deltay) << 1;
|
|
xinc1 = 0;
|
|
xinc2 = 1;
|
|
yinc1 = 1;
|
|
yinc2 = 1;
|
|
}
|
|
|
|
if (x1 > x2) {
|
|
xinc1 = - xinc1;
|
|
xinc2 = - xinc2;
|
|
}
|
|
if (y1 > y2) {
|
|
yinc1 = - yinc1;
|
|
yinc2 = - yinc2;
|
|
}
|
|
|
|
x = x1; y = y1;
|
|
|
|
for (i = 0; i < numpixels; i++) {
|
|
SDL_GetRGB(lbuf[i+4],screen->format,
|
|
&bgcol.r,
|
|
&bgcol.g,
|
|
&bgcol.b );
|
|
|
|
drawpixel(screen, x, y, bgcol);
|
|
|
|
if (d < 0) {
|
|
d += dinc1;
|
|
x += xinc1;
|
|
y += yinc1;
|
|
} else {
|
|
d += dinc2;
|
|
x += xinc2;
|
|
y += yinc2;
|
|
}
|
|
}
|
|
|
|
|
|
/* update screen */
|
|
x1 = lbuf[0];
|
|
y1 = lbuf[1];
|
|
x2 = lbuf[2];
|
|
y2 = lbuf[3];
|
|
|
|
if (x2 < x1) {
|
|
if (y2 < y1) {
|
|
tlx = x2;
|
|
tly = y2;
|
|
w = x1 - x2;
|
|
h = y1 - y2;
|
|
} else {
|
|
tlx = x2;
|
|
tly = y1;
|
|
w = x1 - x2;
|
|
h = y2 - y1;
|
|
}
|
|
} else {
|
|
if (y2 < y1) {
|
|
tlx = x1;
|
|
tly = y2;
|
|
w = x2 - x1;
|
|
h = y1 - y2;
|
|
} else {
|
|
tlx = x1;
|
|
tly = y1;
|
|
w = x2 - x1;
|
|
h = y2 - y1;
|
|
}
|
|
}
|
|
|
|
|
|
SDL_UpdateRect(screen, tlx, tly,w,h);
|
|
|
|
}
|
|
|
|
int initgraphics(void) {
|
|
FILE *f;
|
|
char *p;
|
|
int line;
|
|
int state;
|
|
int n;
|
|
vectorimg_t tempv;
|
|
char buf[BUFLEN];
|
|
int x,y;
|
|
Uint8 data[32];
|
|
Uint8 mask[32];
|
|
int i;
|
|
char verstring[BUFLEN];
|
|
char file[BUFLEN];
|
|
|
|
int x1,x2,y1,y2;
|
|
SDL_Color c;
|
|
|
|
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE)==-1) {
|
|
printf("SDL_Init: %s\n", SDL_GetError());
|
|
exit(1);
|
|
}
|
|
|
|
initvars();
|
|
|
|
/* initialise mouse cursors */
|
|
|
|
/* regular cursor */
|
|
normalmouse = SDL_GetCursor();
|
|
|
|
/* object placement cursor */
|
|
for (i = 0; i < 32; i++) {
|
|
data[i] = normalmouse->data[i];
|
|
mask[i] = normalmouse->mask[i];
|
|
}
|
|
|
|
|
|
/* add square top+bottom */
|
|
for (x = 10; x < 16; x++) {
|
|
y = 10;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
y = 15;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
}
|
|
/* sides */
|
|
for (y = 10; y < 16; y++) {
|
|
x = 10;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
x = 15;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
}
|
|
|
|
objmouse = SDL_CreateCursor(data, mask, normalmouse->area.w, normalmouse->area.h, 0, 0);
|
|
|
|
|
|
/* text placement cursor */
|
|
for (i = 0; i < 32; i++) {
|
|
data[i] = normalmouse->data[i];
|
|
mask[i] = normalmouse->mask[i];
|
|
}
|
|
|
|
|
|
/* add A crossstroke*/
|
|
for (x = 10; x < 15; x++) {
|
|
y = 13;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
}
|
|
/* downstrokes */
|
|
for (y = 11; y < 16; y++) {
|
|
x = 10;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
x = 14;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
}
|
|
/* pointy bit */
|
|
x = 11; y = 10;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
x = 13; y = 10;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
x = 12; y = 9;
|
|
data[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
mask[(x/8)+(y*2)] |= (128 >> (x%8));
|
|
|
|
|
|
textmouse = SDL_CreateCursor(data, mask, normalmouse->area.w, normalmouse->area.h, 0, 0);
|
|
|
|
/* open window */
|
|
screen = SDL_SetVideoMode(map[curmap].width + SIDEBARW, map[curmap].height + DEFTEXTH+4, map[curmap].bpp, SDL_HWSURFACE|SDL_DOUBLEBUF);
|
|
if(!screen) {
|
|
printf("SDL_SetVideoMode: %s\n", SDL_GetError());
|
|
return -1;
|
|
}
|
|
if (screen->flags & SDL_SWSURFACE) {
|
|
printf("SWSurface set ok.\n"); fflush(stdout);
|
|
}
|
|
if (screen->flags & SDL_HWSURFACE) {
|
|
printf("HWSurface set ok.\n"); fflush(stdout);
|
|
}
|
|
if (screen->flags & SDL_DOUBLEBUF) {
|
|
printf("Doublebuf set ok.\n"); fflush(stdout);
|
|
}
|
|
|
|
sprintf(verstring, "netmapr v%s, by rpearce 2005", VERSION);
|
|
SDL_WM_SetCaption(verstring,"netmapr");
|
|
|
|
/* initialise buffer */
|
|
buffer = SDL_CreateRGBSurface(SDL_SWSURFACE,map[curmap].width,map[curmap].height,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
|
|
if (!buffer) {
|
|
printf("Cannot create buffer!\n");
|
|
exit(1);
|
|
}
|
|
|
|
|
|
printf("Reading shapes...\n");
|
|
f = fopen("objects.dat","rt");
|
|
if (!f) {
|
|
sprintf(file, "/usr/local/share/netmapr/objects.dat");
|
|
f = fopen(file,"rt");
|
|
}
|
|
if (!f) {
|
|
sprintf(file, "%s/objects.dat",progdir);
|
|
f = fopen(file,"rt");
|
|
}
|
|
if (!f) {
|
|
printf("Cannot open objects file!\n");
|
|
exit(1);
|
|
}
|
|
|
|
state = 0;
|
|
line = 0;
|
|
numobjtypes = 0;
|
|
n = 0;
|
|
fgets(buf, BUFLEN, f);
|
|
buf[strlen(buf)-1] = '\0';
|
|
line++;
|
|
while (!feof(f)) {
|
|
/* ignore comments */
|
|
if (buf[0] != '#') {
|
|
if (state == 0) {
|
|
p = strtok(buf, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
if (strcmp(p, "object")) {
|
|
printf("Expecting 'object' on line #%d of objects file (got '%s').\n",line,p);
|
|
exit(1);
|
|
}
|
|
/* name */
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
strncpy(objtype[numobjtypes].name, p, BUFLEN);
|
|
/* width */
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
objtype[numobjtypes].vimg.w = atoi(p);
|
|
/* height */
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
objtype[numobjtypes].vimg.h = atoi(p);
|
|
|
|
/* no vectors to start with */
|
|
objtype[numobjtypes].vimg.vnum = 0;
|
|
objtype[numobjtypes].canscale = TRUE;
|
|
|
|
/* default size is minimum */
|
|
objtype[numobjtypes].defw = MINOBJWIDTH;
|
|
objtype[numobjtypes].defh = MINOBJHEIGHT;
|
|
|
|
state = 1;
|
|
} else if (state == 1) {
|
|
p = strtok(buf, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
if (!strcmp(p, "line")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
x2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
y2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.r = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.g = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.b = atoi(p);
|
|
|
|
if (addvector(&objtype[numobjtypes].vimg,VT_LINE,x1,y1,x2,y2,&c)) {
|
|
printf("Too many vectors on line %d of objects file.\n",line);
|
|
exit(1);
|
|
}
|
|
|
|
} else if (!strcmp(p, "fill")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.r = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.g = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.b = atoi(p);
|
|
|
|
if (addvector(&objtype[numobjtypes].vimg,VT_FILL,x1,y1,0,0,&c)) {
|
|
printf("Too many vectors on line %d of objects file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "box")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
x2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
y2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.r = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.g = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of objects file.\n",line); exit(1); }
|
|
c.b = atoi(p);
|
|
|
|
if (addvector(&objtype[numobjtypes].vimg,VT_BOX,x1,y1,x2,y2,&c)) {
|
|
printf("Too many vectors on line %d of objects file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "end")) {
|
|
state = 0;
|
|
numobjtypes++;
|
|
if (numobjtypes >= MAXOBJTYPES) {
|
|
printf("FATAL: Too many object types found (max is %d).\n",MAXOBJTYPES);
|
|
exit(1);
|
|
}
|
|
} else {
|
|
printf("Invalid command '%s' on line #%d of objects file.\n",p,line);
|
|
exit(1);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
fgets(buf, BUFLEN, f);
|
|
buf[strlen(buf)-1] = '\0';
|
|
line++;
|
|
}
|
|
fclose(f);
|
|
printf("Shape load complete - %d objects found.\n",numobjtypes);
|
|
|
|
printf("Reading buttons...\n");
|
|
f = fopen("buttons.dat","rt");
|
|
if (!f) {
|
|
sprintf(file, "/usr/local/share/netmapr/buttons.dat");
|
|
f = fopen(file,"rt");
|
|
}
|
|
if (!f) {
|
|
sprintf(file, "%s/buttons.dat",progdir);
|
|
f = fopen(file,"rt");
|
|
}
|
|
if (!f) {
|
|
printf("Cannot open buttons file!\n");
|
|
exit(1);
|
|
}
|
|
|
|
state = 0;
|
|
line = 0;
|
|
numbuttons = 0;
|
|
n = 0;
|
|
fgets(buf, BUFLEN, f);
|
|
buf[strlen(buf)-1] = '\0';
|
|
line++;
|
|
while (!feof(f)) {
|
|
/* ignore comments */
|
|
if (buf[0] != '#') {
|
|
if (state == 0) {
|
|
p = strtok(buf, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
if (strcmp(p, "button")) {
|
|
printf("Expecting 'button' on line #%d of buttons file (got '%s').\n",line,p);
|
|
exit(1);
|
|
}
|
|
/* name */
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
strncpy(button[numbuttons].name, p, BUFLEN);
|
|
/* width */
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
tempv.w = atoi(p);
|
|
/* height */
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
tempv.h = atoi(p);
|
|
|
|
|
|
/* allocate mem */
|
|
button[numbuttons].img = SDL_CreateRGBSurface(SDL_SWSURFACE,toolbox.gridsize-2,toolbox.gridsize-2,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
|
|
tempv.vnum = 0;
|
|
|
|
|
|
state = 1;
|
|
} else if (state == 1) {
|
|
p = strtok(buf, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
if (!strcmp(p, "line")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
x2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
y2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.r = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.g = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.b = atoi(p);
|
|
|
|
if (addvector(&tempv,VT_LINE,x1,y1,x2,y2,&c)) {
|
|
printf("Too many vectors on line %d of objects file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "fill")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.r = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.g = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.b = atoi(p);
|
|
|
|
if (addvector(&tempv,VT_FILL,x1,y1,0,0,&c)) {
|
|
printf("Too many vectors on line %d of objects file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "box")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
x2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
y2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.r = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.g = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of buttons file.\n",line); exit(1); }
|
|
c.b = atoi(p);
|
|
|
|
if (addvector(&tempv,VT_BOX,x1,y1,x2,y2,&c)) {
|
|
printf("Too many vectors on line %d of buttons file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "end")) {
|
|
/* draw vector image into button's bitmap field */
|
|
drawvector(button[numbuttons].img, &tempv, 1, 1, toolbox.gridsize-2,toolbox.gridsize-2, NULL);
|
|
|
|
|
|
//printf("Adding button: '%s' (vnum = %d).\n",button[numbuttons].name,tempv.vnum);
|
|
state = 0;
|
|
numbuttons++;
|
|
} else {
|
|
printf("Invalid command '%s' on line #%d of buttons file.\n",p,line);
|
|
exit(1);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
fgets(buf, BUFLEN, f);
|
|
buf[strlen(buf)-1] = '\0';
|
|
line++;
|
|
}
|
|
fclose(f);
|
|
printf("Button load complete - %d buttons found.\n",numbuttons);
|
|
|
|
printf("Reading letters...\n");
|
|
f = fopen("letters.dat","rt");
|
|
if (!f) {
|
|
sprintf(file, "/usr/local/share/netmapr/letters.dat");
|
|
f = fopen(file,"rt");
|
|
}
|
|
if (!f) {
|
|
sprintf(file, "%s/letters.dat",progdir);
|
|
f = fopen(file,"rt");
|
|
}
|
|
if (!f) {
|
|
printf("Cannot open letters file!\n");
|
|
exit(1);
|
|
}
|
|
|
|
state = 0;
|
|
line = 0;
|
|
numletters = 0;
|
|
n = 0;
|
|
fgets(buf, BUFLEN, f);
|
|
buf[strlen(buf)-1] = '\0';
|
|
line++;
|
|
while (!feof(f)) {
|
|
// ignore comments
|
|
if (buf[0] != '#') {
|
|
if (state == 0) {
|
|
p = strtok(buf, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
if (strcmp(p, "letter")) {
|
|
printf("Expecting 'letter' on line #%d of letters file (got '%s').\n",line,p);
|
|
exit(1);
|
|
}
|
|
// name
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
letter[numletters].name = p[0];
|
|
// width
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
letter[numletters].vect.w = atoi(p);
|
|
// height
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
letter[numletters].vect.h = atoi(p);
|
|
|
|
|
|
letter[numletters].vect.vnum = 0;
|
|
|
|
|
|
state = 1;
|
|
} else if (state == 1) {
|
|
p = strtok(buf, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
if (!strcmp(p, "line")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
x2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
y2 = atoi(p);
|
|
|
|
c = fgcol;
|
|
|
|
if (addvector(&letter[numletters].vect,VT_LINE,x1,y1,x2,y2,&c)) {
|
|
printf("Too many vectors on line %d of letters file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "fill")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
|
|
c = fgcol;
|
|
|
|
if (addvector(&letter[numletters].vect,VT_FILL,x1,y1,0,0,&c)) {
|
|
printf("Too many vectors on line %d of letters file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "box")) {
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
x1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
y1 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
x2 = atoi(p);
|
|
p = strtok(NULL, " ");
|
|
if (p == NULL) { printf("Missing token on line #%d of letters file.\n",line); exit(1); }
|
|
y2 = atoi(p);
|
|
|
|
c = fgcol;
|
|
|
|
if (addvector(&letter[numletters].vect,VT_BOX,x1,y1,x2,y2,&c)) {
|
|
printf("Too many vectors on line %d of letters file.\n",line);
|
|
exit(1);
|
|
}
|
|
} else if (!strcmp(p, "end")) {
|
|
|
|
//printf("Adding letter %d: '%c' (vnum = %d).\n",numletters,letter[numletters].name,letter[numletters].vect.vnum);
|
|
state = 0;
|
|
numletters++;
|
|
if (numletters >= MAXLETTERVECTS) {
|
|
printf("FATAL: Too many letters found (max is %d).\n",MAXLETTERVECTS);
|
|
exit(1);
|
|
}
|
|
} else {
|
|
printf("Invalid command '%s' on line #%d of letters file.\n",p,line);
|
|
exit(1);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
fgets(buf, BUFLEN, f);
|
|
buf[strlen(buf)-1] = '\0';
|
|
line++;
|
|
}
|
|
fclose(f);
|
|
printf("Letter load complete - %d letters found.\n",numletters);
|
|
|
|
////////////////////////////////////////////////////////////
|
|
/// XXX: TESTING ///
|
|
|
|
/*
|
|
x = 10; y = 10;
|
|
for (i = 0; i < numletters; i++) {
|
|
int lw,lh;
|
|
lw = 8;
|
|
lh = 10;
|
|
drawvector(screen, &letter[i].vect, x, y, lw,lh);
|
|
x = x + lw + 2;
|
|
if (x >= (map[curmap].width - lw)) {
|
|
x = 0;
|
|
y = y + lh + 2;
|
|
}
|
|
}
|
|
SDL_Flip(screen);
|
|
while(1) {
|
|
while (SDL_PollEvent(&event)) {
|
|
switch (event.type) {
|
|
case SDL_KEYDOWN:
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int isonline (int fx, int fy, int x1, int y1, int x2, int y2) {
|
|
int deltax, deltay;
|
|
int numpixels;
|
|
int d;
|
|
int dinc1,dinc2,xinc1,xinc2,yinc1,yinc2;
|
|
int i;
|
|
int x;
|
|
int y;
|
|
|
|
deltax = (x2 - x1);
|
|
if (deltax < 0) deltax = -deltax;
|
|
deltay = (y2 - y1);
|
|
if (deltay < 0) deltay = -deltay;
|
|
|
|
if (deltax >= deltay) {
|
|
numpixels = deltax + 1;
|
|
d = (deltay*2) - deltax;
|
|
dinc1 = deltay << 1;
|
|
dinc2 = (deltay-deltax) << 1;
|
|
xinc1 = 1;
|
|
xinc2 = 1;
|
|
yinc1 = 0;
|
|
yinc2 = 1;
|
|
} else {
|
|
numpixels = deltay + 1;
|
|
d = (deltax*2) - deltay;
|
|
dinc1 = deltax << 1;
|
|
dinc2 = (deltax - deltay) << 1;
|
|
xinc1 = 0;
|
|
xinc2 = 1;
|
|
yinc1 = 1;
|
|
yinc2 = 1;
|
|
}
|
|
|
|
if (x1 > x2) {
|
|
xinc1 = - xinc1;
|
|
xinc2 = - xinc2;
|
|
}
|
|
if (y1 > y2) {
|
|
yinc1 = - yinc1;
|
|
yinc2 = - yinc2;
|
|
}
|
|
|
|
x = x1; y = y1;
|
|
|
|
for (i = 0; i < numpixels; i++) {
|
|
|
|
if ((fx >= (x-LINESELTHRESHOLD)) && (fx <= (x+LINESELTHRESHOLD)) &&
|
|
(fy >= (y-LINESELTHRESHOLD)) && (fy <= (y+LINESELTHRESHOLD))) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (d < 0) {
|
|
d += dinc1;
|
|
x += xinc1;
|
|
y += yinc1;
|
|
} else {
|
|
d += dinc2;
|
|
x += xinc2;
|
|
y += yinc2;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int isonlink (int linkid, int mx, int my) {
|
|
int i;
|
|
int x,y,x2,y2;
|
|
|
|
x = map[curmap].obj[map[curmap].olink[linkid].srcobj].x + map[curmap].olink[linkid].srcxoff;
|
|
y = map[curmap].obj[map[curmap].olink[linkid].srcobj].y + map[curmap].olink[linkid].srcyoff;
|
|
|
|
for (i = 0; i < map[curmap].olink[linkid].npoints; i++) {
|
|
x2 = map[curmap].olink[linkid].point[i].x;
|
|
y2 = map[curmap].olink[linkid].point[i].y;
|
|
|
|
if (isonline(mx,my,x,y,x2,y2)) return TRUE;
|
|
|
|
x = x2;
|
|
y = y2;
|
|
}
|
|
|
|
/* draw line to final map[curmap].object */
|
|
x2 = map[curmap].obj[map[curmap].olink[linkid].dstobj].x + map[curmap].olink[linkid].dstxoff;
|
|
y2 = map[curmap].obj[map[curmap].olink[linkid].dstobj].y + map[curmap].olink[linkid].dstyoff;
|
|
|
|
if (isonline(mx,my,x,y,x2,y2)) return TRUE;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
int isonlinkdst(int lineid, int x, int y) {
|
|
int hx1,hy1,hx2,hy2;
|
|
|
|
hx1 = map[curmap].obj[map[curmap].olink[lineid].dstobj].x + map[curmap].olink[lineid].dstxoff - (LINESELHANDLESIZE/2);
|
|
hy1 = map[curmap].obj[map[curmap].olink[lineid].dstobj].y + map[curmap].olink[lineid].dstyoff - (LINESELHANDLESIZE/2);
|
|
hx2 = hx1 + LINESELHANDLESIZE;
|
|
hy2 = hy1 + LINESELHANDLESIZE;
|
|
|
|
if ((x >= hx1) && ( x <= hx2) && (y >= hy1) & (y <= hy2)) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int isonlinkpoint(int lineid, int mx, int my) {
|
|
int i;
|
|
|
|
for (i = 0; i < map[curmap].olink[lineid].npoints; i++) {
|
|
int x,y;
|
|
|
|
x = map[curmap].olink[lineid].point[i].x;
|
|
y = map[curmap].olink[lineid].point[i].y;
|
|
|
|
if ((mx >= (x-LINESELTHRESHOLD)) && (mx <= (x+LINESELTHRESHOLD)) &&
|
|
(my >= (y-LINESELTHRESHOLD)) && (my <= (y+LINESELTHRESHOLD))) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int isonlinksrc(int lineid, int x, int y) {
|
|
int hx1,hy1,hx2,hy2;
|
|
|
|
hx1 = map[curmap].obj[map[curmap].olink[lineid].srcobj].x + map[curmap].olink[lineid].srcxoff - (LINESELHANDLESIZE/2);
|
|
hy1 = map[curmap].obj[map[curmap].olink[lineid].srcobj].y + map[curmap].olink[lineid].srcyoff - (LINESELHANDLESIZE/2);
|
|
hx2 = hx1 + LINESELHANDLESIZE;
|
|
hy2 = hy1 + LINESELHANDLESIZE;
|
|
|
|
if ((x >= hx1) && ( x <= hx2) && (y >= hy1) & (y <= hy2)) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int isonmap(int x, int y) {
|
|
if ((x >= 0) && ( y >= 0) && (x <= map[curmap].width) && (y <= map[curmap].height)) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int isonmapbox(int x, int y) {
|
|
if ((x >= mapbox.x) && ( y >= mapbox.y) && (x <= mapbox.x+mapbox.width) && (y <= mapbox.y+mapbox.height)) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int isonmapboxchildren(int x, int y) {
|
|
if ((x >= mapbox.x) && ( y >= mapbox.y+(DEFTEXTH*2)+2) && (x <= mapbox.x+mapbox.width) && (y <= mapbox.y+mapbox.height)) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int isonmapname(int x, int y) {
|
|
if ((x >= mapbox.x) && ( y >= mapbox.y) && (x <= mapbox.x+mapbox.width) && (y <= mapbox.y+DEFTEXTH+2)) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
int isongoback(int x, int y) {
|
|
if ((x >= mapbox.x) && ( y >= (mapbox.y + DEFTEXTH))
|
|
&& (x <= mapbox.x+mapbox.width) && (y <= mapbox.y+(DEFTEXTH*2))) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int isonobox(int x, int y) {
|
|
if ((x >= obox.x) && ( y >= obox.y) && (x <= obox.x+obox.width) && (y <= obox.y+obox.height)) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int isontoolbox(int x, int y) {
|
|
if ((x >= toolbox.x) && ( y >= toolbox.y) && (x <= toolbox.x+toolbox.width) && (y <= toolbox.y+toolbox.height)) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void initmap(int mapnum) {
|
|
map[mapnum].width = 800;
|
|
map[mapnum].height = 600 - DEFTEXTH;
|
|
map[mapnum].bpp = 16;
|
|
map[mapnum].bgcol.r = 255;
|
|
map[mapnum].bgcol.g = 255;
|
|
map[mapnum].bgcol.b = 255;
|
|
map[mapnum].boxcol.r = 90;
|
|
map[mapnum].boxcol.g = 90;
|
|
map[mapnum].boxcol.b = 90;
|
|
|
|
map[mapnum].numthings = 0;
|
|
map[mapnum].numobjects = 0;
|
|
map[mapnum].numlinks = 0;
|
|
map[mapnum].numtext = 0;
|
|
|
|
map[mapnum].selecteditem = -1;
|
|
map[mapnum].selecteditemtype = -1;
|
|
map[mapnum].selectedlinkpoint = -1;
|
|
map[mapnum].selectedtype = 0;
|
|
|
|
map[mapnum].curobj = -1; /* map[curmap].object being moved/dragged/etc */
|
|
map[mapnum].curlink = -1; /* link being moved/dragged/etc */
|
|
map[mapnum].curlinkpoint = -1; /* link pomap[mapnum].being moved/dragged/etc */
|
|
map[mapnum].curtext = -1; /* text being moved/dragged/etc */
|
|
map[mapnum].startx = -1;
|
|
map[mapnum].starty = -1;
|
|
map[mapnum].textanchor = -1;
|
|
strcpy(map[mapnum].text, "");
|
|
if (mapnum == 0) {
|
|
sprintf(map[mapnum].name, "Toplevel");
|
|
} else {
|
|
sprintf(map[mapnum].name, "Map #%d",mapnum);
|
|
}
|
|
|
|
modified = FALSE;
|
|
|
|
|
|
}
|
|
|
|
void initvars(void) {
|
|
nummaps = 1;
|
|
|
|
strcpy(currentfilename, "");
|
|
|
|
/* set globals */
|
|
initmap(0);
|
|
|
|
curmap = 0;
|
|
|
|
obox.x = map[curmap].width + 1;
|
|
obox.y = (map[curmap].height / 4) * 3;
|
|
obox.width = SIDEBARW;
|
|
obox.height = map[curmap].height - obox.y;
|
|
obox.pos = 0;
|
|
obox.bgcol = black;
|
|
obox.gridbgcol = grey4;
|
|
obox.gridcol = grey;
|
|
obox.gridsize = 30;
|
|
obox.gridrowlen = SIDEBARW / obox.gridsize;
|
|
|
|
toolbox.x = map[curmap].width + 1;
|
|
toolbox.y = 0;
|
|
toolbox.width = SIDEBARW;
|
|
toolbox.height = map[curmap].height / 3;
|
|
toolbox.bgcol = black;
|
|
//toolbox.gridcol = grey3;
|
|
toolbox.gridsize = 30;
|
|
toolbox.gridrowlen = SIDEBARW / toolbox.gridsize;
|
|
|
|
mapbox.x = map[curmap].width + 1;
|
|
mapbox.y = toolbox.y+toolbox.height+1;
|
|
mapbox.width = SIDEBARW;
|
|
mapbox.height = obox.y - mapbox.y - 20;
|
|
|
|
|
|
fgcol = black;
|
|
objfillcol = yellow;
|
|
|
|
}
|
|
|
|
void raiseselected(void) {
|
|
int i;
|
|
int temptype,tempid;
|
|
int target;
|
|
/* find map[curmap].object */
|
|
for (i = 0; i < map[curmap].numthings; i++) {
|
|
if ((map[curmap].thing[i].id == map[curmap].selecteditem) && (map[curmap].thing[i].type == map[curmap].selecteditemtype)) {
|
|
/* swap with one above */
|
|
if (i == (map[curmap].numthings-1)) {
|
|
break;
|
|
} else {
|
|
target = i+1;
|
|
}
|
|
tempid = map[curmap].thing[target].id;
|
|
temptype = map[curmap].thing[target].type;
|
|
map[curmap].thing[target].id = map[curmap].thing[i].id;
|
|
map[curmap].thing[target].type = map[curmap].thing[i].type;
|
|
map[curmap].thing[i].id = tempid;
|
|
map[curmap].thing[i].type = temptype;
|
|
break;
|
|
}
|
|
}
|
|
modified = TRUE;
|
|
/* redraw map */
|
|
drawmap();
|
|
}
|
|
|
|
int savemap(void) {
|
|
char filename[BUFLEN];
|
|
FILE *f;
|
|
int namelen;
|
|
int i;
|
|
int eoff;
|
|
SDL_Surface *exportmap;
|
|
SDL_Rect area;
|
|
|
|
/* TODO: validate */
|
|
strcpy(filename, text);
|
|
|
|
|
|
sprintf(statustext,"Saving map...\n");
|
|
drawstatusbar();
|
|
|
|
|
|
|
|
/* is this an export? (use extenstion) */
|
|
if (strlen(filename) >= 5) {
|
|
eoff = strlen(filename)-4;
|
|
if ((filename[eoff] == '.') &&
|
|
((filename[eoff+1] == 'b') || (filename[eoff+1] == 'B')) &&
|
|
((filename[eoff+2] == 'm') || (filename[eoff+2] == 'M')) &&
|
|
((filename[eoff+3] == 'p') || (filename[eoff+3] == 'P'))
|
|
) {
|
|
exportmap = SDL_CreateRGBSurface(SDL_SWSURFACE,map[curmap].width, map[curmap].height,
|
|
buffer->format->BitsPerPixel, buffer->format->Rmask,
|
|
buffer->format->Gmask,buffer->format->Bmask,
|
|
buffer->format->Amask);
|
|
|
|
state = S_NONE;
|
|
drawmap();
|
|
area.x = 0;
|
|
area.y = 0;
|
|
area.w = map[curmap].width;
|
|
area.h = map[curmap].height;
|
|
SDL_BlitSurface(screen,&area,exportmap, 0);
|
|
if (SDL_SaveBMP(exportmap, filename)) {
|
|
sprintf(statustext,"ERROR: Could not export to BMP file '%s'.\n",filename);
|
|
drawstatusbar();
|
|
return TRUE;
|
|
}
|
|
sprintf(statustext,"Successfully exported map to BMP file '%s'.\n",filename);
|
|
drawstatusbar();
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if ((f = fopen(filename, "wb")) == NULL) {
|
|
sprintf(statustext,"ERROR: Could not open '%s'.\n",filename);
|
|
drawstatusbar();
|
|
return TRUE;
|
|
}
|
|
|
|
/* dump out numbers of map[curmap].objects */
|
|
fwrite(&nummaps, sizeof(int), 1, f);
|
|
|
|
for (i = 0; i < nummaps; i++) {
|
|
fwrite(&map[i].width, sizeof(int), 1, f);
|
|
fwrite(&map[i].height, sizeof(int), 1, f);
|
|
fwrite(&map[i].bpp, sizeof(int), 1, f);
|
|
fwrite(&map[i].bgcol, sizeof(SDL_Color), 1, f);
|
|
fwrite(&map[i].boxcol, sizeof(SDL_Color), 1, f);
|
|
fwrite(&map[i].numthings, sizeof(int), 1, f);
|
|
fwrite(&map[i].numobjects, sizeof(int), 1, f);
|
|
fwrite(&map[i].numlinks, sizeof(int), 1, f);
|
|
fwrite(&map[i].numtext, sizeof(int), 1, f);
|
|
/* selecteditem*/
|
|
/* selecteditemtype*/
|
|
/* selectedlinkpoint*/
|
|
/* selectedtype*/
|
|
/* curobj*/
|
|
/* curlink*/
|
|
/* curlinkpoint*/
|
|
/* curtext*/
|
|
/* startx,starty */
|
|
/* textanchor */
|
|
/* text*/
|
|
namelen = strlen(map[i].name);
|
|
fwrite(&namelen, sizeof(int), 1, f);
|
|
fwrite(&map[i].name, (namelen+1) * sizeof(char), 1, f);
|
|
|
|
/* write objects */
|
|
fwrite(&map[i].thing, sizeof(thing_t), map[i].numthings, f);
|
|
fwrite(&map[i].olink, sizeof(link_t), map[i].numlinks, f);
|
|
fwrite(&map[i].obj, sizeof(mapobject_t), map[i].numobjects, f);
|
|
fwrite(&map[i].textob, sizeof(text_t), map[i].numtext, f);
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
|
|
modified = FALSE;
|
|
sprintf(statustext,"Successfully saved map to '%s'.\n",filename);
|
|
|
|
/* save filename */
|
|
strcpy(currentfilename, filename);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int showfiledialog(void) {
|
|
Uint32 fillcol;
|
|
text_t temp;
|
|
SDL_Rect area,sarea;
|
|
int y;
|
|
SDL_Color ccol;
|
|
|
|
/* clear map */
|
|
fillcol = SDL_MapRGB(buffer->format, map[curmap].bgcol.r,map[curmap].bgcol.g,map[curmap].bgcol.b);
|
|
SDL_FillRect(buffer, NULL, fillcol);
|
|
|
|
/* */
|
|
switch (state) {
|
|
case S_SAVING:
|
|
strcpy(temp.text,"Enter save filename:");
|
|
break;
|
|
case S_LOADING:
|
|
strcpy(temp.text,"Enter load filename:");
|
|
break;
|
|
case S_MAPNAMING:
|
|
strcpy(temp.text,"Enter new map name:");
|
|
break;
|
|
default:
|
|
strcpy(temp.text,"Enter filename:");
|
|
break;
|
|
}
|
|
temp.w = strlen(temp.text) * (DEFTEXTW * 2);
|
|
temp.h = DEFTEXTH*2;
|
|
temp.x = (map[curmap].width / 2) - (temp.w / 2);
|
|
temp.y = (map[curmap].height / 2) - (temp.h*4);
|
|
temp.c = black;
|
|
temp.anchor = -1;
|
|
|
|
drawtext(buffer, &temp);
|
|
|
|
/* draw outlines */
|
|
drawbox(buffer,0,0,map[curmap].width-1,map[curmap].height-DEFTEXTH-3,blue);
|
|
|
|
drawbox(buffer,0,(map[curmap].height/2)-2,map[curmap].width-1,(map[curmap].height/2)+(DEFTEXTH*2)+2,blue);
|
|
|
|
/* actually draw the text */
|
|
|
|
/* paste old background */
|
|
if (bg != NULL) {
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bg->w;
|
|
area.h = bg->h;
|
|
SDL_BlitSurface(bg,0,screen, &area);
|
|
// free it
|
|
//SDL_UpdateRect(screen,area.x, area.y, area.w, area.h);
|
|
SDL_FreeSurface(bg);
|
|
}
|
|
/* copy new background */
|
|
sarea.x = startx;
|
|
sarea.y = starty;
|
|
sarea.w = ((strlen(text)+1) * (DEFTEXTW*2)) +2; // include space for cursor
|
|
sarea.h = DEFTEXTH*2;
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE,sarea.w, sarea.h,
|
|
buffer->format->BitsPerPixel, buffer->format->Rmask,
|
|
buffer->format->Gmask,buffer->format->Bmask,
|
|
buffer->format->Amask);
|
|
SDL_BlitSurface(screen,&sarea,bg,0);
|
|
bgx = sarea.x;
|
|
bgy = sarea.y;
|
|
/* draw text */
|
|
strcpy(temp.text, text);
|
|
temp.x = startx;
|
|
temp.y = starty;
|
|
temp.w = strlen(temp.text) * (DEFTEXTW*2);
|
|
temp.h = DEFTEXTH*2;
|
|
temp.c = fgcol;
|
|
temp.anchor = -1;
|
|
|
|
drawtext(buffer, &temp);
|
|
|
|
/* draw cursor (a solid block) */
|
|
ccol = blue;
|
|
for (y = starty ; y < (starty + DEFTEXTH*2); y++ ) {
|
|
drawline(buffer, startx + temp.w, y, startx + temp.w + (DEFTEXTW*2),y,ccol);
|
|
}
|
|
|
|
/* blit to screen */
|
|
SDL_BlitSurface(buffer, 0, screen, 0);
|
|
SDL_UpdateRect(screen, 0, 0, map[curmap].width, map[curmap].height);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int startlink(int x, int y) {
|
|
int linex1,liney1,linex2,liney2;
|
|
int len;
|
|
|
|
xoff = x - map[curmap].obj[map[curmap].curobj].x;
|
|
yoff = y - map[curmap].obj[map[curmap].curobj].y;
|
|
|
|
startx = x;
|
|
starty = y;
|
|
|
|
startobj = map[curmap].curobj;
|
|
|
|
changestate(S_DRAWLINK);
|
|
|
|
/* copy line */
|
|
linex1 = startx;
|
|
liney1 = starty;
|
|
linex2 = x;
|
|
liney2 = y;
|
|
|
|
len = linelen(linex1,liney1,linex2,liney2);
|
|
linebg = malloc((len + 4) * sizeof(int));
|
|
|
|
|
|
copyline(screen, linex1,liney1,linex2,liney2, linebg );
|
|
|
|
|
|
sprintf(statustext,"Creating link #%d...\n", map[curmap].numlinks);
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int startlinkdstmove(int x, int y) {
|
|
int linex1,liney1,linex2,liney2;
|
|
int len;
|
|
|
|
startx = x;
|
|
starty = y;
|
|
|
|
changestate(S_LINKDSTMOVE);
|
|
|
|
/* copy background */
|
|
linex1 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].x + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstxoff;
|
|
liney1 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].y + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstyoff;
|
|
linex2 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].x + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstxoff;
|
|
liney2 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].y + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstyoff;
|
|
|
|
len = linelen(linex1,liney1,linex2,liney2);
|
|
linebg = malloc((len + 4) * sizeof(int));
|
|
|
|
copyline(screen, linex1,liney1,linex2,liney2, linebg );
|
|
|
|
sprintf(statustext,"Starting dst endpoint move for link #%d...\n", map[curmap].curlink); fflush(stdout);
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int startlinkpointmove(int x, int y) {
|
|
int linex1,liney1,linex2,liney2;
|
|
SDL_Rect area;
|
|
|
|
startx = x;
|
|
starty = y;
|
|
|
|
changestate(S_LINKPOINTMOVE);
|
|
|
|
/* copy background */
|
|
linex1 = map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].x - (LINESELHANDLESIZE / 2);
|
|
liney1 = map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].y - (LINESELHANDLESIZE / 2);
|
|
linex2 = map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].x + (LINESELHANDLESIZE / 2)+2;
|
|
liney2 = map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].y + (LINESELHANDLESIZE / 2)+2;
|
|
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE, LINESELHANDLESIZE, LINESELHANDLESIZE,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
|
|
bgx = linex1;
|
|
bgy = liney1;
|
|
|
|
area.x = linex1;
|
|
area.y = liney1;
|
|
area.w = LINESELHANDLESIZE+4;
|
|
area.h = LINESELHANDLESIZE+4;
|
|
SDL_BlitSurface(screen, &area, bg,0);
|
|
|
|
sprintf(statustext,"Starting link point move for link #%d poinrt #%d...\n", map[curmap].curlink,map[curmap].curlinkpoint);
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int startlinksrcmove(int x, int y) {
|
|
int linex1,liney1,linex2,liney2;
|
|
int len;
|
|
|
|
startx = x;
|
|
starty = y;
|
|
|
|
changestate(S_LINKSRCMOVE);
|
|
|
|
/* copy background */
|
|
linex1 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].srcobj].x + map[curmap].olink[map[curmap].olink[map[curmap].curlink].srcobj].srcxoff;
|
|
liney1 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].srcobj].y + map[curmap].olink[map[curmap].olink[map[curmap].curlink].srcobj].srcyoff;
|
|
linex2 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].x + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstxoff;
|
|
liney2 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].y + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstyoff;
|
|
|
|
len = linelen(linex1,liney1,linex2,liney2);
|
|
if (len <= 0) {
|
|
printf("ERROR: length is zero or negative - %d\n",len);
|
|
fflush(stdout);
|
|
exit(1);
|
|
}
|
|
linebg = malloc((len + 4) * sizeof(int));
|
|
|
|
if (linebg == NULL) {
|
|
printf("ERROR: cannot malloc()\n"); fflush(stdout);
|
|
}
|
|
|
|
copyline(screen, linex1,liney1,linex2,liney2, linebg);
|
|
|
|
sprintf(statustext,"Starting src endpoint move for link #%d...\n", map[curmap].curlink); fflush(stdout);
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int startlinkmove (int x, int y) {
|
|
int linex1,liney1;
|
|
int linex2,liney2;
|
|
int len;
|
|
|
|
startx = x;
|
|
starty = y;
|
|
changestate(S_LINKMOVING);
|
|
/* copy background */
|
|
linex1 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].srcobj].x + map[curmap].olink[map[curmap].olink[map[curmap].curlink].srcobj].srcxoff;
|
|
liney1 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].srcobj].y + map[curmap].olink[map[curmap].olink[map[curmap].curlink].srcobj].srcyoff;
|
|
linex2 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].x + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstxoff;
|
|
liney2 = map[curmap].obj[map[curmap].olink[map[curmap].curlink].dstobj].y + map[curmap].olink[map[curmap].olink[map[curmap].curlink].dstobj].dstyoff;
|
|
|
|
len = linelen(linex1,liney1,linex2,liney2);
|
|
if (len <= 0) {
|
|
printf("ERROR: length is zero or negative - %d\n",len);
|
|
fflush(stdout);
|
|
exit(1);
|
|
}
|
|
linebg = malloc((len+4) * sizeof(int));
|
|
if (linebg == NULL) {
|
|
printf("ERROR: cannot malloc()\n"); fflush(stdout);
|
|
}
|
|
|
|
copyline(screen, linex1,liney1,linex2,liney2, linebg);
|
|
|
|
sprintf(statustext,"Starting move of link #%d...\n", map[curmap].curlink); fflush(stdout);
|
|
drawstatusbar();
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
int startobjmove (int x, int y) {
|
|
SDL_Rect area;
|
|
|
|
xoff = map[curmap].obj[map[curmap].curobj].x - x;
|
|
yoff = map[curmap].obj[map[curmap].curobj].y - y;
|
|
|
|
startx = x;
|
|
starty = y;
|
|
changestate(S_OBJMOVING);
|
|
/* copy background */
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE,map[curmap].obj[map[curmap].curobj].w,map[curmap].obj[map[curmap].curobj].h,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
area.x = map[curmap].obj[map[curmap].curobj].x;
|
|
area.y = map[curmap].obj[map[curmap].curobj].y;
|
|
area.w = map[curmap].obj[map[curmap].curobj].w;
|
|
area.h = map[curmap].obj[map[curmap].curobj].h;
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
return 0;
|
|
}
|
|
|
|
int startresize (int x, int y) {
|
|
SDL_Rect area;
|
|
|
|
startx = x;
|
|
starty = y;
|
|
changestate(S_RESIZING);
|
|
|
|
/* copy background */
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE,MAXOBJWIDTH+2,MAXOBJHEIGHT+2,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
area.x = map[curmap].obj[map[curmap].curobj].x;
|
|
area.y = map[curmap].obj[map[curmap].curobj].y;
|
|
area.w = map[curmap].obj[map[curmap].curobj].w+2;
|
|
area.h = map[curmap].obj[map[curmap].curobj].h+2;
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
return 0;
|
|
}
|
|
|
|
int startresizetext(int x, int y) {
|
|
SDL_Rect area;
|
|
int txoff,tyoff;
|
|
|
|
if (map[curmap].textob[map[curmap].curtext].anchor == -1) {
|
|
txoff = 0;
|
|
tyoff = 0;
|
|
} else {
|
|
txoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].x;
|
|
tyoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].y;
|
|
}
|
|
|
|
startx = x;
|
|
starty = y;
|
|
changestate(S_TEXTRESIZING);
|
|
|
|
/* copy background */
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE,map[curmap].width,map[curmap].height,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
area.x = map[curmap].textob[map[curmap].curtext].x + txoff;
|
|
area.y = map[curmap].textob[map[curmap].curtext].y + tyoff;
|
|
area.w = map[curmap].textob[map[curmap].curtext].w+2;
|
|
area.h = map[curmap].textob[map[curmap].curtext].h+2;
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
return 0;
|
|
}
|
|
|
|
int starttextmove (int x, int y) {
|
|
SDL_Rect area;
|
|
int txoff,tyoff;
|
|
|
|
if (map[curmap].textob[map[curmap].curtext].anchor == -1) {
|
|
txoff = 0;
|
|
tyoff = 0;
|
|
} else {
|
|
txoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].x;
|
|
tyoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].y;
|
|
}
|
|
|
|
xoff = map[curmap].textob[map[curmap].curtext].x - x + txoff;
|
|
yoff = map[curmap].textob[map[curmap].curtext].y - y + tyoff;
|
|
|
|
startx = x ;
|
|
starty = y ;
|
|
changestate(S_TEXTMOVING);
|
|
/* copy background */
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE,map[curmap].textob[map[curmap].curtext].w,map[curmap].textob[map[curmap].curtext].h,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
area.x = map[curmap].textob[map[curmap].curtext].x + txoff;
|
|
area.y = map[curmap].textob[map[curmap].curtext].y + tyoff;
|
|
area.w = map[curmap].textob[map[curmap].curtext].w;
|
|
area.h = map[curmap].textob[map[curmap].curtext].h;
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int textat(int x, int y) {
|
|
int i,anchor;
|
|
for (i = 0; i < map[curmap].numtext; i++) {
|
|
anchor = map[curmap].textob[i].anchor;
|
|
if (anchor == -1) {
|
|
if ( (x >= map[curmap].textob[i].x ) && (x <= (map[curmap].textob[i].x + map[curmap].textob[i].w)) &&
|
|
(y >= map[curmap].textob[i].y ) && (y <= (map[curmap].textob[i].y + map[curmap].textob[i].h)) ) {
|
|
return i;
|
|
}
|
|
} else {
|
|
if ( (x >= map[curmap].textob[i].x + map[curmap].obj[anchor].x ) && (x <= (map[curmap].textob[i].x + map[curmap].obj[anchor].x + map[curmap].textob[i].w)) &&
|
|
(y >= map[curmap].textob[i].y + map[curmap].obj[anchor].y ) && (y <= (map[curmap].textob[i].y + map[curmap].obj[anchor].y + map[curmap].textob[i].h)) ) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int thingat(int x, int y) {
|
|
int i;
|
|
int anchor;
|
|
for (i = (map[curmap].numthings-1); i >= 0; i--) {
|
|
switch (map[curmap].thing[i].type) {
|
|
case T_OBJECT:
|
|
if ( (x >= map[curmap].obj[map[curmap].thing[i].id].x ) &&
|
|
(x <= (map[curmap].obj[map[curmap].thing[i].id].x + map[curmap].obj[map[curmap].thing[i].id].w)) &&
|
|
(y >= map[curmap].obj[map[curmap].thing[i].id].y ) &&
|
|
(y <= (map[curmap].obj[map[curmap].thing[i].id].y + map[curmap].obj[map[curmap].thing[i].id].h)) ) {
|
|
return i;
|
|
}
|
|
break;
|
|
case T_LINK:
|
|
if (isonlink(map[curmap].thing[i].id, x, y)) {
|
|
return i;
|
|
}
|
|
break;
|
|
case T_TEXT:
|
|
anchor = map[curmap].textob[map[curmap].thing[i].id].anchor;
|
|
if (anchor == -1) {
|
|
if ( (x >= map[curmap].textob[map[curmap].thing[i].id].x ) && (x <= (map[curmap].textob[map[curmap].thing[i].id].x + map[curmap].textob[map[curmap].thing[i].id].w)) &&
|
|
(y >= map[curmap].textob[map[curmap].thing[i].id].y ) && (y <= (map[curmap].textob[map[curmap].thing[i].id].y + map[curmap].textob[map[curmap].thing[i].id].h)) ) {
|
|
return i;
|
|
}
|
|
} else {
|
|
if ( (x >= map[curmap].textob[map[curmap].thing[i].id].x + map[curmap].obj[anchor].x ) && (x <= (map[curmap].textob[map[curmap].thing[i].id].x + map[curmap].obj[anchor].x + map[curmap].textob[map[curmap].thing[i].id].w)) &&
|
|
(y >= map[curmap].textob[map[curmap].thing[i].id].y + map[curmap].obj[anchor].y ) && (y <= (map[curmap].textob[map[curmap].thing[i].id].y + map[curmap].obj[anchor].y + map[curmap].textob[map[curmap].thing[i].id].h)) ) {
|
|
return i;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
int updatefilename(void) {
|
|
int y;
|
|
SDL_Rect sarea;
|
|
SDL_Rect area;
|
|
SDL_Color ccol = blue;
|
|
text_t temp;
|
|
|
|
|
|
/* paste old background */
|
|
if (bg != NULL) {
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bg->w;
|
|
area.h = bg->h;
|
|
SDL_BlitSurface(bg,0,screen, &area);
|
|
SDL_UpdateRect(screen, bgx, bgy, bg->w, bg->h);
|
|
// free it
|
|
SDL_FreeSurface(bg);
|
|
}
|
|
/* copy new background */
|
|
sarea.x = startx;
|
|
sarea.y = starty;
|
|
sarea.w = ((strlen(text)+1) * (DEFTEXTW*2)) +2; // include space for cursor
|
|
sarea.h = DEFTEXTH*2;
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE,sarea.w, sarea.h,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
SDL_BlitSurface(screen,&sarea,bg,0);
|
|
bgx = sarea.x;
|
|
bgy = sarea.y;
|
|
/* draw text */
|
|
strcpy(temp.text, text);
|
|
temp.x = startx;
|
|
temp.y = starty;
|
|
temp.w = strlen(text) * (DEFTEXTW*2);
|
|
temp.h = DEFTEXTH*2;
|
|
temp.c = black;
|
|
temp.anchor = -1;
|
|
|
|
drawtext(screen, &temp);
|
|
|
|
/* draw cursor (a solid block) */
|
|
for (y = starty ; y < (starty + (DEFTEXTH*2)); y++ ) {
|
|
drawline(screen, startx + temp.w, y, startx + temp.w + DEFTEXTW*2,y,ccol);
|
|
}
|
|
|
|
SDL_UpdateRect(screen, startx, starty, temp.w + DEFTEXTW*2, DEFTEXTH*2);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
int updatelinkshadow(int x, int y) {
|
|
int len;
|
|
int w,h;
|
|
int tlx,tly;
|
|
int linex1,liney1,linex2,liney2;
|
|
|
|
/* replace old bg */
|
|
pasteline(screen,linebg);
|
|
|
|
/* copy current bg */
|
|
linex1 = startx;
|
|
liney1 = starty;
|
|
linex2 = x;
|
|
liney2 = y;
|
|
|
|
len = linelen(linex1,liney1,linex2,liney2);
|
|
linebg = malloc((len + 4) * sizeof(int));
|
|
|
|
copyline(screen, linex1,liney1,linex2,liney2, linebg);
|
|
|
|
/* draw line */
|
|
drawline(screen,startx,starty,x,y, map[curmap].boxcol);
|
|
|
|
|
|
if (x < startx) {
|
|
if (y < starty) {
|
|
tlx = x;
|
|
tly = y;
|
|
w = startx - x;
|
|
h = starty - y;
|
|
} else {
|
|
tlx = x;
|
|
tly = starty;
|
|
w = startx - x;
|
|
h = y - starty;
|
|
}
|
|
} else {
|
|
if (y < starty) {
|
|
tlx = startx;
|
|
tly = y;
|
|
w = x - startx;
|
|
h = starty - y;
|
|
} else {
|
|
tlx = startx;
|
|
tly = starty;
|
|
w = x - startx;
|
|
h = y - starty;
|
|
}
|
|
}
|
|
|
|
SDL_UpdateRect(screen, tlx, tly,w,h);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int updatelinkpointshadow(int x, int y) {
|
|
int linex1,liney1,linex2,liney2;
|
|
SDL_Rect area;
|
|
int ty;
|
|
|
|
/* paste old bg */
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bg->w;
|
|
area.h = bg->h;
|
|
SDL_BlitSurface(bg, 0, screen, &area);
|
|
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
|
|
/* copy background */
|
|
linex1 = x - (LINESELHANDLESIZE / 2);
|
|
liney1 = y - (LINESELHANDLESIZE / 2);
|
|
linex2 = x + (LINESELHANDLESIZE / 2)+4;
|
|
liney2 = y + (LINESELHANDLESIZE / 2)+4;
|
|
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE, LINESELHANDLESIZE, LINESELHANDLESIZE,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
|
|
bgx = linex1;
|
|
bgy = liney1;
|
|
bgw = LINESELHANDLESIZE+4;
|
|
bgh = LINESELHANDLESIZE+4;
|
|
|
|
area.x = linex1;
|
|
area.y = liney1;
|
|
area.w = LINESELHANDLESIZE;
|
|
area.h = LINESELHANDLESIZE;
|
|
SDL_BlitSurface(screen, &area, bg,0);
|
|
|
|
/* draw link point */
|
|
for (ty = liney1; ty < (liney1+LINESELHANDLESIZE-1); ty++) {
|
|
drawline(screen, linex1, ty, linex1+LINESELHANDLESIZE-1, ty, black);
|
|
}
|
|
//SDL_UpdateRect(screen, linex1, liney1, linex2, liney2);
|
|
SDL_Flip(screen);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int updatemoveshadow(int x, int y) {
|
|
SDL_Rect area;
|
|
|
|
if ((x + xoff) < 0) xoff = -x;
|
|
if ((y + yoff) < 0) yoff = -y;
|
|
|
|
|
|
x += xoff;
|
|
y += yoff;
|
|
|
|
|
|
/* replace old bg */
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bgw;
|
|
area.h = bgh;
|
|
SDL_BlitSurface(bg, 0, screen, &area);
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
/* copy current bg */
|
|
area.x = x;
|
|
area.y = y;
|
|
area.w = map[curmap].obj[map[curmap].curobj].w;
|
|
area.h = map[curmap].obj[map[curmap].curobj].h;
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
/* draw box */
|
|
if ((x > 0) && (y > 0) && (x+map[curmap].obj[map[curmap].curobj].w-1 < map[curmap].width) && (y+map[curmap].obj[map[curmap].curobj].h-1 < map[curmap].height)) {
|
|
drawline(screen,x,y,x+map[curmap].obj[map[curmap].curobj].w-1,y, map[curmap].boxcol);
|
|
drawline(screen,x,y,x,y+map[curmap].obj[map[curmap].curobj].h-1, map[curmap].boxcol);
|
|
drawline(screen,x,y+map[curmap].obj[map[curmap].curobj].h-1,x+map[curmap].obj[map[curmap].curobj].w-1,y+map[curmap].obj[map[curmap].curobj].h-1, map[curmap].boxcol);
|
|
drawline(screen,x+map[curmap].obj[map[curmap].curobj].w-1,y,x+map[curmap].obj[map[curmap].curobj].w-1,y+map[curmap].obj[map[curmap].curobj].h-1, map[curmap].boxcol);
|
|
}
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
return 0;
|
|
}
|
|
|
|
int updateresizeshadow(int x, int y) {
|
|
SDL_Rect sarea;
|
|
SDL_Rect area;
|
|
int xdiff,ydiff;
|
|
|
|
xdiff = x - startx;
|
|
ydiff = y - starty;
|
|
|
|
/* check for maximum object sizes */
|
|
if ((map[curmap].obj[map[curmap].curobj].w + xdiff) > MAXOBJWIDTH) xdiff = MAXOBJWIDTH - map[curmap].obj[map[curmap].curobj].w;
|
|
if ((map[curmap].obj[map[curmap].curobj].h + ydiff) > MAXOBJHEIGHT) ydiff = MAXOBJHEIGHT - map[curmap].obj[map[curmap].curobj].h;
|
|
if ((map[curmap].obj[map[curmap].curobj].w + xdiff) < MINOBJWIDTH) xdiff = MINOBJWIDTH - map[curmap].obj[map[curmap].curobj].w ;
|
|
if ((map[curmap].obj[map[curmap].curobj].h + ydiff) < MINOBJHEIGHT) ydiff = MINOBJHEIGHT - map[curmap].obj[map[curmap].curobj].h ;
|
|
|
|
/* check for edges of screen */
|
|
if ((map[curmap].obj[map[curmap].curobj].x + map[curmap].obj[map[curmap].curobj].w + xdiff) >= map[curmap].width) {
|
|
xdiff = 0;
|
|
}
|
|
if ((map[curmap].obj[map[curmap].curobj].y + map[curmap].obj[map[curmap].curobj].h + ydiff) >= map[curmap].height) {
|
|
ydiff = 0;
|
|
//ydiff = (map[curmap].height - map[curmap].obj[map[curmap].curobj].h);
|
|
}
|
|
|
|
/* replace old bg */
|
|
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bgw;
|
|
area.h = bgh;
|
|
|
|
sarea.x = 0;
|
|
sarea.y = 0;
|
|
sarea.w = bgw;
|
|
sarea.h = bgh;
|
|
|
|
SDL_BlitSurface(bg, &sarea, screen, &area);
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
/* copy current bg */
|
|
area.x = map[curmap].obj[map[curmap].curobj].x;
|
|
area.y = map[curmap].obj[map[curmap].curobj].y;
|
|
area.w = map[curmap].obj[map[curmap].curobj].w + xdiff + 2;
|
|
area.h = map[curmap].obj[map[curmap].curobj].h + ydiff + 2;
|
|
if (area.w < MINOBJWIDTH) area.w = MINOBJWIDTH;
|
|
if (area.h < MINOBJHEIGHT) area.h = MINOBJHEIGHT;
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
/* draw box */
|
|
drawline(screen,map[curmap].obj[map[curmap].curobj].x, map[curmap].obj[map[curmap].curobj].y,
|
|
map[curmap].obj[map[curmap].curobj].x+map[curmap].obj[map[curmap].curobj].w+xdiff, map[curmap].obj[map[curmap].curobj].y , map[curmap].boxcol);
|
|
drawline(screen,map[curmap].obj[map[curmap].curobj].x, map[curmap].obj[map[curmap].curobj].y,
|
|
map[curmap].obj[map[curmap].curobj].x, map[curmap].obj[map[curmap].curobj].y+map[curmap].obj[map[curmap].curobj].h+ydiff , map[curmap].boxcol);
|
|
drawline(screen,map[curmap].obj[map[curmap].curobj].x+map[curmap].obj[map[curmap].curobj].w+xdiff, map[curmap].obj[map[curmap].curobj].y,
|
|
map[curmap].obj[map[curmap].curobj].x+map[curmap].obj[map[curmap].curobj].w+xdiff, map[curmap].obj[map[curmap].curobj].y+map[curmap].obj[map[curmap].curobj].h+ydiff , map[curmap].boxcol);
|
|
drawline(screen,map[curmap].obj[map[curmap].curobj].x, map[curmap].obj[map[curmap].curobj].y+map[curmap].obj[map[curmap].curobj].h+ydiff,
|
|
map[curmap].obj[map[curmap].curobj].x+map[curmap].obj[map[curmap].curobj].w+xdiff, map[curmap].obj[map[curmap].curobj].y+map[curmap].obj[map[curmap].curobj].h+ydiff , map[curmap].boxcol);
|
|
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
return 0;
|
|
}
|
|
|
|
int updateresizetextshadow(int x, int y) {
|
|
SDL_Rect sarea;
|
|
SDL_Rect area;
|
|
int xdiff,ydiff;
|
|
int txoff,tyoff;
|
|
|
|
if (map[curmap].textob[map[curmap].curtext].anchor == -1) {
|
|
txoff = 0;
|
|
tyoff = 0;
|
|
} else {
|
|
txoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].x;
|
|
tyoff = map[curmap].obj[map[curmap].textob[map[curmap].curtext].anchor].y;
|
|
}
|
|
|
|
xdiff = x - startx;
|
|
ydiff = y - starty;
|
|
|
|
if ((map[curmap].textob[map[curmap].curtext].w + xdiff) > strlen(map[curmap].textob[map[curmap].curtext].text) * MAXLETTERWIDTH) xdiff = (strlen(map[curmap].textob[map[curmap].curtext].text) * MAXLETTERWIDTH)-map[curmap].textob[map[curmap].curtext].w;
|
|
if ((map[curmap].textob[map[curmap].curtext].h + ydiff) > MAXLETTERHEIGHT) ydiff = MAXLETTERHEIGHT - map[curmap].textob[map[curmap].curtext].h;
|
|
if ((map[curmap].textob[map[curmap].curtext].w + xdiff) < strlen(map[curmap].textob[map[curmap].curtext].text) * MINLETTERWIDTH)
|
|
xdiff = (strlen(map[curmap].textob[map[curmap].curtext].text) * MINLETTERWIDTH) - map[curmap].textob[map[curmap].curtext].w ;
|
|
if ((map[curmap].textob[map[curmap].curtext].h + ydiff) < MINLETTERHEIGHT) ydiff = MINLETTERHEIGHT - map[curmap].textob[map[curmap].curtext].h ;
|
|
|
|
/* replace old bg */
|
|
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bgw;
|
|
area.h = bgh;
|
|
|
|
sarea.x = 0;
|
|
sarea.y = 0;
|
|
sarea.w = bgw;
|
|
sarea.h = bgh;
|
|
|
|
SDL_BlitSurface(bg, &sarea, screen, &area);
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
/* copy current bg */
|
|
area.x = map[curmap].textob[map[curmap].curtext].x + txoff;
|
|
area.y = map[curmap].textob[map[curmap].curtext].y + tyoff;
|
|
area.w = map[curmap].textob[map[curmap].curtext].w + xdiff + 2;
|
|
area.h = map[curmap].textob[map[curmap].curtext].h + ydiff + 2;
|
|
|
|
|
|
if (area.w < strlen(map[curmap].textob[map[curmap].curtext].text) * MINLETTERWIDTH) area.w = strlen(map[curmap].textob[map[curmap].curtext].text) * MINLETTERWIDTH;
|
|
if (area.h < MINLETTERHEIGHT) area.h = MINLETTERHEIGHT;
|
|
|
|
if (area.w > strlen(map[curmap].textob[map[curmap].curtext].text) * MAXLETTERWIDTH ) area.w = strlen(map[curmap].textob[map[curmap].curtext].text) * MAXLETTERWIDTH;
|
|
if (area.h > MAXLETTERHEIGHT) area.h = MAXLETTERHEIGHT;
|
|
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
/* draw box */
|
|
drawline(screen,map[curmap].textob[map[curmap].curtext].x+txoff, map[curmap].textob[map[curmap].curtext].y+tyoff,
|
|
map[curmap].textob[map[curmap].curtext].x+txoff+map[curmap].textob[map[curmap].curtext].w+xdiff, map[curmap].textob[map[curmap].curtext].y+tyoff , map[curmap].boxcol);
|
|
drawline(screen,map[curmap].textob[map[curmap].curtext].x+txoff, map[curmap].textob[map[curmap].curtext].y+tyoff,
|
|
map[curmap].textob[map[curmap].curtext].x+txoff, map[curmap].textob[map[curmap].curtext].y+tyoff+map[curmap].textob[map[curmap].curtext].h+ydiff , map[curmap].boxcol);
|
|
drawline(screen,map[curmap].textob[map[curmap].curtext].x+txoff+map[curmap].textob[map[curmap].curtext].w+xdiff, map[curmap].textob[map[curmap].curtext].y+tyoff,
|
|
map[curmap].textob[map[curmap].curtext].x+txoff+map[curmap].textob[map[curmap].curtext].w+xdiff, map[curmap].textob[map[curmap].curtext].y+tyoff+map[curmap].textob[map[curmap].curtext].h+ydiff , map[curmap].boxcol);
|
|
drawline(screen,map[curmap].textob[map[curmap].curtext].x+txoff, map[curmap].textob[map[curmap].curtext].y+tyoff+map[curmap].textob[map[curmap].curtext].h+ydiff,
|
|
map[curmap].textob[map[curmap].curtext].x+txoff+map[curmap].textob[map[curmap].curtext].w+xdiff, map[curmap].textob[map[curmap].curtext].y+tyoff+map[curmap].textob[map[curmap].curtext].h+ydiff , map[curmap].boxcol);
|
|
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
return 0;
|
|
}
|
|
|
|
int updatetextcursor(void) {
|
|
int y;
|
|
SDL_Rect sarea;
|
|
SDL_Rect area;
|
|
SDL_Color ccol = blue;
|
|
text_t temp;
|
|
|
|
if ((state == S_SAVING) || (state == S_LOADING) || (state == S_MAPNAMING)) {
|
|
showfiledialog();
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* paste old background */
|
|
if (bg != NULL) {
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bg->w;
|
|
area.h = bg->h;
|
|
SDL_BlitSurface(bg,0,screen, &area);
|
|
SDL_UpdateRect(screen, bgx, bgy, bg->w, bg->h);
|
|
// free it
|
|
SDL_FreeSurface(bg);
|
|
}
|
|
/* copy new background */
|
|
sarea.x = startx;
|
|
sarea.y = starty;
|
|
sarea.w = ((strlen(text)+1) * (DEFTEXTW)) +2; // include space for cursor
|
|
sarea.h = DEFTEXTH;
|
|
bg = SDL_CreateRGBSurface(SDL_SWSURFACE,sarea.w, sarea.h,
|
|
screen->format->BitsPerPixel, screen->format->Rmask,
|
|
screen->format->Gmask,screen->format->Bmask,
|
|
screen->format->Amask);
|
|
SDL_BlitSurface(screen,&sarea,bg,0);
|
|
bgx = sarea.x;
|
|
bgy = sarea.y;
|
|
/* draw text */
|
|
strcpy(temp.text, text);
|
|
temp.x = startx;
|
|
temp.y = starty;
|
|
temp.w = strlen(text) * (DEFTEXTW);
|
|
temp.h = DEFTEXTH;
|
|
temp.c = fgcol;
|
|
temp.anchor = -1;
|
|
|
|
drawtext(screen, &temp);
|
|
|
|
/* draw cursor (a solid block) */
|
|
for (y = starty ; y < (starty + DEFTEXTH); y++ ) {
|
|
drawline(screen, startx + temp.w, y, startx + temp.w + DEFTEXTW,y,ccol);
|
|
}
|
|
|
|
SDL_UpdateRect(screen, startx, starty, temp.w + DEFTEXTW, DEFTEXTH);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
int endlink(int x, int y) {
|
|
int endxoff,endyoff;
|
|
int i;
|
|
|
|
/* replace old bg */
|
|
pasteline(screen,linebg);
|
|
|
|
/* check if we've exceeded the max number of links */
|
|
if ((map[curmap].numlinks+1) >= MAXLINKS) {
|
|
sprintf(statustext,"ERROR: Maximum link count (%d) exceeded.", MAXLINKS);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
endxoff = x - map[curmap].obj[endobj].x;
|
|
endyoff = y - map[curmap].obj[endobj].y;
|
|
*/
|
|
/* centre offsets*/
|
|
xoff = (map[curmap].obj[startobj].w / 2);
|
|
yoff = (map[curmap].obj[startobj].h / 2);
|
|
endxoff = (map[curmap].obj[endobj].w / 2);
|
|
endyoff = (map[curmap].obj[endobj].h / 2);
|
|
|
|
map[curmap].olink[map[curmap].numlinks].srcobj = startobj;
|
|
map[curmap].olink[map[curmap].numlinks].srcxoff = xoff;
|
|
map[curmap].olink[map[curmap].numlinks].srcyoff = yoff;
|
|
|
|
map[curmap].olink[map[curmap].numlinks].dstobj = endobj;
|
|
map[curmap].olink[map[curmap].numlinks].dstxoff = endxoff;
|
|
map[curmap].olink[map[curmap].numlinks].dstyoff = endyoff;
|
|
|
|
map[curmap].olink[map[curmap].numlinks].col = fgcol;
|
|
|
|
map[curmap].olink[map[curmap].numlinks].style = LS_NORMAL;
|
|
|
|
map[curmap].olink[map[curmap].numlinks].npoints = 0;
|
|
|
|
/* add to 'thing' list */
|
|
/* links start at the bottom of the thing list */
|
|
/* shuffle all things up */
|
|
for (i = (map[curmap].numthings-1); i >= 0 ; i--) {
|
|
map[curmap].thing[i+1].type = map[curmap].thing[i].type;
|
|
map[curmap].thing[i+1].id = map[curmap].thing[i].id;
|
|
}
|
|
map[curmap].thing[0].type = T_LINK;
|
|
map[curmap].thing[0].id = map[curmap].numlinks;
|
|
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Link #%d created (from obj #%d to obj #%d).\n", map[curmap].numlinks, startobj, endobj);
|
|
map[curmap].numlinks++;
|
|
map[curmap].numthings++;
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int endlinkdstmove(int x, int y) {
|
|
int o;
|
|
|
|
/* free variable */
|
|
if (linebg) free(linebg);
|
|
|
|
|
|
/* find which map[curmap].object it's over */
|
|
o = objat(x, y);
|
|
|
|
if (o == -1) {
|
|
/* if it's not over an map[curmap].object, abort the move */
|
|
changestate(S_NONE);
|
|
map[curmap].curlink = -1;
|
|
|
|
sprintf(statustext,"Move of link #%d dst endpoint aborted.\n",map[curmap].curlink);
|
|
} else if (o == map[curmap].olink[map[curmap].curlink].dstobj) {
|
|
/* if over the same map[curmap].object, update offsets */
|
|
map[curmap].olink[map[curmap].curlink].dstxoff = x - map[curmap].obj[o].x;
|
|
map[curmap].olink[map[curmap].curlink].dstyoff = y - map[curmap].obj[o].y;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Link #%d dst endpoint moved to offset (+%d,+%d).\n",map[curmap].curlink, map[curmap].olink[map[curmap].curlink].dstxoff,map[curmap].olink[map[curmap].curlink].dstyoff);
|
|
} else {
|
|
/* else if over a new map[curmap].object, update map[curmap].objid and offsets */
|
|
map[curmap].olink[map[curmap].curlink].dstobj = o;
|
|
map[curmap].olink[map[curmap].curlink].dstxoff = x - map[curmap].obj[o].x;
|
|
map[curmap].olink[map[curmap].curlink].dstyoff = y - map[curmap].obj[o].y;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Link #%d dst endpoint moved to object %d(+%d,+%d).\n",map[curmap].curlink,o, map[curmap].olink[map[curmap].curlink].dstxoff,map[curmap].olink[map[curmap].curlink].dstyoff);
|
|
}
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int endlinkpointmove(int x, int y) {
|
|
/* free variable */
|
|
if (bg) free(bg);
|
|
|
|
|
|
map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].x = x;
|
|
map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].y = y;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Link #%d point #%d moved to (%d,%d).\n",map[curmap].curlink, map[curmap].curlinkpoint, map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].x,map[curmap].olink[map[curmap].curlink].point[map[curmap].curlinkpoint].y);
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int endlinksrcmove(int x, int y) {
|
|
int o;
|
|
|
|
/* free variable */
|
|
if (linebg) free(linebg);
|
|
|
|
/* find which map[curmap].object it's over */
|
|
o = objat(x, y);
|
|
|
|
if (o == -1) {
|
|
/* if it's not over an map[curmap].object, abort the move */
|
|
changestate(S_NONE);
|
|
map[curmap].curlink = -1;
|
|
|
|
sprintf(statustext,"Move of link #%d src endpoint aborted.\n",map[curmap].curlink);
|
|
} else if (o == map[curmap].olink[map[curmap].curlink].srcobj) {
|
|
/* if over the same map[curmap].object, update offsets */
|
|
map[curmap].olink[map[curmap].curlink].srcxoff = x - map[curmap].obj[o].x;
|
|
map[curmap].olink[map[curmap].curlink].srcyoff = y - map[curmap].obj[o].y;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Link #%d src endpoint moved to offset (+%d,+%d).\n",map[curmap].curlink, map[curmap].olink[map[curmap].curlink].srcxoff,map[curmap].olink[map[curmap].curlink].srcyoff);
|
|
} else {
|
|
/* else if over a new map[curmap].object, update map[curmap].objid and offsets */
|
|
map[curmap].olink[map[curmap].curlink].srcobj = o;
|
|
map[curmap].olink[map[curmap].curlink].srcxoff = x - map[curmap].obj[o].x;
|
|
map[curmap].olink[map[curmap].curlink].srcyoff = y - map[curmap].obj[o].y;
|
|
|
|
modified = TRUE;
|
|
sprintf(statustext,"Link #%d src endpoint moved to object %d(+%d,+%d).\n",map[curmap].curlink,o, map[curmap].olink[map[curmap].curlink].srcxoff,map[curmap].olink[map[curmap].curlink].srcyoff);
|
|
}
|
|
drawstatusbar();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int endlinkmove(int x, int y) {
|
|
/* free variable */
|
|
//printf("about to free linebg (0x%x)\n",linebg); fflush(stdout);
|
|
if (linebg) free(linebg);
|
|
|
|
|
|
modified = TRUE;
|
|
/* TODO: move the line */
|
|
|
|
return 0;
|
|
}
|
|
|
|
void drillto(int mapnum) {
|
|
if (mapnum == -1) {
|
|
if (nummaps < (MAXMAPS-1)) {
|
|
/* push current map */
|
|
history[numhistory] = curmap;
|
|
numhistory++;
|
|
|
|
/* change child */
|
|
map[curmap].obj[map[curmap].selecteditem].child = nummaps;
|
|
|
|
/* create a new map */
|
|
initmap(nummaps);
|
|
|
|
/* select the new map */
|
|
curmap = nummaps;
|
|
|
|
nummaps++;
|
|
sprintf(statustext,"Drilled down (new map created).");
|
|
|
|
startx = 1;
|
|
starty = (map[curmap].height/2)-2;
|
|
bg = NULL;
|
|
strcpy(text, map[curmap].name);
|
|
changestate(S_MAPNAMING);
|
|
|
|
drawmap();
|
|
} else {
|
|
sprintf(statustext, "ERROR: Maximum number of maps reached.");
|
|
drawstatusbar();
|
|
}
|
|
} else {
|
|
/* push current map */
|
|
history[numhistory] = curmap;
|
|
numhistory++;
|
|
|
|
curmap = mapnum;
|
|
|
|
sprintf(statustext,"Drilled down into map #%d (%s).",curmap,map[curmap].name);
|
|
drawmap();
|
|
}
|
|
}
|
|
|
|
int endobjmove(int x, int y) {
|
|
SDL_FreeSurface(bg);
|
|
|
|
/* check position */
|
|
if ((map[curmap].obj[map[curmap].curobj].x + x - startx) >= (map[curmap].width - map[curmap].obj[map[curmap].curobj].w)) {
|
|
return -1;
|
|
}
|
|
if ((map[curmap].obj[map[curmap].curobj].y + y - starty) >= (map[curmap].height - map[curmap].obj[map[curmap].curobj].h)) {
|
|
return -1;
|
|
}
|
|
if (map[curmap].obj[map[curmap].curobj].y + y - starty <= 0) {
|
|
return -1;
|
|
}
|
|
if (map[curmap].obj[map[curmap].curobj].x + x - startx <= 0) {
|
|
return -1;
|
|
}
|
|
|
|
modified = TRUE;
|
|
map[curmap].obj[map[curmap].curobj].x += (x - startx);
|
|
map[curmap].obj[map[curmap].curobj].y += (y - starty);
|
|
return 0;
|
|
}
|
|
|
|
int endresize(int x, int y) {
|
|
int origw,origh;
|
|
int neww,newh;
|
|
int i;
|
|
float xscale,yscale;
|
|
|
|
|
|
SDL_FreeSurface(bg);
|
|
|
|
origw = map[curmap].obj[map[curmap].curobj].w;
|
|
origh = map[curmap].obj[map[curmap].curobj].h;
|
|
neww = map[curmap].obj[map[curmap].curobj].w;
|
|
newh = map[curmap].obj[map[curmap].curobj].h;
|
|
|
|
|
|
if (map[curmap].obj[map[curmap].curobj].w + (x - startx) > 0) {
|
|
neww = map[curmap].obj[map[curmap].curobj].w + (x - startx);
|
|
}
|
|
if (map[curmap].obj[map[curmap].curobj].h + (y - starty) > 0) {
|
|
newh = map[curmap].obj[map[curmap].curobj].h + (y - starty);
|
|
}
|
|
|
|
if (neww < MINOBJWIDTH) neww = MINOBJWIDTH;
|
|
if (newh < MINOBJHEIGHT) newh = MINOBJHEIGHT;
|
|
if (neww > MAXOBJWIDTH) neww = MAXOBJWIDTH;
|
|
if (newh > MAXOBJHEIGHT) newh = MAXOBJHEIGHT;
|
|
|
|
if (map[curmap].obj[map[curmap].curobj].x + neww >= map[curmap].width) {
|
|
neww = map[curmap].width - map[curmap].obj[map[curmap].curobj].x-1;
|
|
}
|
|
if (map[curmap].obj[map[curmap].curobj].y + newh >= map[curmap].height) {
|
|
newh = map[curmap].height - map[curmap].obj[map[curmap].curobj].y-1;
|
|
}
|
|
|
|
map[curmap].obj[map[curmap].curobj].w = neww;
|
|
map[curmap].obj[map[curmap].curobj].h = newh;
|
|
|
|
/* update default map[curmap].object size */
|
|
objtype[map[curmap].obj[map[curmap].curobj].type].defw = neww;
|
|
objtype[map[curmap].obj[map[curmap].curobj].type].defh = newh;
|
|
|
|
/* scale all link endpoints in this map[curmap].object */
|
|
xscale = (float)neww / (float)origw;
|
|
yscale = (float)newh / (float)origh;
|
|
for (i = 0; i < map[curmap].numlinks; i++) {
|
|
if (map[curmap].olink[i].srcobj == map[curmap].curobj) {
|
|
map[curmap].olink[i].srcxoff = map[curmap].olink[i].srcxoff * xscale;
|
|
map[curmap].olink[i].srcyoff = map[curmap].olink[i].srcyoff * yscale;
|
|
}
|
|
if (map[curmap].olink[i].dstobj == map[curmap].curobj) {
|
|
map[curmap].olink[i].dstxoff = map[curmap].olink[i].dstxoff * xscale;
|
|
map[curmap].olink[i].dstyoff = map[curmap].olink[i].dstyoff * yscale;
|
|
}
|
|
}
|
|
/* scale x,y of any text anchored to this map[curmap].object */
|
|
for (i = 0; i < map[curmap].numtext; i++) {
|
|
if (map[curmap].textob[i].anchor == map[curmap].curobj) {
|
|
map[curmap].textob[i].x = map[curmap].textob[i].x * xscale;
|
|
map[curmap].textob[i].y = map[curmap].textob[i].y * yscale;
|
|
}
|
|
}
|
|
|
|
modified = TRUE;
|
|
drawmap();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int endtextresize(int x, int y) {
|
|
int origw,origh;
|
|
int neww,newh;
|
|
|
|
|
|
SDL_FreeSurface(bg);
|
|
|
|
origw = map[curmap].textob[map[curmap].curtext].w;
|
|
origh = map[curmap].textob[map[curmap].curtext].h;
|
|
neww = map[curmap].textob[map[curmap].curtext].w;
|
|
newh = map[curmap].textob[map[curmap].curtext].h;
|
|
|
|
|
|
if (map[curmap].textob[map[curmap].curtext].w + (x - startx) > 0) {
|
|
neww = map[curmap].textob[map[curmap].curtext].w + (x - startx);
|
|
}
|
|
if (map[curmap].textob[map[curmap].curtext].h + (y - starty) > 0) {
|
|
newh = map[curmap].textob[map[curmap].curtext].h + (y - starty);
|
|
}
|
|
|
|
if (neww < strlen(map[curmap].textob[map[curmap].curtext].text) * MINLETTERWIDTH) neww = strlen(map[curmap].textob[map[curmap].curtext].text) * MINLETTERWIDTH;
|
|
if (newh < MINLETTERHEIGHT) newh = MINLETTERHEIGHT;
|
|
|
|
if (neww > strlen(map[curmap].textob[map[curmap].curtext].text) * MAXLETTERWIDTH ) neww = strlen(map[curmap].textob[map[curmap].curtext].text) * MAXLETTERWIDTH;
|
|
if ((map[curmap].textob[map[curmap].curtext].x + neww) >= map[curmap].width ) neww = map[curmap].width - map[curmap].textob[map[curmap].curtext].x - 1;
|
|
if (newh > MAXLETTERHEIGHT) newh = MAXLETTERHEIGHT;
|
|
if ((map[curmap].textob[map[curmap].curtext].y + newh) >= map[curmap].height ) newh = map[curmap].height - map[curmap].textob[map[curmap].curtext].y - 1;
|
|
|
|
map[curmap].textob[map[curmap].curtext].w = neww;
|
|
map[curmap].textob[map[curmap].curtext].h = newh;
|
|
|
|
/* update default text size */
|
|
/* TODO: is this useful? */
|
|
/*
|
|
objtype[map[curmap].obj[map[curmap].curobj].type].defw = neww;
|
|
objtype[map[curmap].obj[map[curmap].curobj].type].defh = newh;
|
|
*/
|
|
|
|
modified = TRUE;
|
|
drawmap();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int updatetextshadow(int x, int y) {
|
|
SDL_Rect area;
|
|
|
|
|
|
x += xoff;
|
|
y += yoff;
|
|
|
|
if (x < 0) x = 0;
|
|
if (y < 0) y = 0;
|
|
|
|
/* replace old bg */
|
|
area.x = bgx;
|
|
area.y = bgy;
|
|
area.w = bgw;
|
|
area.h = bgh;
|
|
SDL_BlitSurface(bg, 0, screen, &area);
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
/* copy current bg */
|
|
area.x = x;
|
|
area.y = y;
|
|
area.w = map[curmap].textob[map[curmap].curtext].w;
|
|
area.h = map[curmap].textob[map[curmap].curtext].h;
|
|
SDL_BlitSurface(screen,&area,bg,0);
|
|
bgx = area.x;
|
|
bgy = area.y;
|
|
bgw = area.w;
|
|
bgh = area.h;
|
|
/* draw box */
|
|
if ((x > 0) && (y > 0) && (x+map[curmap].textob[map[curmap].curtext].w-1 < map[curmap].width) && (y+map[curmap].textob[map[curmap].curtext].h-1 < map[curmap].height)) {
|
|
drawline(screen,x,y,x+map[curmap].textob[map[curmap].curtext].w-1,y, map[curmap].boxcol);
|
|
drawline(screen,x,y,x,y+map[curmap].textob[map[curmap].curtext].h-1, map[curmap].boxcol);
|
|
drawline(screen,x,y+map[curmap].textob[map[curmap].curtext].h-1,x+map[curmap].textob[map[curmap].curtext].w-1,y+map[curmap].textob[map[curmap].curtext].h-1, map[curmap].boxcol);
|
|
drawline(screen,x+map[curmap].textob[map[curmap].curtext].w-1,y,x+map[curmap].textob[map[curmap].curtext].w-1,y+map[curmap].textob[map[curmap].curtext].h-1, map[curmap].boxcol);
|
|
}
|
|
SDL_UpdateRect(screen, area.x, area.y, area.w, area.h);
|
|
return 0;
|
|
}
|