/* -------------------------------------------------------------------- */
void doccr(void)
{
unsigned char row, col;
if (!console) return;
if (!anyEcho) return;
readpos( &row, &col);
if (row == (scrollpos + 1) )
{
position(0,0); /* clear screen if we hit our window */
}
if (row >= scrollpos)
{
scroll( scrollpos, 1, cfg.attr);
position( scrollpos, 0);
}
else
{
putch('\n');
putch('\r');
}
}
void Encoder::reset(void)
{
int i;
for(i=0;i<NFilter;i++){
readpos();
}
zeropos = rawpos;
}
void Encoder::set(int pos)
{
long zp;
readpos();
zp = (long)rawpos - pos;
if(zp<0)zp+=(MAX_ENC_VAL+1)<<OBITS;
zeropos = zp;
}
int main(int argc, char *argv[])
{
unsigned char i;
if(argc<2)
exit(0);
i=(unsigned char)atoi(argv[1]);
readpos(i);
return;
}
/* -------------------------------------------------------------------- */
void ctrl_c(void)
{
uchar row, col;
signal(SIGINT, ctrl_c);
readpos(&row, &col);
position(row - 1, 19);
ungetch('\r');
getkey = TRUE;
}
/* -------------------------------------------------------------------- */
void outCon(char c)
{
unsigned char row, col;
static char escape = FALSE;
if (!console) return;
if (c == 7 /* BELL */ && cfg.noBells) return;
if (c == 27 || escape) /* ESC || ANSI sequence */
{
escape = ansi(c);
return;
}
if (c == 26) /* CT-Z */ return;
if (!anyEcho) return;
/* if we dont have carrier then count what goes to console */
if (!gotCarrier()) transmitted++;
if (c == '\n')
doccr();
else
if (c == '\r')
{
putch(c);
} else {
readpos(&row, &col);
if (c == '\b' || c == 7)
{
if (c == '\b' && col == 0 && prevChar != 10)
position(row-1,80);
putch(c);
} else {
(*charattr)(c, ansiattr);
if (col == 79)
{
position(row,col);
doccr();
}
}
}
}
checkup()
{
register int k, n, explode, sink;
readpos();
for (n=0; n < scene[game].vessels; n++){
explode = scene[game].ship[n].file -> explode;
sink = scene[game].ship[n].file -> sink;
if (die() >= 5 && (explode == 1 || sink == 1)){
explode = 2;
if (sink != 1)
Write(FILES + n, 0, 232, explode);
else
Write(FILES + n, 0, 234, explode);
pos[n].dir = 0; /* hopefully enough to kill ship */
Write(n, 0, 10, 0);
if (fouled(n) || grappled(n)){
for (k=0; k < 10; k++){
if (scene[game].ship[n].file -> fouls[k].turnfoul)
cleanfoul(n,scene[game].ship[n].file -> fouls[k].toship,k);
}
for (k=0; k < 10; k++){
if (scene[game].ship[n].file -> grapples[k].turnfoul)
cleangrapple(n,scene[game].ship[n].file -> grapples[k].toship,k);
}
}
if (sink != 1){
makesignal("exploding!", 0, n);
for (k=0; k < scene[game].vessels; k++)
if (k != n && pos[k].dir && range(n,k) < 4)
table(RIGGING, EXPLODE, specs[scene[game].ship[n].shipnum].guns/13, k, n, 6);
}
else {
makesignal("sinking!", 0, n);
}
}
}
}
/*-------------------------------------------------------------------*/
int main (int argc, char *argv[])
{
char *pgmname; /* prog name in host format */
char *pgm; /* less any extension (.ext) */
char msgbuf[512]; /* message build work area */
int cckd_diag_rc = 0; /* Program return code */
char *fn; /* File name */
CKDDASD_DEVHDR devhdr; /* [C]CKD device hdr */
CCKDDASD_DEVHDR cdevhdr; /* Compressed CKD device hdr */
CKDDEV *ckd=0; /* CKD DASD table entry */
FBADEV *fba=0; /* FBA DASD table entry */
int cmd_devhdr = 0; /* display DEVHDR */
int cmd_cdevhdr = 0; /* display CDEVHDR */
int cmd_l1tab = 0; /* display L1TAB */
int cmd_l2tab = 0; /* display L2TAB */
int cmd_trkdata = 0; /* display track data */
int cmd_hexdump = 0; /* display track data (hex) */
int cmd_offset = 0; /* 1 = display data at */
int op_offset = 0; /* op_offset of length */
int op_length = 0; /* op_length */
int cmd_cchh = 0; /* 1 = display CCHH data */
int op_cc = 0; /* CC = cylinder */
int op_hh = 0; /* HH = head */
int cmd_tt = 0; /* 1 = display TT data */
int op_tt = 0; /* relative track # */
int swapend; /* 1 = New endianess doesn't
match machine endianess */
int n, trk=0, l1ndx=0, l2ndx=0;
off_t l2taboff=0; /* offset to assoc. L2 table */
int ckddasd; /* 1=CKD dasd 0=FBA dasd */
int heads=0; /* Heads per cylinder */
off_t trkhdroff=0; /* offset to assoc. trk hdr */
int imglen=0; /* track length */
char pathname[MAX_PATH]; /* file path in host format */
char *strtok_str = NULL;
/* Set program name */
if ( argc > 0 )
{
if ( strlen(argv[0]) == 0 )
{
pgmname = strdup( UTILITY_NAME );
}
else
{
char path[MAX_PATH];
#if defined( _MSVC_ )
GetModuleFileName( NULL, path, MAX_PATH );
#else
strncpy( path, argv[0], sizeof( path ) );
#endif
pgmname = strdup(basename(path));
#if !defined( _MSVC_ )
strncpy( path, argv[0], sizeof(path) );
#endif
}
}
else
{
pgmname = strdup( UTILITY_NAME );
}
pgm = strtok_r( strdup(pgmname), ".", &strtok_str);
INITIALIZE_UTILITY( pgmname );
/* Display the program identification message */
MSGBUF( msgbuf, MSG_C( HHC02499, "I", pgm, "CCKD diagnostic program" ) );
display_version (stderr, msgbuf+10, FALSE);
/* parse the arguments */
argc--;
argv++ ;
while (argc > 0) {
if(**argv != '-') break;
switch(argv[0][1]) {
case 'v': if (argv[0][2] != '\0') return syntax (pgm);
return 0;
case 'd': if (argv[0][2] != '\0') return syntax (pgm);
cmd_devhdr = 1;
break;
case 'c': if (argv[0][2] != '\0') return syntax (pgm);
cmd_cdevhdr = 1;
break;
case '1': if (argv[0][2] != '\0') return syntax (pgm);
cmd_l1tab = 1;
break;
case '2': if (argv[0][2] != '\0') return syntax (pgm);
cmd_l2tab = 1;
break;
case 'a': if (argv[0][2] != '\0') return syntax (pgm);
cmd_cchh = 1;
argc--; argv++;
op_cc = offtify(*argv);
argc--; argv++;
op_hh = offtify(*argv);
break;
case 'r': if (argv[0][2] != '\0') return syntax (pgm);
cmd_tt = 1;
argc--; argv++;
op_tt = offtify(*argv);
break;
case 'o': if (argv[0][2] != '\0') return syntax (pgm);
cmd_offset = 1;
argc--;
argv++;
op_offset = offtify(*argv);
argc--;
argv++;
op_length = offtify(*argv);
break;
case 't': if (argv[0][2] != '\0') return syntax (pgm);
cmd_trkdata = 1;
break;
case 'x': if (argv[0][2] != '\0') return syntax (pgm);
cmd_hexdump = 1;
cmd_trkdata = 1;
break;
case 'g': if (argv[0][2] != '\0') return syntax (pgm);
debug = 1;
break;
default: return syntax (pgm);
}
argc--;
argv++;
}
if (argc != 1) return syntax (pgm);
fn = argv[0];
/* open the file */
hostpath(pathname, fn, sizeof(pathname));
fd = HOPEN(pathname, O_RDONLY | O_BINARY);
if (fd < 0) {
fprintf(stderr,
_("cckddiag: error opening file %s: %s\n"),
fn, strerror(errno));
return -1;
}
/*---------------------------------------------------------------*/
/* display DEVHDR - first 512 bytes of dasd image */
/*---------------------------------------------------------------*/
readpos(fd, &devhdr, 0, sizeof(devhdr));
if (cmd_devhdr) {
fprintf(stderr, "\nDEVHDR - %d (decimal) bytes:\n",
(int)sizeof(devhdr));
data_dump(&devhdr, sizeof(devhdr));
}
/*---------------------------------------------------------------*/
/* Determine CKD or FBA device type */
/*---------------------------------------------------------------*/
if (memcmp(devhdr.devid, "CKD_C370", 8) == 0
|| memcmp(devhdr.devid, "CKD_S370", 8) == 0) {
ckddasd = 1;
ckd = dasd_lookup(DASD_CKDDEV, NULL, devhdr.devtype, 0);
if (ckd == NULL) {
fprintf(stderr,
"DASD table entry not found for devtype 0x%2.2X\n",
devhdr.devtype);
clean();
exit(5);
}
}
else
if (memcmp(devhdr.devid, "FBA_C370", 8) == 0
|| memcmp(devhdr.devid, "FBA_S370", 8) == 0) {
ckddasd = 0;
fba = dasd_lookup(DASD_FBADEV, NULL, devhdr.devtype, 0);
if (fba == NULL) {
fprintf(stderr,
"DASD table entry not found for "
"devtype 0x%2.2X\n",
DEFAULT_FBA_TYPE);
clean();
exit(6);
}
}
else {
fprintf(stderr, "incorrect header id\n");
clean();
return -1;
}
/*---------------------------------------------------------------*/
/* Set up device characteristics */
/*---------------------------------------------------------------*/
if (ckddasd) {
heads = ((U32)(devhdr.heads[3]) << 24)
| ((U32)(devhdr.heads[2]) << 16)
| ((U32)(devhdr.heads[1]) << 8)
| (U32)(devhdr.heads[0]);
if (debug)
fprintf(stderr,
"\nHHC90000D DBG: %s device has %d heads/cylinder\n",
ckd->name, heads);
}
/*---------------------------------------------------------------*/
/* display CDEVHDR - follows DEVHDR */
/*---------------------------------------------------------------*/
readpos(fd, &cdevhdr, CKDDASD_DEVHDR_SIZE, sizeof(cdevhdr));
if (cmd_cdevhdr) {
fprintf(stderr, "\nCDEVHDR - %d (decimal) bytes:\n",
(int)sizeof(cdevhdr));
data_dump(&cdevhdr, sizeof(cdevhdr));
}
/*---------------------------------------------------------------*/
/* Find machine endian-ness */
/*---------------------------------------------------------------*/
/* cckd_endian() returns 1 for big-endian machines */
swapend = (cckd_endian() !=
((cdevhdr.options & CCKD_BIGENDIAN) != 0));
/*---------------------------------------------------------------*/
/* display L1TAB - follows CDEVHDR */
/*---------------------------------------------------------------*/
/* swap numl1tab if needed */
n = cdevhdr.numl1tab;
if (swapend) cckd_swapend4((char *)&n);
l1 = makbuf(n * CCKD_L1ENT_SIZE, "L1TAB");
readpos(fd, l1, CCKD_L1TAB_POS, n * CCKD_L1ENT_SIZE);
/* L1TAB itself is not adjusted for endian-ness */
if (cmd_l1tab) {
fprintf(stderr, "\nL1TAB - %d (0x%X) bytes:\n",
(int)(n * CCKD_L1ENT_SIZE), (unsigned int)(n * CCKD_L1ENT_SIZE));
data_dump(l1, n * CCKD_L1ENT_SIZE);
}
/*---------------------------------------------------------------*/
/* display OFFSET, LENGTH data */
/*---------------------------------------------------------------*/
if (cmd_offset) {
bulk = makbuf(op_length, "BULK");
readpos(fd, bulk, op_offset, op_length);
fprintf(stderr,
"\nIMAGE OFFSET %d (0x%8.8X) "
"of length %d (0x%8.8X) bytes:\n",
op_offset, op_offset, op_length, op_length);
data_dump(bulk, op_length);
free(bulk);
bulk = NULL;
}
/*---------------------------------------------------------------*/
/* FBA isn't supported here because I don't know much about FBA */
/*---------------------------------------------------------------*/
if ( (!ckddasd) && ((cmd_cchh) || (cmd_tt)) ) {
fprintf(stderr, "CCHH/reltrk not supported for FBA\n");
clean();
exit(3);
}
/*---------------------------------------------------------------*/
/* Setup CCHH or relative track request */
/*---------------------------------------------------------------*/
if (ckddasd) {
if (cmd_tt) {
trk = op_tt;
op_cc = trk / heads;
op_hh = trk % heads;
} else {
trk = (op_cc * heads) + op_hh;
}
l1ndx = trk / cdevhdr.numl2tab;
l2ndx = trk % cdevhdr.numl2tab;
l2taboff = l1[l1ndx];
if (swapend) cckd_swapend4((char *)&l2taboff);
}
/*---------------------------------------------------------------*/
/* display CKD CCHH or relative track data */
/*---------------------------------------------------------------*/
if ((cmd_cchh) || (cmd_tt)) {
fprintf(stderr,
"CC %d HH %d = reltrk %d; "
"L1 index = %d, L2 index = %d\n"
"L1 index %d = L2TAB offset %d (0x%8.8X)\n",
op_cc, op_hh, trk,
l1ndx, l2ndx,
l1ndx, (int)l2taboff, (int)l2taboff);
l2 = makbuf(cdevhdr.numl2tab * sizeof(CCKD_L2ENT), "L2TAB");
readpos(fd, l2, l2taboff,
cdevhdr.numl2tab * sizeof(CCKD_L2ENT));
if (cmd_l2tab) {
fprintf(stderr,
"\nL2TAB - %d (decimal) bytes\n",
(int)(cdevhdr.numl2tab * sizeof(CCKD_L2ENT)));
data_dump(l2, (cdevhdr.numl2tab * sizeof(CCKD_L2ENT)) );
}
fprintf(stderr, "\nL2 index %d = L2TAB entry %d bytes\n",
l2ndx, (int)sizeof(CCKD_L2ENT) );
data_dump(&l2[l2ndx], sizeof(CCKD_L2ENT) );
trkhdroff = l2[l2ndx].pos;
imglen = l2[l2ndx].len;
if (swapend) {
cckd_swapend4((char *)&trkhdroff);
cckd_swapend4((char *)&imglen);
}
fprintf(stderr, "\nTRKHDR offset %d (0x%8.8X); "
"length %d (0x%4.4X)\n",
(int)trkhdroff, (int)trkhdroff, imglen, imglen);
tbuf = makbuf(imglen, "TRKHDR+DATA");
readpos(fd, tbuf, trkhdroff, imglen);
fprintf(stderr, "\nTRKHDR track %d\n", trk);
data_dump(tbuf, sizeof(CKDDASD_TRKHDR) );
if (cmd_trkdata) showtrk(tbuf, imglen, trk, cmd_hexdump);
free(l2); free(tbuf);
l2 = NULL; tbuf = NULL;
}
/* Close file, exit */
fprintf(stderr, "\n");
clean();
return cckd_diag_rc;
}
int main() {
fin = fopen(_P ".in", "r"); assert(fin);
fout = fopen(_P ".out", "w"); assert(fout);
// read input
ret = fscanf(fin, "%d %d", &rmax, &cmax);
assert(ret == 2);
readpos(fin, &king);
nknight = 0;
while (readpos(fin, &knights[nknight])) {
nknight++;
}
/*
printpos(&king);
for (int i = 0; i < nknight; i++) {
printpos(&knights[i]);
}
*/
fclose(fin);
// compute the min map
computeAll();
int mintotal = -1;
int rking = king.r;
int cking = king.c;
for (int rgath = 0; rgath < rmax; rgath++) {
for (int cgath = 0; cgath < cmax; cgath++) {
int minkdelta = imax(iabs(rking - rgath),
iabs(cking - cgath));
int indgath = indexof(rgath, cgath);
int total = 0;
bool unreachable = false;
for (int k = 0; k < nknight; k++) {
int indknight = indexof(&knights[k]);
int ms = minsteps(indgath, indknight);
if (ms < 0) {
unreachable = true;
break;
}
knights[k].d = minsteps(indgath, indknight);
total += knights[k].d;
}
if (unreachable) continue; // knight unreachable
memset(touched, 0, sizeof(bool) * MAXIND);
int head = 0;
int tail = 1;
trace[0].r = rking; trace[0].c = cking;
trace[0].d = 0;
while (head < tail) {
int dthis = trace[head].d;
if (dthis >= minkdelta) break;
int rthis = trace[head].r;
int cthis = trace[head].c;
int indpick = indexof(rthis, cthis);
int deltabase = minsteps(indgath, indpick);
if (deltabase >= 0) { // reachable
int mindel = 1000;
for (int k = 0; k < nknight; k++) {
int indknight = indexof(&knights[k]);
int ms = minsteps(indpick, indknight);
if (ms < 0) continue;
int delta = deltabase + ms;
assert(delta >= knights[k].d);
delta -= knights[k].d;
if (delta < mindel) {
mindel = delta;
}
if (mindel == 0) break; // drive by already
}
if (nknight > 0) { // have knights
int dmin = dthis + mindel;
if (dmin < minkdelta) {
minkdelta = dmin;
}
}
}
for (int i = 0; i < 8; i++) {
int rthat = rthis + ksteps[i].r;
int cthat = cthis + ksteps[i].c;
if (rthat < 0 || rthat >= rmax) continue;
if (cthat < 0 || cthat >= cmax) continue;
int ind = indexof(rthat, cthat);
if (touched[ind]) continue;
int dthat = dthis + 1;
touched[ind] = true;
trace[tail].r = rthat;
trace[tail].c = cthat;
trace[tail].d = dthat;
tail++;
}
head++;
}
total += minkdelta;
if (mintotal < 0 || total < mintotal) {
mintotal = total;
}
}
}
assert(mintotal >= 0);
fprintf(fout, "%d\n", mintotal);
return 0;
}
/* Initialize the gamestate by reading the level data, in MS dat-file
* format, from the state's setup.
*/
static int expandmsdatlevel(gamestate *state)
{
gamesetup *setup;
unsigned char const *data;
unsigned char const *dataend;
int size, pos, id;
int i, n;
memset(state->map, 0, sizeof state->map);
state->trapcount = 0;
state->clonercount = 0;
state->crlistcount = 0;
state->hinttext[0] = '\0';
setup = state->game;
if (setup->levelsize < 10)
goto badlevel;
data = setup->leveldata;
dataend = data + setup->levelsize;
if (readword(data) == 0)
goto badlevel;
state->chipsneeded = readword(data + 4);
if (readword(data + 6) > 1)
goto badlevel;
size = readword(data + 8);
data += 10;
if (data + size + 2 > dataend)
goto badlevel;
for (n = pos = 0 ; n < size && pos < CXGRID * CYGRID ; ++n) {
if (data[n] == 0xFF) {
i = data[++n];
id = data[++n];
} else {
i = 1;
id = data[n];
}
if (id >= (int)(sizeof fileids / sizeof *fileids)) {
id = Wall;
state->statusflags |= SF_BADTILES;
} else {
id = fileids[id];
}
while (i-- && pos < CXGRID * CYGRID)
state->map[pos++].top.id = id;
}
if (n < size)
warn("level %d: %d extra bytes in upper map layer",
setup->number, size - n);
else if (pos < CXGRID * CYGRID)
warn("level %d: %d missing bytes in upper map layer",
setup->number, CXGRID * CYGRID - pos);
data += size + 2;
size = readword(data - 2);
if (data + size > dataend)
goto badlevel;
for (n = pos = 0 ; n < size && pos < CXGRID * CYGRID ; ++n) {
if (data[n] == 0xFF) {
i = data[++n];
id = data[++n];
} else {
i = 1;
id = data[n];
}
if (id >= (int)(sizeof fileids / sizeof *fileids)) {
id = Wall;
state->statusflags |= SF_BADTILES;
} else {
id = fileids[id];
}
while (i-- && pos < CXGRID * CYGRID)
state->map[pos++].bot.id = id;
}
if (n < size)
warn("level %d: %d extra bytes in lower map layer",
setup->number, size - n);
else if (pos < CXGRID * CYGRID)
warn("level %d: %d missing bytes in lower map layer",
setup->number, CXGRID * CYGRID - pos);
data += size;
size = readword(data);
data += 2;
if (data + size != dataend)
warn("level %d: inconsistent metadata", setup->number);
while (data + 2 < dataend) {
size = data[1];
data += 2;
if (data + size > dataend)
size = dataend - data;
switch (data[-2]) {
case 1:
/* time */
break;
case 2:
if (size < 2)
warn("level %d: ignoring field 2 data of size %d",
setup->number, size);
else
state->chipsneeded = readword(data);
break;
case 3:
/* level name */
break;
case 4:
if (size % 10)
warn("level %d: ignoring %d extra bytes at end of field 4",
setup->number, size % 10);
state->trapcount = size / 10;
for (i = 0 ; i < state->trapcount ; ++i) {
state->traps[i].from = readpos(data + i * 10,
data + i * 10 + 2);
state->traps[i].to = readpos(data + i * 10 + 4,
data + i * 10 + 6);
}
break;
case 5:
if (size % 8)
warn("level %d: ignoring %d extra bytes at end of field 5",
setup->number, size % 8);
state->clonercount = size / 8;
for (i = 0 ; i < state->clonercount ; ++i) {
state->cloners[i].from = readpos(data + i * 8,
data + i * 8 + 2);
state->cloners[i].to = readpos(data + i * 8 + 4,
data + i * 8 + 6);
}
break;
case 6:
/* passwd */
break;
case 7:
memcpy(state->hinttext, data, size);
state->hinttext[size] = '\0';
break;
case 8:
/* field 8 passwd */
break;
case 10:
if (size % 2)
warn("level %d: ignoring extra byte at end of field 10",
setup->number);
state->crlistcount = size / 2;
for (i = 0 ; i < state->crlistcount ; ++i)
state->crlist[i] = readpos(data + i * 2, data + i * 2 + 1);
break;
default:
warn("level %d: ignoring unrecognized field %d (%d bytes)",
setup->number, data[-2], size);
break;
}
data += size;
}
return TRUE;
badlevel:
errmsg(NULL, "level %d: invalid data", setup->number);
return FALSE;
}
