![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hack.cmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / games / hack|
Return to hack.cmd.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / games / hack |
1.1 root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2: /* hack.cmd.c - version 1.0.3 */
3:
4: #include "hack.h"
5: #include "def.func_tab.h"
6:
7: int doredraw(),doredotopl(),dodrop(),dodrink(),doread(),dosearch(),dopickup(),
8: doversion(),doweararm(),dowearring(),doremarm(),doremring(),dopay(),doapply(),
9: dosave(),dowield(),ddoinv(),dozap(),ddocall(),dowhatis(),doengrave(),dotele(),
10: dohelp(),doeat(),doddrop(),do_mname(),doidtrap(),doprwep(),doprarm(),
11: doprring(),doprgold(),dodiscovered(),dotypeinv(),dolook(),doset(),
12: doup(), dodown(), done1(), donull(), dothrow(), doextcmd(), dodip(), dopray();
13: #ifdef SHELL
14: int dosh();
15: #endif SHELL
16: #ifdef SUSPEND
17: int dosuspend();
18: #endif SUSPEND
19:
20: struct func_tab cmdlist[]={
21: '\020', doredotopl,
22: '\022', doredraw,
23: '\024', dotele,
24: #ifdef SUSPEND
25: '\032', dosuspend,
26: #endif SUSPEND
27: 'a', doapply,
28: /* 'A' : UNUSED */
29: /* 'b', 'B' : go sw */
30: 'c', ddocall,
31: 'C', do_mname,
32: 'd', dodrop,
33: 'D', doddrop,
34: 'e', doeat,
35: 'E', doengrave,
36: /* 'f', 'F' : multiple go (might become 'fight') */
37: /* 'g', 'G' : UNUSED */
38: /* 'h', 'H' : go west */
39: 'I', dotypeinv, /* Robert Viduya */
40: 'i', ddoinv,
41: /* 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N' : move commands */
42: /* 'o', doopen, */
43: 'O', doset,
44: 'p', dopay,
45: 'P', dowearring,
46: 'q', dodrink,
47: 'Q', done1,
48: 'r', doread,
49: 'R', doremring,
50: 's', dosearch,
51: 'S', dosave,
52: 't', dothrow,
53: 'T', doremarm,
54: /* 'u', 'U' : go ne */
55: 'v', doversion,
56: /* 'V' : UNUSED */
57: 'w', dowield,
58: 'W', doweararm,
59: /* 'x', 'X' : UNUSED */
60: /* 'y', 'Y' : go nw */
61: 'z', dozap,
62: /* 'Z' : UNUSED */
63: '<', doup,
64: '>', dodown,
65: '/', dowhatis,
66: '?', dohelp,
67: #ifdef SHELL
68: '!', dosh,
69: #endif SHELL
70: '.', donull,
71: ' ', donull,
72: ',', dopickup,
73: ':', dolook,
74: '^', doidtrap,
75: '\\', dodiscovered, /* Robert Viduya */
76: WEAPON_SYM, doprwep,
77: ARMOR_SYM, doprarm,
78: RING_SYM, doprring,
79: '$', doprgold,
80: '#', doextcmd,
81: 0,0,0
82: };
83:
84: struct ext_func_tab extcmdlist[] = {
85: "dip", dodip,
86: "pray", dopray,
87: (char *) 0, donull
88: };
89:
90: extern char *parse(), lowc(), unctrl(), quitchars[];
91:
92: rhack(cmd)
93: register char *cmd;
94: {
95: register struct func_tab *tlist = cmdlist;
96: boolean firsttime = FALSE;
97: register res;
98:
99: if(!cmd) {
100: firsttime = TRUE;
101: flags.nopick = 0;
102: cmd = parse();
103: }
104: if(!*cmd || (*cmd & 0377) == 0377 ||
105: (flags.no_rest_on_space && *cmd == ' ')){
106: bell();
107: flags.move = 0;
108: return; /* probably we just had an interrupt */
109: }
110: if(movecmd(*cmd)) {
111: walk:
112: if(multi) flags.mv = 1;
113: domove();
114: return;
115: }
116: if(movecmd(lowc(*cmd))) {
117: flags.run = 1;
118: rush:
119: if(firsttime){
120: if(!multi) multi = COLNO;
121: u.last_str_turn = 0;
122: }
123: flags.mv = 1;
124: #ifdef QUEST
125: if(flags.run >= 4) finddir();
126: if(firsttime){
127: u.ux0 = u.ux + u.dx;
128: u.uy0 = u.uy + u.dy;
129: }
130: #endif QUEST
131: domove();
132: return;
133: }
134: if((*cmd == 'f' && movecmd(cmd[1])) || movecmd(unctrl(*cmd))) {
135: flags.run = 2;
136: goto rush;
137: }
138: if(*cmd == 'F' && movecmd(lowc(cmd[1]))) {
139: flags.run = 3;
140: goto rush;
141: }
142: if(*cmd == 'm' && movecmd(cmd[1])) {
143: flags.run = 0;
144: flags.nopick = 1;
145: goto walk;
146: }
147: if(*cmd == 'M' && movecmd(lowc(cmd[1]))) {
148: flags.run = 1;
149: flags.nopick = 1;
150: goto rush;
151: }
152: #ifdef QUEST
153: if(*cmd == cmd[1] && (*cmd == 'f' || *cmd == 'F')) {
154: flags.run = 4;
155: if(*cmd == 'F') flags.run += 2;
156: if(cmd[2] == '-') flags.run += 1;
157: goto rush;
158: }
159: #endif QUEST
160: while(tlist->f_char) {
161: if(*cmd == tlist->f_char){
162: res = (*(tlist->f_funct))();
163: if(!res) {
164: flags.move = 0;
165: multi = 0;
166: }
167: return;
168: }
169: tlist++;
170: }
171: { char expcmd[10];
172: register char *cp = expcmd;
173: while(*cmd && cp-expcmd < sizeof(expcmd)-2) {
174: if(*cmd >= 040 && *cmd < 0177)
175: *cp++ = *cmd++;
176: else {
177: *cp++ = '^';
178: *cp++ = *cmd++ ^ 0100;
179: }
180: }
181: *cp++ = 0;
182: pline("Unknown command '%s'.", expcmd);
183: }
184: multi = flags.move = 0;
185: }
186:
187: doextcmd() /* here after # - now read a full-word command */
188: {
189: char buf[BUFSZ];
190: register struct ext_func_tab *efp = extcmdlist;
191:
192: pline("# ");
193: getlin(buf);
194: clrlin();
195: if(buf[0] == '\033')
196: return(0);
197: while(efp->ef_txt) {
198: if(!strcmp(efp->ef_txt, buf))
199: return((*(efp->ef_funct))());
200: efp++;
201: }
202: pline("%s: unknown command.", buf);
203: return(0);
204: }
205:
206: char
207: lowc(sym)
208: char sym;
209: {
210: return( (sym >= 'A' && sym <= 'Z') ? sym+'a'-'A' : sym );
211: }
212:
213: char
214: unctrl(sym)
215: char sym;
216: {
217: return( (sym >= ('A' & 037) && sym <= ('Z' & 037)) ? sym + 0140 : sym );
218: }
219:
220: /* 'rogue'-like direction commands */
221: char sdir[] = "hykulnjb><";
222: schar xdir[10] = { -1,-1, 0, 1, 1, 1, 0,-1, 0, 0 };
223: schar ydir[10] = { 0,-1,-1,-1, 0, 1, 1, 1, 0, 0 };
224: schar zdir[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 1,-1 };
225:
226: movecmd(sym) /* also sets u.dz, but returns false for <> */
227: char sym;
228: {
229: register char *dp;
230:
231: u.dz = 0;
232: if(!(dp = index(sdir, sym))) return(0);
233: u.dx = xdir[dp-sdir];
234: u.dy = ydir[dp-sdir];
235: u.dz = zdir[dp-sdir];
236: return(!u.dz);
237: }
238:
239: getdir(s)
240: boolean s;
241: {
242: char dirsym;
243:
244: if(s) pline("In what direction?");
245: dirsym = readchar();
246: if(!movecmd(dirsym) && !u.dz) {
247: if(!index(quitchars, dirsym))
248: pline("What a strange direction!");
249: return(0);
250: }
251: if(Confusion && !u.dz)
252: confdir();
253: return(1);
254: }
255:
256: confdir()
257: {
258: register x = rn2(8);
259: u.dx = xdir[x];
260: u.dy = ydir[x];
261: }
262:
263: #ifdef QUEST
264: finddir(){
265: register int i, ui = u.di;
266: for(i = 0; i <= 8; i++){
267: if(flags.run & 1) ui++; else ui += 7;
268: ui %= 8;
269: if(i == 8){
270: pline("Not near a wall.");
271: flags.move = multi = 0;
272: return(0);
273: }
274: if(!isroom(u.ux+xdir[ui], u.uy+ydir[ui]))
275: break;
276: }
277: for(i = 0; i <= 8; i++){
278: if(flags.run & 1) ui += 7; else ui++;
279: ui %= 8;
280: if(i == 8){
281: pline("Not near a room.");
282: flags.move = multi = 0;
283: return(0);
284: }
285: if(isroom(u.ux+xdir[ui], u.uy+ydir[ui]))
286: break;
287: }
288: u.di = ui;
289: u.dx = xdir[ui];
290: u.dy = ydir[ui];
291: }
292:
293: isroom(x,y) register x,y; { /* what about POOL? */
294: return(isok(x,y) && (levl[x][y].typ == ROOM ||
295: (levl[x][y].typ >= LDOOR && flags.run >= 6)));
296: }
297: #endif QUEST
298:
299: isok(x,y) register x,y; {
300: /* x corresponds to curx, so x==1 is the first column. Ach. %% */
301: return(x >= 1 && x <= COLNO-1 && y >= 0 && y <= ROWNO-1);
302: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.