forked from github/server
1468 lines
30 KiB
C
1468 lines
30 KiB
C
/* vi: set ts=2:
|
||
*
|
||
*
|
||
* Eressea PB(E)M host Copyright (C) 1998-2000
|
||
* Christian Schlittchen (corwin@amber.kn-bremen.de)
|
||
* Katja Zedel (katze@felidae.kn-bremen.de)
|
||
* Henning Peters (faroul@beyond.kn-bremen.de)
|
||
* Enno Rehling (enno@eressea-pbem.de)
|
||
* Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
|
||
*
|
||
* This program may not be used, modified or distributed without
|
||
* prior permission by the authors of Eressea.
|
||
*/
|
||
|
||
#define BOOL_DEFINED
|
||
/* wenn config.h nicht vor curses included wird, kompiliert es unter windows nicht */
|
||
#include <config.h>
|
||
#include <curses.h>
|
||
#include <eressea.h>
|
||
#include "mapper.h"
|
||
|
||
/* kernel includes */
|
||
#include <building.h>
|
||
#include <faction.h>
|
||
#include <goodies.h>
|
||
#include <item.h>
|
||
#include <movement.h>
|
||
#include <race.h>
|
||
#include <region.h>
|
||
#include <reports.h>
|
||
#include <ship.h>
|
||
#include <skill.h>
|
||
#include <unit.h>
|
||
#include <base36.h>
|
||
|
||
/* libc includes */
|
||
#include <ctype.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
#define findunit(f,r) findunitg(f,r)
|
||
|
||
static region *shipregion;
|
||
|
||
unit *
|
||
make_new_unit(region * r)
|
||
{
|
||
unit *u;
|
||
faction *f;
|
||
WINDOW *win;
|
||
char *fac_nr36;
|
||
int i, p, anz, q, y;
|
||
win = openwin(SX - 10, 8, "< Neue Einheit erschaffen >");
|
||
|
||
if (r->units)
|
||
p = r->units->faction->no;
|
||
else
|
||
p = 0;
|
||
|
||
do {
|
||
fac_nr36 = my_input(win, 2, 1, "Parteinummer: ", itoa36(p));
|
||
if(fac_nr36 == NULL || *fac_nr36 == 0) {
|
||
delwin(win);
|
||
return 0;
|
||
}
|
||
f = findfaction(atoi36(fac_nr36));
|
||
} while (!f);
|
||
wmove(win, 1, 2);
|
||
wclrtoeol(win);
|
||
wmove(win, 1, win->_maxx);
|
||
waddch(win, '|');
|
||
wmove(win, 1, 2);
|
||
wAddstr(factionname(f));
|
||
wrefresh(win);
|
||
|
||
anz = map_input(win, 2, 2, "Anzahl Personen", 0, 9999, 1);
|
||
if (anz > 0) {
|
||
q = 0;
|
||
y = 4;
|
||
wmove(win, y, 4);
|
||
for (i = 0; i < MAXRACES; i++) {
|
||
sprintf(buf, "%d=%s; ", i, race[i].name[0]);
|
||
q += strlen(buf);
|
||
if (q > SX - 20) {
|
||
q = strlen(buf);
|
||
y++;
|
||
wmove(win, y, 4);
|
||
}
|
||
wAddstr(buf);
|
||
}
|
||
q = map_input(win, 2, 3, "Rasse", 0, MAXRACES-1, f->race);
|
||
|
||
u = createunit(r, f, anz, (race_t) q);
|
||
if (p==0)
|
||
u->age = (short)map_input(win, 2, 4, "Alter", 1, 99, 1);
|
||
else
|
||
u->age = 0;
|
||
for (; y > 3; y--) {
|
||
wmove(win, y, 4);
|
||
wclrtoeol(win);
|
||
wrefresh(win);
|
||
wmove(win, y, win->_maxx);
|
||
waddch(win, '|');
|
||
wrefresh(win);
|
||
}
|
||
|
||
buf[0] = 0;
|
||
strcpy(buf, my_input(win, 2, 4, "Name: ", NULL));
|
||
if (buf[0])
|
||
set_string(&u->name, buf);
|
||
if (!strlen(u->name))
|
||
set_string(&u->name, buf);
|
||
set_money(u, map_input(win, 2, 5, "Silber", 0, 999999, anz * 10));
|
||
} else
|
||
u = NULL;
|
||
|
||
delwin(win);
|
||
return u;
|
||
}
|
||
|
||
void
|
||
copy_unit(unit * from, unit * to)
|
||
{
|
||
memcpy(to, from, sizeof(unit));
|
||
}
|
||
|
||
|
||
static int
|
||
input_string(const char * text, char * result, size_t len) {
|
||
WINDOW * wn;
|
||
int res;
|
||
wn = newwin(1, SX, SY-1, 0);
|
||
werase(wn);
|
||
wmove(wn, 0, 0);
|
||
wattron(wn, A_BOLD);
|
||
waddstr(wn, text);
|
||
waddstr(wn, ": ");
|
||
echo();
|
||
curs_set(1);
|
||
res = wgetnstr(wn, result, len);
|
||
curs_set(0);
|
||
noecho();
|
||
delwin(wn);
|
||
return res;
|
||
}
|
||
|
||
#ifdef NEW_ITEMS
|
||
static boolean i_modif = false;
|
||
|
||
static void
|
||
chg_item(selection * s, void * data) {
|
||
unit * u = (unit *)data;
|
||
int i;
|
||
|
||
i = input_string("Anzahl", buf, 80);
|
||
if (i==ERR) return;
|
||
i = atoi(buf);
|
||
if (i) {
|
||
const item_type * itype = (const item_type *)s->data;
|
||
item * itm = i_change(&u->items, itype, i);
|
||
int k = itm?itm->number:0;
|
||
sprintf(buf, "%s: %d", locale_string(NULL, resourcename(itype->rtype, GR_PLURAL)), k);
|
||
i_modif = true;
|
||
free(s->str);
|
||
s->str = strdup(buf);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
boolean
|
||
modify_items(unit * u)
|
||
{
|
||
selection *ilist = NULL, **ilast = &ilist;
|
||
const item_type * itype = itemtypes;
|
||
|
||
while (itype!=NULL) {
|
||
selection * prev = NULL;
|
||
item * itm = *i_find(&u->items, itype);
|
||
int q = itm?itm->number:0;
|
||
sprintf(buf, "%s: %d", locale_string(NULL, resourcename(itype->rtype, GR_PLURAL)), q);
|
||
for (ilast = &ilist; *ilast; ilast=&(*ilast)->next) {
|
||
if (strcmp((*ilast)->str, buf)>0) break;
|
||
prev = *ilast;
|
||
}
|
||
insert_selection(ilast, prev, strdup(buf), (void*)itype);
|
||
itype=itype->next;
|
||
while (ilist->prev!=NULL) ilist=ilist->prev;
|
||
}
|
||
i_modif = false;
|
||
do_selection(ilist, "Gegenst<EFBFBD>nde", chg_item, (void*)u);
|
||
while (ilist) {
|
||
selection * s = ilist;
|
||
ilist=ilist->next;
|
||
free((void*)s->str);
|
||
free(s);
|
||
}
|
||
return i_modif;
|
||
}
|
||
|
||
|
||
#if 0
|
||
char
|
||
modify_zauber(unit * u)
|
||
{
|
||
int q, L;
|
||
char i, x, modif = 0;
|
||
WINDOW *wn;
|
||
char *ZL[MAXSPELLS];
|
||
|
||
if (SY > MAXSPELLS + 2)
|
||
L = MAXSPELLS;
|
||
else
|
||
L = 10;
|
||
|
||
wn = newwin(L + 2, 50, (SY - L - 2) / 2, (SX - 50) / 2);
|
||
|
||
wclear(wn);
|
||
wborder(wn, '|', '|', '-', '-', '.', '.', '`', '\'');
|
||
wmove(wn, 0, 3);
|
||
waddnstr(wn, "< Zauber >", -1);
|
||
for (i = 0; i < MAXSPELLS; i++) {
|
||
if (get_spell(u, i))
|
||
sprintf(buf, "%s", spellnames[i]);
|
||
else
|
||
sprintf(buf, " (%s)", spellnames[i]);
|
||
ZL[i] = strdup(buf);
|
||
modif = 1;
|
||
if (L > 10) {
|
||
wmove(wn, i + 1, 4);
|
||
waddnstr(wn, ZL[i], -1);
|
||
}
|
||
}
|
||
|
||
x = 0;
|
||
do {
|
||
if (L == 10) {
|
||
for (i = 0; i < L && i + x < MAXSPELLS; i++) {
|
||
wmove(wn, i + 1, 2);
|
||
wclrtoeol(wn);
|
||
if (i == 0)
|
||
wattron(wn, A_BOLD);
|
||
waddnstr(wn, ZL[i + x], -1);
|
||
if (i == 0)
|
||
wattroff(wn, A_BOLD);
|
||
}
|
||
if (i < L)
|
||
for (; i < L; i++) {
|
||
wmove(wn, i + 1, 2);
|
||
wclrtoeol(wn);
|
||
}
|
||
wborder(wn, '|', '|', '-', '-', '.', '.', '`', '\'');
|
||
wmove(wn, 0, 3);
|
||
waddnstr(wn, "< Zauber >", -1);
|
||
} else {
|
||
wmove(wn, x + 1, 1);
|
||
waddnstr(wn, "-> ", -1);
|
||
wattron(wn, A_BOLD);
|
||
waddnstr(wn, ZL[x], -1);
|
||
wattroff(wn, A_BOLD);
|
||
wmove(wn, x + 1, 1);
|
||
}
|
||
wrefresh(wn);
|
||
|
||
q = getch();
|
||
|
||
if (L > 10) {
|
||
waddnstr(wn, " ", -1);
|
||
waddnstr(wn, ZL[x], -1);
|
||
}
|
||
switch (q) {
|
||
case KEY_DOWN:
|
||
if (x < MAXSPELLS - 1)
|
||
x++;
|
||
else
|
||
beep();
|
||
break;
|
||
case KEY_UP:
|
||
if (x > 0)
|
||
x--;
|
||
else
|
||
beep();
|
||
break;
|
||
case 10:
|
||
case 13:
|
||
if (get_spell(u, x)) {
|
||
sprintf(buf, " (%s)", spellnames[x]);
|
||
set_spell(u, x, false);
|
||
} else {
|
||
sprintf(buf, "%s", spellnames[x]);
|
||
set_spell(u, x, true);
|
||
}
|
||
free(ZL[x]);
|
||
ZL[x] = strdup(buf);
|
||
modif = 1;
|
||
break;
|
||
}
|
||
} while (q != 27 && q != 'q');
|
||
delwin(wn);
|
||
return modif;
|
||
}
|
||
#endif
|
||
|
||
char
|
||
modify_talente(unit * u, region * r)
|
||
{
|
||
int q, L;
|
||
item_t i;
|
||
unsigned char x;
|
||
char modif=0;
|
||
WINDOW *wn;
|
||
char *TL[MAXSKILLS];
|
||
if (SY > MAXSKILLS + 2)
|
||
L = MAXSKILLS;
|
||
else
|
||
L = 10;
|
||
|
||
wn = newwin(L + 2, 40, (SY - L - 2) / 2, (SX - 40) / 2);
|
||
|
||
wclear(wn);
|
||
wborder(wn, '|', '|', '-', '-', '.', '.', '`', '\'');
|
||
wmove(wn, 0, 3);
|
||
waddnstr(wn, "< Talente >", -1);
|
||
for (i = 0; i < MAXSKILLS; i++) {
|
||
q = get_skill(u, i);
|
||
sprintf(buf, "%s %d [%d]", skillname(i, NULL), eff_skill(u, i, r), q / u->number);
|
||
TL[i] = strdup(buf);
|
||
if (L > 10) {
|
||
wmove(wn, i + 1, 4);
|
||
waddnstr(wn, TL[i], -1);
|
||
}
|
||
}
|
||
|
||
x = 0;
|
||
do {
|
||
if (L == 10) {
|
||
for (i = 0; i < L && i + x < MAXSKILLS; i++) {
|
||
wmove(wn, i + 1, 2);
|
||
wclrtoeol(wn);
|
||
if (i == 0)
|
||
wattron(wn, A_BOLD);
|
||
waddnstr(wn, TL[i + x], -1);
|
||
if (i == 0)
|
||
wattroff(wn, A_BOLD);
|
||
}
|
||
if (i < L)
|
||
for (; i < L; i++) {
|
||
wmove(wn, i + 1, 2);
|
||
wclrtoeol(wn);
|
||
}
|
||
wborder(wn, '|', '|', '-', '-', '.', '.', '`', '\'');
|
||
wmove(wn, 0, 3);
|
||
waddnstr(wn, "< Talente >", -1);
|
||
} else {
|
||
wmove(wn, x + 1, 1);
|
||
waddnstr(wn, "-> ", -1);
|
||
wattron(wn, A_BOLD);
|
||
waddnstr(wn, TL[x], -1);
|
||
wattroff(wn, A_BOLD);
|
||
wmove(wn, x + 1, 1);
|
||
}
|
||
wrefresh(wn);
|
||
|
||
q = getch();
|
||
|
||
if (L > 10) {
|
||
waddnstr(wn, " ", -1);
|
||
waddnstr(wn, TL[x], -1);
|
||
}
|
||
switch (q) {
|
||
case KEY_DOWN:
|
||
if (x < MAXSKILLS - 1)
|
||
x++;
|
||
else
|
||
beep();
|
||
break;
|
||
case KEY_UP:
|
||
if (x > 0)
|
||
x--;
|
||
else
|
||
beep();
|
||
break;
|
||
case 10:
|
||
case 13:
|
||
if (L == 10) {
|
||
wmove(wn, x + 2, 2);
|
||
wclrtoeol(wn);
|
||
wmove(wn, x + 2, 39);
|
||
waddch(wn, '|');
|
||
wrefresh(wn);
|
||
q = map_input(wn, 2, 2, "Tage pro Person", 0, 5000, get_skill(u, x) / u->number);
|
||
} else {
|
||
q = map_input(0, 0, 0, "Tage pro Person", 0, 5000, get_skill(u, x) / u->number);
|
||
touchwin(mywin);
|
||
touchwin(wn);
|
||
wrefresh(mywin); /* altes Fenster <20>berb<72>geln */
|
||
}
|
||
set_skill(u, x, q * u->number);
|
||
sprintf(buf, "%s %d [%d]", skillname(x, NULL), eff_skill(u, x, r), q);
|
||
free(TL[x]);
|
||
modif = 1;
|
||
TL[x] = strdup(buf);
|
||
q = 0; /* sicherheitshalber, weil 27 oder 'q' -> Ende */
|
||
break;
|
||
}
|
||
} while (q != 27 && q != 'q');
|
||
delwin(wn);
|
||
return modif;
|
||
}
|
||
|
||
boolean
|
||
modify_unit(region * r, unit * modunit)
|
||
{
|
||
WINDOW *win;
|
||
unit *u;
|
||
int q, a, x, y, zt, zg;
|
||
char modif = 0;
|
||
int at;
|
||
#ifdef NEW_ITEMS
|
||
const item * itm;
|
||
#endif
|
||
|
||
wclear(mywin);
|
||
sprintf(buf, "< Einheit modifizieren: %s,%s >",
|
||
Unitid(modunit), factionname(modunit->faction));
|
||
movexy((SX - strlen(buf)) / 2, 1);
|
||
addstr(buf);
|
||
|
||
u = calloc(1, sizeof(unit));
|
||
copy_unit(modunit, u);
|
||
|
||
do {
|
||
skill_t sk;
|
||
item_t i;
|
||
y = 0;
|
||
wclear(mywin);
|
||
Movexy(3, y);
|
||
wprintw(mywin, (NCURSES_CONST char*)"Rasse: %s", race[u->race].name[0]);
|
||
Movexy(3, ++y);
|
||
wprintw(mywin, (NCURSES_CONST char*)"Anzahl: %d", u->number);
|
||
Movexy(3, ++y);
|
||
wprintw(mywin, (NCURSES_CONST char*)"Silber: %d", get_money(u));
|
||
Movexy(3, ++y);
|
||
at = fval(modunit, FL_PARTEITARNUNG);
|
||
wprintw(mywin, (NCURSES_CONST char*)"Parteitarnung: %s", at ? "an" : "aus");
|
||
Movexy(3, ++y);
|
||
Addstr("D<EFBFBD>monentarnung: ");
|
||
#if 0 /* ja, wie denn? */
|
||
if (u->race == RC_DAEMON && u->itypus > 0 && u->typus != u->itypus)
|
||
Addstr(typusdaten[u->itypus].name[0]);
|
||
else {
|
||
#endif
|
||
Addstr("keine");
|
||
if (u->race != RC_DAEMON)
|
||
Addstr(" m<>glich");
|
||
#if 0
|
||
}
|
||
#endif
|
||
|
||
Movexy(3, ++y);
|
||
zt = y;
|
||
q = 11;
|
||
x = 0;
|
||
Addstr("Talente: ");
|
||
for (sk = 0; sk != MAXSKILLS; sk++) {
|
||
if ((a = get_skill(u, sk))!=0) {
|
||
if (x) {
|
||
Addstr(", ");
|
||
q += 2;
|
||
}
|
||
sprintf(buf, "%s %d [%d]", skillname(sk, NULL), eff_skill(u, sk, r), a / u->number);
|
||
q += strlen(buf);
|
||
if (q > SX - 8) {
|
||
q = strlen(buf);
|
||
y++;
|
||
Movexy(5, y);
|
||
}
|
||
Addstr(buf);
|
||
x = 1;
|
||
}
|
||
}
|
||
if (!x)
|
||
Addstr("keine");
|
||
y++;
|
||
|
||
Movexy(3, y);
|
||
q = 15;
|
||
x = false;
|
||
zg = y;
|
||
Addstr("Gegenst<EFBFBD>nde: ");
|
||
for (itm=u->items;itm;itm=itm->next) {
|
||
if (x) {
|
||
Addstr(", ");
|
||
q += 2;
|
||
}
|
||
sprintf(buf, "%d %s", itm->number, locale_string(NULL, resourcename(itm->type->rtype, GR_PLURAL)));
|
||
q += strlen(buf);
|
||
if (q > SX - 8) {
|
||
q = strlen(buf);
|
||
y++;
|
||
Movexy(5, y);
|
||
}
|
||
Addstr(buf);
|
||
x = true;
|
||
}
|
||
if (!x)
|
||
Addstr("keine");
|
||
y++;
|
||
y++;
|
||
Movexy(3, y);
|
||
Addstr("Anfangsbuchstabe, <Esc> f<>r Ende");
|
||
wrefresh(mywin);
|
||
|
||
q = getch();
|
||
switch (tolower(q)) {
|
||
case 't':
|
||
modif = modify_talente(u, r);
|
||
break;
|
||
case 'g':
|
||
modif = (char)modify_items(u);
|
||
break;
|
||
case 'r':
|
||
win = openwin(SX - 10, 5, "< Rasse w<>hlen >");
|
||
y = 2;
|
||
q = 0;
|
||
wmove(win, y, 4);
|
||
for (i = 1; i < MAXRACES; i++) {
|
||
sprintf(buf, "%d=%s; ", i, race[i].name[0]);
|
||
q += strlen(buf);
|
||
if (q > SX - 20) {
|
||
q = strlen(buf);
|
||
y++;
|
||
wmove(win, y, 4);
|
||
}
|
||
wAddstr(buf);
|
||
}
|
||
u->race = (race_t)map_input(win, 2, 1, "Rasse", 0, MAXRACES-1, modunit->faction->race);
|
||
modif = 1;
|
||
delwin(win);
|
||
break;
|
||
case 'd':
|
||
if (u->race == RC_DAEMON) {
|
||
race_t rc;
|
||
win = openwin(SX - 10, 5, "< Tarnrasse w<>hlen >");
|
||
y = 2;
|
||
q = 0;
|
||
wmove(win, y, 4);
|
||
for (rc = 1; rc != MAXRACES; rc++) {
|
||
sprintf(buf, "%d=%s; ", rc, race[rc].name[0]);
|
||
q += strlen(buf);
|
||
if (q > SX - 20) {
|
||
q = strlen(buf);
|
||
y++;
|
||
wmove(win, y, 4);
|
||
}
|
||
wAddstr(buf);
|
||
}
|
||
u->irace = (race_t)map_input(win, 2, 1, "Tarnrasse", 0, MAXRACES, modunit->irace);
|
||
modif = 1;
|
||
delwin(win);
|
||
} else
|
||
beep();
|
||
break;
|
||
case 'a':
|
||
a = u->number;
|
||
scale_number(u, map_input(0, 0, 0, "Anzahl Personen", 1, 9999, u->number));
|
||
if (a != u->number)
|
||
modif = 1;
|
||
break;
|
||
case 's':
|
||
set_money(u, map_input(0, 0, 0, "Silber", 0, 999999, get_money(u)));
|
||
modif = 1;
|
||
break;
|
||
case 'p':
|
||
q = (int) yes_no(0, "Parteitarnung?",
|
||
(char) ((fval(modunit, FL_PARTEITARNUNG))
|
||
? 'j' : 'n'));
|
||
if (at && !q) {
|
||
freset(modunit, FL_PARTEITARNUNG);
|
||
modif = 1;
|
||
} else if (!at && q) {
|
||
fset(modunit, FL_PARTEITARNUNG);
|
||
modif = 1;
|
||
}
|
||
break;
|
||
}
|
||
} while (q != 27 && q != 'q');
|
||
|
||
if (modif) {
|
||
if (yes_no(0, "<EFBFBD>nderungen <20>bernehmen?", 'j')) {
|
||
copy_unit(u, modunit);
|
||
modified = 1;
|
||
}
|
||
}
|
||
free(u);
|
||
movexy(0, 1);
|
||
hline('-', SX + 1);
|
||
refresh();
|
||
return i2b(modif == 1);
|
||
}
|
||
|
||
dbllist *pointer;
|
||
boolean isunit;
|
||
|
||
void
|
||
SetPointer(int dir)
|
||
{
|
||
dbllist *h = pointer;
|
||
int pl = pline;
|
||
switch (dir) {
|
||
case KEY_UP:
|
||
case KEY_LEFT:
|
||
case KEY_PPAGE:
|
||
case '/':
|
||
case 'n':
|
||
case '<':
|
||
while (h) {
|
||
if (h->s[0] < ' ') {
|
||
if (h->s[0] == '\025') /* eine Einheit */
|
||
isunit = true;
|
||
else
|
||
isunit = false;
|
||
pointer = h;
|
||
pline = pl;
|
||
return;
|
||
}
|
||
h = h->prev;
|
||
pl--;
|
||
}
|
||
break;
|
||
case KEY_DOWN:
|
||
case KEY_RIGHT:
|
||
case KEY_NPAGE:
|
||
case '>':
|
||
while (h) {
|
||
if (h->s[0] < ' ') {
|
||
if (h->s[0] == '\025') /* eine Einheit */
|
||
isunit = true;
|
||
else
|
||
isunit = false;
|
||
pointer = h;
|
||
pline = pl;
|
||
return;
|
||
}
|
||
h = h->next;
|
||
pl++;
|
||
}
|
||
}
|
||
|
||
/* Unten bzw. oben angekommen und nix gefunden? Dann andersrum */
|
||
h = pointer;
|
||
pl = pline;
|
||
switch (dir) {
|
||
case KEY_DOWN:
|
||
case KEY_RIGHT:
|
||
case KEY_NPAGE:
|
||
case '>':
|
||
while (h) {
|
||
if (h->s[0] < ' ') {
|
||
if (h->s[0] == '\025') /* eine Einheit */
|
||
isunit = true;
|
||
else
|
||
isunit = false;
|
||
pointer = h;
|
||
pline = pl;
|
||
return;
|
||
}
|
||
h = h->prev;
|
||
pl--;
|
||
}
|
||
break;
|
||
case KEY_UP:
|
||
case KEY_PPAGE:
|
||
case KEY_LEFT:
|
||
case '/':
|
||
case 'n':
|
||
case '<':
|
||
while (h) {
|
||
if (h->s[0] < ' ') {
|
||
if (h->s[0] == '\025') /* eine Einheit */
|
||
isunit = true;
|
||
else
|
||
isunit = false;
|
||
pointer = h;
|
||
pline = pl;
|
||
return;
|
||
}
|
||
h = h->next;
|
||
pl++;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
void
|
||
Umark(int p)
|
||
{
|
||
Movexy(0, p);
|
||
if (isunit)
|
||
Addstr("=>");
|
||
else
|
||
Addstr("->");
|
||
movexy(0, 1);
|
||
hline('-', SX + 1);
|
||
if (clipship) {
|
||
sprintf(buf, "< Clipschiff: %s >", shipname(clipship));
|
||
movexy(SX - strlen(buf) - 2, 1);
|
||
addstr(buf);
|
||
}
|
||
movexy(0, SY - 1);
|
||
hline('-', SX + 1);
|
||
if (clipunit) {
|
||
sprintf(buf, "< Clipunit:%s >", Unitid(clipunit));
|
||
movexy(SX - strlen(buf) - 2, SY - 1);
|
||
addstr(buf);
|
||
}
|
||
Movexy(0, p);
|
||
wrefresh(mywin);
|
||
}
|
||
|
||
void
|
||
sAddstr(char *s)
|
||
{
|
||
if (s[0] < ' ')
|
||
s++;
|
||
Addstr(s);
|
||
}
|
||
|
||
unit *clipunit; /* hierin kann eine Einheit gespeichert werden */
|
||
region *clipregion; /* hierher kommt die clipunit */
|
||
|
||
void
|
||
dblparagraph(dbllist ** SP, char *s, int indent, char mark)
|
||
{
|
||
int i, j, width, delta = 0;
|
||
int firstline;
|
||
static char lbuf[128];
|
||
width = SX - 5 - indent;
|
||
firstline = 1;
|
||
|
||
for (;;) {
|
||
i = 0;
|
||
|
||
do {
|
||
j = i;
|
||
while (s[j] && s[j] != ' ')
|
||
j++;
|
||
if (j > width) {
|
||
if (i == 0)
|
||
i = width - 1;
|
||
break;
|
||
}
|
||
i = j + 1;
|
||
}
|
||
while (s[j]);
|
||
|
||
j = 0;
|
||
if (firstline) {
|
||
if (*s == '\025') { /* \023 ist ^U => Unit-Kennung */
|
||
lbuf[0] = '\025'; /* Kennung nach vorne
|
||
* holen */
|
||
delta = 1;
|
||
}
|
||
} else
|
||
delta = 0;
|
||
|
||
for (j = 0; j != indent; j++)
|
||
lbuf[j + delta] = ' ';
|
||
|
||
if (firstline && mark)
|
||
lbuf[indent - 2 + delta] = mark;
|
||
|
||
for (j = 0; j != i - 1; j++)
|
||
lbuf[indent + j + delta] = s[j + delta];
|
||
lbuf[indent + j + delta] = 0;
|
||
|
||
adddbllist(SP, lbuf);
|
||
|
||
if (!s[i - 1 + delta])
|
||
break;
|
||
|
||
s += i;
|
||
firstline = 0;
|
||
}
|
||
}
|
||
|
||
void
|
||
mapper_spunit(dbllist ** SP, unit * u, int indent)
|
||
{
|
||
int i, dh;
|
||
skill_t sk;
|
||
item * itm;
|
||
|
||
strcpy(buf, "\025");
|
||
sncat(buf, unitname(u), BUFSIZE);
|
||
sncat(buf, ", ", BUFSIZE);
|
||
sncat(buf, factionname(u->faction), BUFSIZE);
|
||
|
||
if (fval(u, FL_PARTEITARNUNG))
|
||
sncat(buf, " (getarnt)", BUFSIZE);
|
||
|
||
sncat(buf, ", ", BUFSIZE);
|
||
icat(u->number);
|
||
sncat(buf, " ", BUFSIZE);
|
||
|
||
i = u->race;
|
||
if (u->irace != u->race) {
|
||
sncat(buf, race[u->irace].name[u->number != 1], BUFSIZE);
|
||
sncat(buf, " (", BUFSIZE);
|
||
if (u->race == RC_ILLUSION)
|
||
sncat(buf, race[u->faction->race].name[u->number != 1], BUFSIZE);
|
||
else
|
||
sncat(buf, race[u->race].name[u->number != 1], BUFSIZE);
|
||
sncat(buf, ")", BUFSIZE);
|
||
} else {
|
||
if (u->race == RC_ILLUSION)
|
||
sncat(buf, race[u->faction->race].name[u->number != 1], BUFSIZE);
|
||
else
|
||
sncat(buf, race[u->race].name[u->number != 1], BUFSIZE);
|
||
}
|
||
|
||
switch (u->status) {
|
||
case ST_FIGHT:
|
||
sncat(buf, ", vorne", BUFSIZE);
|
||
break;
|
||
case ST_BEHIND:
|
||
sncat(buf, ", hinten", BUFSIZE);
|
||
break;
|
||
case ST_AVOID:
|
||
sncat(buf, ", k<>mpft nicht", BUFSIZE);
|
||
break;
|
||
case ST_FLEE:
|
||
sncat(buf, ", flieht", BUFSIZE);
|
||
break;
|
||
default:
|
||
sncat(buf, ", unbekannt", BUFSIZE);
|
||
break;
|
||
}
|
||
|
||
sncat(buf, " (", BUFSIZE); icat(u->hp/u->number); sncat(buf, " HP)", BUFSIZE);
|
||
|
||
if (fval(u, FL_GUARD))
|
||
sncat(buf, ", bewacht die Region", BUFSIZE);
|
||
|
||
if (usiege(u)) {
|
||
sncat(buf, ", belagert ", BUFSIZE);
|
||
sncat(buf, buildingname(usiege(u)), BUFSIZE);
|
||
}
|
||
sncat(buf, ", ", BUFSIZE);
|
||
icat(get_money(u));
|
||
sncat(buf, " Silber", BUFSIZE);
|
||
|
||
dh = 0;
|
||
for (sk = 0; sk != MAXSKILLS; sk++)
|
||
spskill(find_locale("de"), u, sk, &dh, 1);
|
||
dh = 0;
|
||
|
||
for (itm = u->items;itm;itm=itm->next) {
|
||
sncat(buf, ", ", BUFSIZE);
|
||
|
||
if (!dh) {
|
||
sncat(buf, "hat: ", BUFSIZE);
|
||
dh = 1;
|
||
}
|
||
if (itm->number == 1)
|
||
sncat(buf, locale_string(NULL, resourcename(itm->type->rtype, 0)), BUFSIZE);
|
||
else {
|
||
icat(itm->number);
|
||
sncat(buf, " ", BUFSIZE);
|
||
sncat(buf, locale_string(NULL, resourcename(itm->type->rtype, GR_PLURAL)), BUFSIZE);
|
||
}
|
||
}
|
||
dh = 0;
|
||
|
||
#if 0
|
||
for (spell = 0; spell != MAXSPELLS; spell++)
|
||
if (get_spell(u, spell)) {
|
||
sncat(buf, ", ", BUFSIZE);
|
||
|
||
if (!dh) {
|
||
sncat(buf, "Zauber: ", BUFSIZE);
|
||
dh = 1;
|
||
}
|
||
sncat(buf, spellnames[spell], BUFSIZE);
|
||
}
|
||
#endif
|
||
if (u->lastorder[0]) {
|
||
scat(", \"");
|
||
sncat(buf, u->lastorder, BUFSIZE);
|
||
scat("\"");
|
||
}
|
||
#if 0
|
||
if (u->combatspell != NOSPELL) {
|
||
sncat(buf, ", Kampfzauber: ", BUFSIZE);
|
||
sncat(buf, spellnames[u->combatspell], BUFSIZE);
|
||
}
|
||
#endif
|
||
if (uprivate(u)) {
|
||
sncat(buf, " (Bem: ", BUFSIZE);
|
||
sncat(buf, uprivate(u), BUFSIZE);
|
||
sncat(buf, ")", BUFSIZE);
|
||
}
|
||
sncat(buf, ".", BUFSIZE);
|
||
|
||
dblparagraph(SP, buf, indent, '-');
|
||
adddbllist(SP, " ");
|
||
}
|
||
|
||
|
||
int
|
||
showunits(region * r)
|
||
{
|
||
unit *u, *x;
|
||
building *b;
|
||
ship *sh;
|
||
dbllist *eh = NULL, *unten, *oben, *hlp = NULL, *such = NULL, *tmp;
|
||
int line, ch, bottom, bot, f, f2;
|
||
size_t lt;
|
||
char *s = NULL, *txt, *suchtext = 0, str[45], lbuf[256];
|
||
|
||
clear();
|
||
strncpy(str, rname(r, NULL), 44);
|
||
str[44] = 0;
|
||
movexy(0, 0);
|
||
printw((NCURSES_CONST char*)"Einheiten in %s (%d,%d):", str, r->x, r->y);
|
||
movexy(0, SY);
|
||
addstr("/,n: Suche; N: NewUnit; G: GetUnit; P: PutUnit; M: Modify; S: Schiff; B: Burg");
|
||
refresh();
|
||
|
||
for (b = r->buildings; b; b = b->next) {
|
||
if (b->type == &bt_castle) {
|
||
sprintf(lbuf, "\002%s, Gr<47><72>e %d, %s", buildingname(b), b->size, buildingtype(b, b->size, NULL));
|
||
} else {
|
||
sprintf(lbuf, "\002%s, Gr<47><72>e %d, %s", buildingname(b),
|
||
b->size, buildingtype(b, b->size, NULL));
|
||
if (b->type->maxsize > 0 &&
|
||
b->size < b->type->maxsize) {
|
||
sncat(lbuf, " (im Bau)", BUFSIZE);
|
||
}
|
||
}
|
||
adddbllist(&eh, lbuf);
|
||
adddbllist(&eh, " ");
|
||
for (u = r->units; u; u = u->next) {
|
||
if (u->building == b && fval(u, FL_OWNER)) {
|
||
mapper_spunit(&eh, u, 4);
|
||
break;
|
||
}
|
||
}
|
||
for (u = r->units; u; u = u->next) {
|
||
if (u->building == b && !fval(u, FL_OWNER)) {
|
||
mapper_spunit(&eh, u, 4);
|
||
}
|
||
}
|
||
}
|
||
for (sh = r->ships; sh; sh = sh->next) {
|
||
f=0;
|
||
for (u = r->units; u; u = u->next)
|
||
if (u->ship == sh) f += weight(u);
|
||
sprintf(lbuf, "\023%s, %s, (%d/%d)", shipname(sh), sh->type->name[0],
|
||
(f+99)/100, shipcapacity(sh)/100);
|
||
if (sh->size!=sh->type->construction->maxsize) {
|
||
f = 100 * (sh->size) / sh->type->construction->maxsize;
|
||
sncat(lbuf, ", im Bau (", BUFSIZE);
|
||
icat(f);
|
||
sncat(lbuf, "%) ", BUFSIZE);
|
||
}
|
||
if (sh->damage) {
|
||
sncat(lbuf, ", ", BUFSIZE);
|
||
icat(sh->damage);
|
||
sncat(lbuf, "% besch<63>digt", BUFSIZE);
|
||
}
|
||
adddbllist(&eh, lbuf);
|
||
adddbllist(&eh, " ");
|
||
for (u = r->units; u; u = u->next) {
|
||
if (u->ship == sh && fval(u, FL_OWNER)) {
|
||
mapper_spunit(&eh, u, 4);
|
||
break;
|
||
}
|
||
}
|
||
for (u = r->units; u; u = u->next) {
|
||
if (u->ship == sh && !fval(u, FL_OWNER))
|
||
mapper_spunit(&eh, u, 4);
|
||
}
|
||
}
|
||
|
||
if (!r->units) {
|
||
adddbllist(&eh, "keine Einheiten");
|
||
adddbllist(&eh, " ");
|
||
} else {
|
||
for (u = r->units; u; u = u->next) {
|
||
if (!u->ship && !u->building)
|
||
mapper_spunit(&eh, u, 2);
|
||
}
|
||
}
|
||
|
||
mywin = newwin(SY - 3, SX, 2, 0);
|
||
wclear(mywin);
|
||
bot = mywin->_maxy + 1;
|
||
if (!pointer)
|
||
pointer = eh;
|
||
else {
|
||
pointer = eh;
|
||
for (f = 0; f < pline && pointer->next; f++)
|
||
pointer = pointer->next;
|
||
}
|
||
oben = pointer;
|
||
f = 4;
|
||
while (oben->prev && --f!=0)
|
||
oben = oben->prev; /* Wenn dies ein "Fullredraw" ist, pointer dorthin,
|
||
wo wir vorher ungef<65>hr waren. */
|
||
for (line=0, unten=oben; line<bot && unten->next; line++, unten=unten->next) {
|
||
Movexy(3, line);
|
||
sAddstr(unten->s);
|
||
}
|
||
bottom = line - 1;
|
||
tmp = oben;
|
||
pline = 0;
|
||
|
||
while (tmp != pointer) {
|
||
pline++;
|
||
tmp = tmp->next;
|
||
}
|
||
|
||
scrollok(mywin, TRUE);
|
||
ch = KEY_DOWN;
|
||
wrefresh(mywin);
|
||
|
||
for (;;) {
|
||
SetPointer(ch);
|
||
if (pline < 0 || pline >= bot || !pointer)
|
||
beep();
|
||
else
|
||
Umark(pline);
|
||
ch = getch();
|
||
if (pointer)
|
||
Addstr(" ");
|
||
switch (ch) {
|
||
case KEY_DOWN:
|
||
if (pointer->next) {
|
||
pointer = pointer->next;
|
||
pline++;
|
||
} else
|
||
beep();
|
||
if (pline > bot - 5 && unten->next) {
|
||
line = bot - 5;
|
||
while (line && unten->next) {
|
||
unten = unten->next;
|
||
oben = oben->next;
|
||
pline--;
|
||
line--;
|
||
}
|
||
f = -1;
|
||
}
|
||
break;
|
||
case KEY_UP:
|
||
if (pointer->prev) {
|
||
pointer = pointer->prev;
|
||
pline--;
|
||
} else
|
||
beep();
|
||
if (pline < 5 && oben != eh) {
|
||
line = bot - 5;
|
||
while (line && oben->prev) {
|
||
unten = unten->prev;
|
||
oben = oben->prev;
|
||
pline++;
|
||
line--;
|
||
}
|
||
f = -1;
|
||
}
|
||
break;
|
||
case KEY_NPAGE:
|
||
case KEY_RIGHT:
|
||
for (line = 0; line < 20 && unten->next; line++) {
|
||
oben = oben->next;
|
||
unten = unten->next;
|
||
if (pointer->next)
|
||
pointer = pointer->next;
|
||
}
|
||
f = -1;
|
||
break;
|
||
case KEY_PPAGE:
|
||
case KEY_LEFT:
|
||
for (line = 0; line < 20 && oben->prev; line++) {
|
||
oben = oben->prev;
|
||
unten = unten->prev;
|
||
if (pointer->prev)
|
||
pointer = pointer->prev;
|
||
}
|
||
f = -1;
|
||
break;
|
||
case '/':
|
||
suchtext = my_input(0, 0, 0, "Suchtext: ", NULL);
|
||
such = eh;
|
||
case 'n':
|
||
if (suchtext) {
|
||
line = 0;
|
||
lt = strlen(suchtext);
|
||
while (such->next && !line) {
|
||
s = such->s;
|
||
while (strlen(s) >= lt && !line) {
|
||
if (strncasecmp(s, suchtext, lt) == 0)
|
||
line = 1;
|
||
s++;
|
||
}
|
||
if (!line)
|
||
such = such->next;
|
||
}
|
||
if (line) {
|
||
wclear(mywin);
|
||
oben = such->prev ? such->prev : such;
|
||
pline = 0;
|
||
/* unten = hlp->prev; */
|
||
while (oben->prev && oben->s[0] != '\025') { /* eine Einheit */
|
||
oben = oben->prev;
|
||
unten = unten->prev;
|
||
}
|
||
pointer = oben;
|
||
Movexy(3, 0);
|
||
for (line = 1, hlp = oben; line < bot && hlp->next; line++, hlp = hlp->next) {
|
||
Movexy(3, line);
|
||
if (hlp == such) {
|
||
txt = such->s;
|
||
s--;
|
||
ch = *s;
|
||
*s = 0;
|
||
sAddstr(txt);
|
||
wattron(mywin, A_REVERSE);
|
||
*s = (char)ch;
|
||
txt = s;
|
||
ch = txt[lt];
|
||
txt[lt] = 0;
|
||
Addstr(txt);
|
||
wattroff(mywin, A_REVERSE);
|
||
txt[lt] = (char)ch;
|
||
txt += lt;
|
||
Addstr(txt);
|
||
} else
|
||
sAddstr(hlp->s);
|
||
}
|
||
bottom = line - 1;
|
||
} else {
|
||
movexy(0, SY);
|
||
beep();
|
||
clrtoeol();
|
||
printw((NCURSES_CONST char*)"'%s' nicht gefunden.", suchtext);
|
||
refresh();
|
||
}
|
||
} else
|
||
beep();
|
||
break;
|
||
case KEY_HELP:
|
||
case '?':
|
||
case 'h':
|
||
movexy(0, SY);
|
||
clrtoeol();
|
||
addstr("/,n:Suche; N:New; G:Get; P:Put; M:Modify; B:Burg; S:Schiff;");
|
||
refresh();
|
||
break;
|
||
case '>':
|
||
while (unten->next) {
|
||
unten = unten->next;
|
||
oben = oben->next;
|
||
}
|
||
while (pointer->next)
|
||
pointer = pointer->next;
|
||
pline = bot;
|
||
f = -1;
|
||
break;
|
||
case '<':
|
||
pointer = such = oben = eh;
|
||
pline = 0;
|
||
f = -1;
|
||
break;
|
||
case 'N':
|
||
if ((u = make_new_unit(r))!=NULL) {
|
||
modified = 1;
|
||
if ((s = strchr(pointer->s, '('))!=NULL) {
|
||
s++;
|
||
f = atoi(s);
|
||
switch (pointer->s[0]) {
|
||
case '\002':
|
||
b = findbuilding(f);
|
||
sprintf(lbuf, "Einheit in %s als Eigner?", BuildingName(b));
|
||
if (yes_no(0, lbuf, 'j')) {
|
||
for (x = r->units; x; x = x->next)
|
||
if (x->building == b && fval(x, FL_OWNER)) {
|
||
freset(x, FL_OWNER);
|
||
break;
|
||
}
|
||
u->building = b;
|
||
fset(u, FL_OWNER);
|
||
}
|
||
break;
|
||
case '\023':
|
||
sh = findship(f);
|
||
sprintf(lbuf, "Einheit auf%s als Eigner?", shipname(sh));
|
||
if (yes_no(0, lbuf, 'j')) {
|
||
for (x = r->units; x; x = x->next)
|
||
if (x->ship == sh && fval(x, FL_OWNER)) {
|
||
freset(x, FL_OWNER);
|
||
break;
|
||
}
|
||
u->ship = sh;
|
||
fset(u, FL_OWNER);
|
||
}
|
||
break;
|
||
case '\025':
|
||
x = findunit(f, r);
|
||
if(x) {
|
||
if (x->building) {
|
||
sprintf(lbuf, "Einheit in %s rein?", buildingname(x->building));
|
||
if (yes_no(0, lbuf, 'j'))
|
||
u->building = x->building;
|
||
} else if (x->ship) {
|
||
sprintf(lbuf, "Einheit auf%s rauf?", shipname(x->ship));
|
||
if (yes_no(0, lbuf, 'j'))
|
||
u->ship = x->ship;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
delwin(mywin);
|
||
freelist(eh);
|
||
return 1;
|
||
}
|
||
case 12: /* ^L */
|
||
f = -1;
|
||
break;
|
||
case 'S':
|
||
if (!clipship)
|
||
beep();
|
||
else {
|
||
sprintf(lbuf, "Schiff%s l<>schen?", shipname(clipship));
|
||
if (yes_no(0, lbuf, 'n')) {
|
||
modified = 1;
|
||
for (x = shipregion->units; x; x = x->next)
|
||
leave(shipregion, x);
|
||
destroy_ship(clipship, shipregion);
|
||
clipship = 0;
|
||
shipregion = 0;
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
delwin(mywin);
|
||
freelist(eh);
|
||
return 1;
|
||
} else
|
||
wrefresh(mywin);
|
||
}
|
||
break;
|
||
case 's':
|
||
if (clipship && shipregion != r) {
|
||
unit *un;
|
||
sprintf(lbuf, "Schiff %s einf<6E>gen?", shipname(clipship));
|
||
if (yes_no(0, lbuf, 'j')) {
|
||
boolean owner_set = false;
|
||
|
||
for (x = shipregion->units; x;) {
|
||
un = x->next;
|
||
if (x->ship == clipship) {
|
||
f = (int) fval(x, FL_OWNER);
|
||
leave(shipregion, x);
|
||
translist(&shipregion->units, &r->units, x);
|
||
x->ship = clipship;
|
||
if (owner_set == false && f) {
|
||
owner_set = true;
|
||
fset(x, FL_OWNER);
|
||
} else {
|
||
freset(x, FL_OWNER);
|
||
}
|
||
}
|
||
x = un;
|
||
}
|
||
move_ship(clipship, shipregion, r, NULL);
|
||
clipship = NULL;
|
||
shipregion = NULL;
|
||
}
|
||
} else
|
||
NeuesSchiff(r);
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
freelist(eh);
|
||
delwin(mywin);
|
||
return 1;
|
||
case 'b':
|
||
NeueBurg(r);
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
freelist(eh);
|
||
delwin(mywin);
|
||
return 1;
|
||
case 'B':
|
||
if (pointer) {
|
||
if ((s = strchr(pointer->s, '('))!=NULL) {
|
||
s++;
|
||
f = atoi(s);
|
||
if (f) {
|
||
b = findbuilding(f);
|
||
if (b) {
|
||
sprintf(lbuf, "Geb<EFBFBD>ude %s l<>schen?", BuildingName(b));
|
||
if (yes_no(0, lbuf, 'n')) {
|
||
modified = 1;
|
||
for (x = r->units; x; x = x->next)
|
||
if (x->building == b)
|
||
leave(r, x);
|
||
destroy_building(b);
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
delwin(mywin);
|
||
freelist(eh);
|
||
return 1;
|
||
} else
|
||
wrefresh(mywin);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case 'U':
|
||
f = map_input(0, 0, 0, "Einheit Nummer", 0, 99999, 0);
|
||
if (f)
|
||
clipunit = findunit(f, r);
|
||
break;
|
||
case 'M':
|
||
if (!isunit || !pointer) {
|
||
movexy(0, SY);
|
||
clrtoeol();
|
||
movexy(0, SY);
|
||
addstr("keine Einheit hier");
|
||
refresh();
|
||
} else {
|
||
s = strchr(pointer->s, '(');
|
||
if (s) {
|
||
s++;
|
||
f = atoi36(s);
|
||
x = findunit(f, r);
|
||
if (x && modify_unit(r, findunit(f, r))) {
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
freelist(eh);
|
||
delwin(mywin);
|
||
clipunit = x;
|
||
clipregion = r;
|
||
return 1;
|
||
} else
|
||
f = -1;
|
||
}
|
||
}
|
||
break;
|
||
case 'P':
|
||
case 'p':
|
||
if (!clipunit)
|
||
beep();
|
||
else {
|
||
leave(clipregion, clipunit);
|
||
if (r != clipregion)
|
||
translist(&clipregion->units, &r->units, clipunit);
|
||
modified = 1;
|
||
if (pointer && (s = strchr(pointer->s, '('))!=NULL) {
|
||
s++;
|
||
f = atoi36(s);
|
||
if (f)
|
||
switch (pointer->s[0]) {
|
||
case '\025':
|
||
f = atoi36(s);
|
||
x = findunit(f, r);
|
||
clipunit->building = x->building;
|
||
clipunit->ship = x->ship;
|
||
clipregion = r;
|
||
break;
|
||
case '\002':
|
||
f = atoi(s);
|
||
b = findbuilding(f);
|
||
for (x = r->units; x; x = x->next)
|
||
if (x->building == b && fval(x, FL_OWNER))
|
||
freset(x, FL_OWNER);
|
||
clipunit->building = b;
|
||
fset(clipunit, FL_OWNER);
|
||
break;
|
||
case '\023':
|
||
f = atoi(s);
|
||
sh = findship(f);
|
||
for (x = r->units; x; x = x->next)
|
||
if (x->ship == sh && fval(x, FL_OWNER))
|
||
freset(x, FL_OWNER);
|
||
clipunit->ship = sh;
|
||
fset(clipunit, FL_OWNER);
|
||
break;
|
||
}
|
||
}
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
delwin(mywin);
|
||
freelist(eh);
|
||
return 1; /* -> totaler Neuaufbau der
|
||
* Liste */
|
||
}
|
||
break;
|
||
case 'E':
|
||
clipunit = 0;
|
||
clipregion = 0;
|
||
break;
|
||
case 'D':
|
||
if (!clipunit)
|
||
beep();
|
||
else {
|
||
sprintf(lbuf, "Einheit %s l<>schen?", Unitid(clipunit));
|
||
if (yes_no(0, lbuf, 'n')) {
|
||
modified = 1;
|
||
destroy_unit(clipunit);
|
||
clipunit = 0;
|
||
clipregion = 0;
|
||
for (pline = 0, tmp = eh; tmp != pointer; tmp = tmp->next)
|
||
pline++; /* Stelle merken */
|
||
freelist(eh);
|
||
delwin(mywin);
|
||
return 1;
|
||
} else
|
||
wrefresh(mywin);
|
||
|
||
}
|
||
break;
|
||
case 'G':
|
||
case 'g':
|
||
if (!pointer) {
|
||
movexy(0, SY);
|
||
addstr("kann hier nichts aufnehmen");
|
||
refresh();
|
||
} else {
|
||
if ((s = strchr(pointer->s, '('))!=NULL) {
|
||
s++;
|
||
f = atoi36(s);
|
||
f2 = atoi(s);
|
||
if (f || f2)
|
||
switch (pointer->s[0]) {
|
||
case '\025':
|
||
clipunit = findunit(f, r);
|
||
clipregion = r;
|
||
break;
|
||
case '\023':
|
||
clipship = findship(f2);
|
||
shipregion = r;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case 27: /* Esc */
|
||
case 'q':
|
||
delwin(mywin);
|
||
freelist(eh);
|
||
pointer = NULL;
|
||
return 0;
|
||
}
|
||
|
||
if (f < 0) {
|
||
wclear(mywin);
|
||
for (line = 0, unten = oben; line < bot && unten->next; line++, unten = unten->next) {
|
||
Movexy(3, line);
|
||
sAddstr(unten->s);
|
||
}
|
||
bottom = line - 1;
|
||
f = 0;
|
||
}
|
||
}
|
||
}
|