diff options
author | Torne Wuff <torne@wolfpuppy.org.uk> | 2010-01-17 22:15:13 +0000 |
---|---|---|
committer | Torne Wuff <torne@wolfpuppy.org.uk> | 2010-01-17 22:15:13 +0000 |
commit | 7f28c94eda576e3f972fc05468188986f2e45885 (patch) | |
tree | e03b94613028d16855a5d3df0f4853e077931214 /apps/plugins/frotz/input.c | |
parent | 563f2602f471208cb8544a36539a79dcceaad643 (diff) | |
download | rockbox-7f28c94eda576e3f972fc05468188986f2e45885.tar.gz rockbox-7f28c94eda576e3f972fc05468188986f2e45885.zip |
New plugin: frotz, a Z-machine interpreter, for playing interactive fiction.
The interpreter more or less passes all the tests in the z-machine test suite.
It should build for every target except Archos (for which it is disabled).
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@24267 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/plugins/frotz/input.c')
-rw-r--r-- | apps/plugins/frotz/input.c | 301 |
1 files changed, 301 insertions, 0 deletions
diff --git a/apps/plugins/frotz/input.c b/apps/plugins/frotz/input.c new file mode 100644 index 0000000000..296bffc529 --- /dev/null +++ b/apps/plugins/frotz/input.c | |||
@@ -0,0 +1,301 @@ | |||
1 | /* input.c - High level input functions | ||
2 | * Copyright (c) 1995-1997 Stefan Jokisch | ||
3 | * | ||
4 | * Changes for Rockbox copyright 2009 Torne Wuff | ||
5 | * | ||
6 | * This file is part of Frotz. | ||
7 | * | ||
8 | * Frotz is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2 of the License, or | ||
11 | * (at your option) any later version. | ||
12 | * | ||
13 | * Frotz is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License | ||
19 | * along with this program; if not, write to the Free Software | ||
20 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA | ||
21 | */ | ||
22 | |||
23 | #include "frotz.h" | ||
24 | |||
25 | extern int save_undo (void); | ||
26 | |||
27 | extern zchar stream_read_key (zword, zword, bool); | ||
28 | extern zchar stream_read_input (int, zchar *, zword, zword, bool, bool); | ||
29 | |||
30 | extern void tokenise_line (zword, zword, zword, bool); | ||
31 | |||
32 | /* | ||
33 | * is_terminator | ||
34 | * | ||
35 | * Check if the given key is an input terminator. | ||
36 | * | ||
37 | */ | ||
38 | |||
39 | bool is_terminator (zchar key) | ||
40 | { | ||
41 | |||
42 | if (key == ZC_TIME_OUT) | ||
43 | return TRUE; | ||
44 | if (key == ZC_RETURN) | ||
45 | return TRUE; | ||
46 | if (key >= ZC_HKEY_MIN && key <= ZC_HKEY_MAX) | ||
47 | return TRUE; | ||
48 | |||
49 | if (h_terminating_keys != 0) | ||
50 | |||
51 | if (key >= ZC_ARROW_MIN && key <= ZC_MENU_CLICK) { | ||
52 | |||
53 | zword addr = h_terminating_keys; | ||
54 | zbyte c; | ||
55 | |||
56 | do { | ||
57 | LOW_BYTE (addr, c) | ||
58 | if (c == 255 || key == translate_from_zscii (c)) | ||
59 | return TRUE; | ||
60 | addr++; | ||
61 | } while (c != 0); | ||
62 | |||
63 | } | ||
64 | |||
65 | return FALSE; | ||
66 | |||
67 | }/* is_terminator */ | ||
68 | |||
69 | /* | ||
70 | * z_make_menu, add or remove a menu and branch if successful. | ||
71 | * | ||
72 | * zargs[0] = number of menu | ||
73 | * zargs[1] = table of menu entries or 0 to remove menu | ||
74 | * | ||
75 | */ | ||
76 | |||
77 | void z_make_menu (void) | ||
78 | { | ||
79 | |||
80 | /* This opcode was only used for the Macintosh version of Journey. | ||
81 | It controls menus with numbers greater than 2 (menus 0, 1 and 2 | ||
82 | are system menus). Frotz doesn't implement menus yet. */ | ||
83 | |||
84 | branch (FALSE); | ||
85 | |||
86 | }/* z_make_menu */ | ||
87 | |||
88 | extern bool read_yes_or_no (const char *s); | ||
89 | |||
90 | /* | ||
91 | * read_string | ||
92 | * | ||
93 | * Read a string from the current input stream. | ||
94 | * | ||
95 | */ | ||
96 | |||
97 | void read_string (int max, zchar *buffer) | ||
98 | { | ||
99 | zchar key; | ||
100 | |||
101 | buffer[0] = 0; | ||
102 | |||
103 | do { | ||
104 | |||
105 | key = stream_read_input (max, buffer, 0, 0, FALSE, FALSE); | ||
106 | |||
107 | } while (key != ZC_RETURN); | ||
108 | |||
109 | }/* read_string */ | ||
110 | |||
111 | /* | ||
112 | * read_number | ||
113 | * | ||
114 | * Ask the user to type in a number and return it. | ||
115 | * | ||
116 | */ | ||
117 | |||
118 | int read_number (void) | ||
119 | { | ||
120 | zchar buffer[6]; | ||
121 | int value = 0; | ||
122 | int i; | ||
123 | |||
124 | read_string (5, buffer); | ||
125 | |||
126 | for (i = 0; buffer[i] != 0; i++) | ||
127 | if (buffer[i] >= '0' && buffer[i] <= '9') | ||
128 | value = 10 * value + buffer[i] - '0'; | ||
129 | |||
130 | return value; | ||
131 | |||
132 | }/* read_number */ | ||
133 | |||
134 | /* | ||
135 | * z_read, read a line of input and (in V5+) store the terminating key. | ||
136 | * | ||
137 | * zargs[0] = address of text buffer | ||
138 | * zargs[1] = address of token buffer | ||
139 | * zargs[2] = timeout in tenths of a second (optional) | ||
140 | * zargs[3] = packed address of routine to be called on timeout | ||
141 | * | ||
142 | */ | ||
143 | |||
144 | void z_read (void) | ||
145 | { | ||
146 | zchar buffer[INPUT_BUFFER_SIZE]; | ||
147 | zword addr; | ||
148 | zchar key; | ||
149 | zbyte max, size; | ||
150 | zbyte c; | ||
151 | int i; | ||
152 | |||
153 | /* Supply default arguments */ | ||
154 | |||
155 | if (zargc < 3) | ||
156 | zargs[2] = 0; | ||
157 | |||
158 | /* Get maximum input size */ | ||
159 | |||
160 | addr = zargs[0]; | ||
161 | |||
162 | LOW_BYTE (addr, max) | ||
163 | |||
164 | if (h_version <= V4) | ||
165 | max--; | ||
166 | |||
167 | if (max >= INPUT_BUFFER_SIZE) | ||
168 | max = INPUT_BUFFER_SIZE - 1; | ||
169 | |||
170 | /* Get initial input size */ | ||
171 | |||
172 | if (h_version >= V5) { | ||
173 | addr++; | ||
174 | LOW_BYTE (addr, size) | ||
175 | } else size = 0; | ||
176 | |||
177 | /* Copy initial input to local buffer */ | ||
178 | |||
179 | for (i = 0; i < size; i++) { | ||
180 | addr++; | ||
181 | LOW_BYTE (addr, c) | ||
182 | buffer[i] = translate_from_zscii (c); | ||
183 | } | ||
184 | |||
185 | buffer[i] = 0; | ||
186 | |||
187 | /* Draw status line for V1 to V3 games */ | ||
188 | |||
189 | if (h_version <= V3) | ||
190 | z_show_status (); | ||
191 | |||
192 | /* Read input from current input stream */ | ||
193 | |||
194 | key = stream_read_input ( | ||
195 | max, buffer, /* buffer and size */ | ||
196 | zargs[2], /* timeout value */ | ||
197 | zargs[3], /* timeout routine */ | ||
198 | TRUE, /* enable hot keys */ | ||
199 | h_version == V6); /* no script in V6 */ | ||
200 | |||
201 | if (key == ZC_BAD) | ||
202 | return; | ||
203 | |||
204 | /* Perform save_undo for V1 to V4 games */ | ||
205 | |||
206 | if (h_version <= V4) | ||
207 | save_undo (); | ||
208 | |||
209 | /* Copy local buffer back to dynamic memory */ | ||
210 | |||
211 | for (i = 0; buffer[i] != 0; i++) { | ||
212 | |||
213 | if (key == ZC_RETURN) { | ||
214 | |||
215 | if (buffer[i] >= 'A' && buffer[i] <= 'Z') | ||
216 | buffer[i] += 'a' - 'A'; | ||
217 | if (buffer[i] >= 0xc0 && buffer[i] <= 0xde && buffer[i] != 0xd7) | ||
218 | buffer[i] += 0x20; | ||
219 | |||
220 | } | ||
221 | |||
222 | storeb ((zword) (zargs[0] + ((h_version <= V4) ? 1 : 2) + i), translate_to_zscii (buffer[i])); | ||
223 | |||
224 | } | ||
225 | |||
226 | /* Add null character (V1-V4) or write input length into 2nd byte */ | ||
227 | |||
228 | if (h_version <= V4) | ||
229 | storeb ((zword) (zargs[0] + 1 + i), 0); | ||
230 | else | ||
231 | storeb ((zword) (zargs[0] + 1), i); | ||
232 | |||
233 | /* Tokenise line if a token buffer is present */ | ||
234 | |||
235 | if (key == ZC_RETURN && zargs[1] != 0) | ||
236 | tokenise_line (zargs[0], zargs[1], 0, FALSE); | ||
237 | |||
238 | /* Store key */ | ||
239 | |||
240 | if (h_version >= V5) | ||
241 | store (translate_to_zscii (key)); | ||
242 | |||
243 | }/* z_read */ | ||
244 | |||
245 | /* | ||
246 | * z_read_char, read and store a key. | ||
247 | * | ||
248 | * zargs[0] = input device (must be 1) | ||
249 | * zargs[1] = timeout in tenths of a second (optional) | ||
250 | * zargs[2] = packed address of routine to be called on timeout | ||
251 | * | ||
252 | */ | ||
253 | |||
254 | void z_read_char (void) | ||
255 | { | ||
256 | zchar key; | ||
257 | |||
258 | /* Supply default arguments */ | ||
259 | |||
260 | if (zargc < 2) | ||
261 | zargs[1] = 0; | ||
262 | |||
263 | /* Read input from the current input stream */ | ||
264 | |||
265 | key = stream_read_key ( | ||
266 | zargs[1], /* timeout value */ | ||
267 | zargs[2], /* timeout routine */ | ||
268 | TRUE); /* enable hot keys */ | ||
269 | |||
270 | if (key == ZC_BAD) | ||
271 | return; | ||
272 | |||
273 | /* Store key */ | ||
274 | |||
275 | store (translate_to_zscii (key)); | ||
276 | |||
277 | }/* z_read_char */ | ||
278 | |||
279 | /* | ||
280 | * z_read_mouse, write the current mouse status into a table. | ||
281 | * | ||
282 | * zargs[0] = address of table | ||
283 | * | ||
284 | */ | ||
285 | |||
286 | void z_read_mouse (void) | ||
287 | { | ||
288 | zword btn; | ||
289 | |||
290 | /* Read the mouse position and which buttons are down */ | ||
291 | |||
292 | btn = os_read_mouse (); | ||
293 | hx_mouse_y = mouse_y; | ||
294 | hx_mouse_x = mouse_x; | ||
295 | |||
296 | storew ((zword) (zargs[0] + 0), hx_mouse_y); | ||
297 | storew ((zword) (zargs[0] + 2), hx_mouse_x); | ||
298 | storew ((zword) (zargs[0] + 4), btn); /* mouse button bits */ | ||
299 | storew ((zword) (zargs[0] + 6), 0); /* menu selection */ | ||
300 | |||
301 | }/* z_read_mouse */ | ||