4 #include <glib-object.h>
6 #include <glib/gi18n-lib.h>
7 #include "chimara-if.h"
8 #include "chimara-glk.h"
9 #include "chimara-marshallers.h"
12 static gboolean supported_formats[CHIMARA_IF_NUM_FORMATS][CHIMARA_IF_NUM_INTERPRETERS] = {
13 /* Frotz Nitfol Glulxe Git */
14 { TRUE, TRUE, FALSE, FALSE }, /* Z5 */
15 { TRUE, TRUE, FALSE, FALSE }, /* Z6 */
16 { TRUE, TRUE, FALSE, FALSE }, /* Z8 */
17 { TRUE, TRUE, FALSE, FALSE }, /* Zblorb */
18 { FALSE, FALSE, TRUE, TRUE }, /* Glulx */
19 { FALSE, FALSE, TRUE, TRUE } /* Gblorb */
21 static gchar *format_names[CHIMARA_IF_NUM_FORMATS] = {
22 N_("Z-code version 5"),
23 N_("Z-code version 6"),
24 N_("Z-code version 8"),
29 static gchar *interpreter_names[CHIMARA_IF_NUM_INTERPRETERS] = {
30 N_("Frotz"), N_("Nitfol"), N_("Glulxe"), N_("Git")
32 static gchar *plugin_names[CHIMARA_IF_NUM_INTERPRETERS] = {
33 "frotz", "nitfol", "glulxe", "git"
36 typedef enum _ChimaraIFFlags {
37 CHIMARA_IF_PIRACY_MODE = 1 << 0,
38 CHIMARA_IF_TANDY_BIT = 1 << 1,
39 CHIMARA_IF_EXPAND_ABBREVIATIONS = 1 << 2,
40 CHIMARA_IF_IGNORE_ERRORS = 1 << 3,
41 CHIMARA_IF_TYPO_CORRECTION = 1 << 4
44 typedef struct _ChimaraIFPrivate {
45 ChimaraIFInterpreter preferred_interpreter[CHIMARA_IF_NUM_FORMATS];
46 ChimaraIFFormat format;
47 ChimaraIFInterpreter interpreter;
49 ChimaraIFZmachineVersion interpreter_number;
51 gboolean random_seed_set;
52 /* Holding buffers for input and response */
57 #define CHIMARA_IF_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), CHIMARA_TYPE_IF, ChimaraIFPrivate))
58 #define CHIMARA_IF_USE_PRIVATE(o, n) ChimaraIFPrivate *n = CHIMARA_IF_PRIVATE(o)
64 PROP_EXPAND_ABBREVIATIONS,
67 PROP_INTERPRETER_NUMBER,
77 static guint chimara_if_signals[LAST_SIGNAL] = { 0 };
79 G_DEFINE_TYPE(ChimaraIF, chimara_if, CHIMARA_TYPE_GLK);
82 chimara_if_waiting(ChimaraGlk *glk)
84 CHIMARA_IF_USE_PRIVATE(glk, priv);
86 gchar *response = g_string_free(priv->response, FALSE);
87 priv->response = g_string_new("");
89 g_signal_emit_by_name(glk, "command", priv->input, response);
97 chimara_if_stopped(ChimaraGlk *glk)
99 CHIMARA_IF_USE_PRIVATE(glk, priv);
101 if(priv->input || priv->response->len > 0)
102 chimara_if_waiting(glk); /* Send one last command signal */
104 priv->format = CHIMARA_IF_FORMAT_NONE;
105 priv->interpreter = CHIMARA_IF_INTERPRETER_NONE;
109 chimara_if_line_input(ChimaraGlk *glk, guint32 win_rock, gchar *input)
111 CHIMARA_IF_USE_PRIVATE(glk, priv);
112 g_assert(priv->input == NULL);
113 priv->input = g_strdup(input);
117 chimara_if_text_buffer_output(ChimaraGlk *glk, guint32 win_rock, gchar *output)
119 CHIMARA_IF_USE_PRIVATE(glk, priv);
120 g_string_append(priv->response, output);
124 chimara_if_init(ChimaraIF *self)
126 CHIMARA_IF_USE_PRIVATE(self, priv);
127 priv->preferred_interpreter[CHIMARA_IF_FORMAT_Z5] = CHIMARA_IF_INTERPRETER_FROTZ;
128 priv->preferred_interpreter[CHIMARA_IF_FORMAT_Z6] = CHIMARA_IF_INTERPRETER_FROTZ;
129 priv->preferred_interpreter[CHIMARA_IF_FORMAT_Z8] = CHIMARA_IF_INTERPRETER_FROTZ;
130 priv->preferred_interpreter[CHIMARA_IF_FORMAT_Z_BLORB] = CHIMARA_IF_INTERPRETER_FROTZ;
131 priv->preferred_interpreter[CHIMARA_IF_FORMAT_GLULX] = CHIMARA_IF_INTERPRETER_GLULXE;
132 priv->preferred_interpreter[CHIMARA_IF_FORMAT_GLULX_BLORB] = CHIMARA_IF_INTERPRETER_GLULXE;
133 priv->format = CHIMARA_IF_FORMAT_NONE;
134 priv->interpreter = CHIMARA_IF_INTERPRETER_NONE;
135 priv->flags = CHIMARA_IF_TYPO_CORRECTION;
136 priv->interpreter_number = CHIMARA_IF_ZMACHINE_DEFAULT;
137 priv->random_seed_set = FALSE;
139 priv->response = g_string_new("");
141 /* Connect to signals of ChimaraGlk parent */
142 g_signal_connect(self, "stopped", G_CALLBACK(chimara_if_stopped), NULL);
143 g_signal_connect(self, "waiting", G_CALLBACK(chimara_if_waiting), NULL);
144 g_signal_connect(self, "line-input", G_CALLBACK(chimara_if_line_input), NULL);
145 g_signal_connect(self, "text-buffer-output", G_CALLBACK(chimara_if_text_buffer_output), NULL);
148 #define PROCESS_FLAG(flags, flag, val) (flags) = (val)? (flags) | (flag) : (flags) & ~(flag)
151 chimara_if_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
153 CHIMARA_IF_USE_PRIVATE(object, priv);
156 case PROP_PIRACY_MODE:
157 PROCESS_FLAG(priv->flags, CHIMARA_IF_PIRACY_MODE, g_value_get_boolean(value));
160 PROCESS_FLAG(priv->flags, CHIMARA_IF_TANDY_BIT, g_value_get_boolean(value));
162 case PROP_EXPAND_ABBREVIATIONS:
163 PROCESS_FLAG(priv->flags, CHIMARA_IF_EXPAND_ABBREVIATIONS, g_value_get_boolean(value));
165 case PROP_IGNORE_ERRORS:
166 PROCESS_FLAG(priv->flags, CHIMARA_IF_IGNORE_ERRORS, g_value_get_boolean(value));
168 case PROP_TYPO_CORRECTION:
169 PROCESS_FLAG(priv->flags, CHIMARA_IF_TYPO_CORRECTION, g_value_get_boolean(value));
171 case PROP_INTERPRETER_NUMBER:
172 priv->interpreter_number = g_value_get_uint(value);
174 case PROP_RANDOM_SEED:
175 priv->random_seed = g_value_get_int(value);
177 case PROP_RANDOM_SEED_SET:
178 priv->random_seed_set = g_value_get_boolean(value);
181 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
186 chimara_if_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
188 CHIMARA_IF_USE_PRIVATE(object, priv);
191 case PROP_PIRACY_MODE:
192 g_value_set_boolean(value, priv->flags & CHIMARA_IF_PIRACY_MODE);
195 g_value_set_boolean(value, priv->flags & CHIMARA_IF_TANDY_BIT);
197 case PROP_EXPAND_ABBREVIATIONS:
198 g_value_set_boolean(value, priv->flags & CHIMARA_IF_EXPAND_ABBREVIATIONS);
200 case PROP_IGNORE_ERRORS:
201 g_value_set_boolean(value, priv->flags & CHIMARA_IF_IGNORE_ERRORS);
203 case PROP_TYPO_CORRECTION:
204 g_value_set_boolean(value, priv->flags & CHIMARA_IF_TYPO_CORRECTION);
206 case PROP_INTERPRETER_NUMBER:
207 g_value_set_uint(value, priv->interpreter_number);
209 case PROP_RANDOM_SEED:
210 g_value_set_int(value, priv->random_seed);
212 case PROP_RANDOM_SEED_SET:
213 g_value_set_boolean(value, priv->random_seed_set);
216 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
221 chimara_if_finalize(GObject *object)
223 G_OBJECT_CLASS(chimara_if_parent_class)->finalize(object);
227 chimara_if_command(ChimaraIF *self, gchar *input, gchar *response)
229 /* Default signal handler */
232 /* G_PARAM_STATIC_STRINGS only appeared in GTK 2.13.0 */
233 #ifndef G_PARAM_STATIC_STRINGS
234 #define G_PARAM_STATIC_STRINGS (G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)
238 chimara_if_class_init(ChimaraIFClass *klass)
240 /* Override methods of parent classes */
241 GObjectClass *object_class = G_OBJECT_CLASS(klass);
242 object_class->set_property = chimara_if_set_property;
243 object_class->get_property = chimara_if_get_property;
244 object_class->finalize = chimara_if_finalize;
247 klass->command = chimara_if_command;
248 /* Gtk-Doc for command */
249 chimara_if_signals[COMMAND] = g_signal_new("command",
250 G_OBJECT_CLASS_TYPE(klass), 0,
251 G_STRUCT_OFFSET(ChimaraIFClass, command), NULL, NULL,
252 chimara_marshal_VOID__STRING_STRING,
253 G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
256 g_object_class_install_property(object_class, PROP_PIRACY_MODE,
257 g_param_spec_boolean("piracy-mode", _("Piracy mode"),
258 _("Pretend the game is pirated"), FALSE,
259 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
261 * ChimaraIF:tandy-bit:
263 * Some early Infocom games were sold by the Tandy Corporation. Setting this
264 * property to %TRUE changes the wording of some Version 3 Infocom games
265 * slightly, so as to be less offensive. See <ulink
266 * url="http://www.ifarchive.org/if-archive/infocom/info/tandy_bits.html">
267 * http://www.ifarchive.org/if-archive/infocom/info/tandy_bits.html</ulink>.
269 * Only works on Z-machine interpreters.
271 g_object_class_install_property(object_class, PROP_TANDY_BIT,
272 g_param_spec_boolean("tandy-bit", _("Tandy bit"),
273 _("Censor certain Infocom games"), FALSE,
274 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
276 g_object_class_install_property(object_class, PROP_EXPAND_ABBREVIATIONS,
277 g_param_spec_boolean("expand-abbreviations", _("Expand abbreviations"),
278 _("Expand abbreviations such as X for EXAMINE"), FALSE,
279 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
281 g_object_class_install_property(object_class, PROP_IGNORE_ERRORS,
282 g_param_spec_boolean("ignore-errors", _("Ignore errors"),
283 _("Do not warn the user about Z-machine errors"), FALSE,
284 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
286 g_object_class_install_property(object_class, PROP_TYPO_CORRECTION,
287 g_param_spec_boolean("typo-correction", _("Typo correction"),
288 _("Try to remedy typos if the interpreter supports it"), TRUE,
289 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
291 g_object_class_install_property(object_class, PROP_INTERPRETER_NUMBER,
292 g_param_spec_uint("interpreter-number", _("Interpreter number"),
293 _("Platform the Z-machine should pretend it is running on"),
294 CHIMARA_IF_ZMACHINE_DEFAULT, CHIMARA_IF_ZMACHINE_MAXVAL, CHIMARA_IF_ZMACHINE_DEFAULT,
295 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
297 g_object_class_install_property(object_class, PROP_RANDOM_SEED,
298 g_param_spec_int("random-seed", _("Random seed"),
299 _("Seed for the random number generator"), G_MININT, G_MAXINT, 0,
300 G_PARAM_READWRITE | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
302 g_object_class_install_property(object_class, PROP_RANDOM_SEED_SET,
303 g_param_spec_boolean("random-seed-set", _("Random seed set"),
304 _("Whether the seed for the random number generator should be set manually"), FALSE,
305 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_LAX_VALIDATION | G_PARAM_STATIC_STRINGS));
308 g_type_class_add_private(klass, sizeof(ChimaraIFPrivate));
311 /* PUBLIC FUNCTIONS */
316 * Creates and initializes a new #ChimaraIF widget.
318 * Return value: a #ChimaraIF widget, with a floating reference.
323 /* This is a library entry point; initialize the library */
325 return GTK_WIDGET(g_object_new(CHIMARA_TYPE_IF, NULL));
329 chimara_if_set_preferred_interpreter(ChimaraIF *self, ChimaraIFFormat format, ChimaraIFInterpreter interpreter)
331 g_return_if_fail(self && CHIMARA_IS_IF(self));
332 g_return_if_fail(format < CHIMARA_IF_NUM_FORMATS);
333 g_return_if_fail(format < CHIMARA_IF_NUM_INTERPRETERS);
335 CHIMARA_IF_USE_PRIVATE(self, priv);
337 if(supported_formats[format][interpreter])
338 priv->preferred_interpreter[format] = interpreter;
340 g_warning("Format '%s' is not supported by interpreter '%s'", format_names[format], interpreter_names[interpreter]);
344 chimara_if_get_preferred_interpreter(ChimaraIF *self, ChimaraIFFormat format)
346 g_return_val_if_fail(self && CHIMARA_IS_IF(self), -1);
347 g_return_val_if_fail(format < CHIMARA_IF_NUM_FORMATS, -1);
348 CHIMARA_IF_USE_PRIVATE(self, priv);
349 return priv->preferred_interpreter[format];
353 chimara_if_run_game(ChimaraIF *self, gchar *gamefile, GError **error)
355 g_return_val_if_fail(self && CHIMARA_IS_IF(self), FALSE);
356 g_return_val_if_fail(gamefile, FALSE);
358 CHIMARA_IF_USE_PRIVATE(self, priv);
360 /* Find out what format the game is */
361 /* TODO: Look inside the file instead of just looking at the extension */
362 ChimaraIFFormat format = CHIMARA_IF_FORMAT_Z5;
363 if(g_str_has_suffix(gamefile, ".z5"))
364 format = CHIMARA_IF_FORMAT_Z5;
365 else if(g_str_has_suffix(gamefile, ".z6"))
366 format = CHIMARA_IF_FORMAT_Z6;
367 else if(g_str_has_suffix(gamefile, ".z8"))
368 format = CHIMARA_IF_FORMAT_Z8;
369 else if(g_str_has_suffix(gamefile, ".zlb") || g_str_has_suffix(gamefile, ".zblorb"))
370 format = CHIMARA_IF_FORMAT_Z_BLORB;
371 else if(g_str_has_suffix(gamefile, ".ulx"))
372 format = CHIMARA_IF_FORMAT_GLULX;
373 else if(g_str_has_suffix(gamefile, ".blb") || g_str_has_suffix(gamefile, ".blorb") || g_str_has_suffix(gamefile, ".glb") || g_str_has_suffix(gamefile, ".gblorb"))
374 format = CHIMARA_IF_FORMAT_GLULX_BLORB;
376 /* Now decide what interpreter to use */
377 ChimaraIFInterpreter interpreter = priv->preferred_interpreter[format];
378 gchar *pluginfile = g_strconcat(plugin_names[interpreter], "." G_MODULE_SUFFIX, NULL);
380 /* If there is a plugin in the source tree, use that */
381 gchar *pluginpath = g_build_filename("..", "interpreters", plugin_names[interpreter], LT_OBJDIR, pluginfile, NULL);
382 if( !g_file_test(pluginpath, G_FILE_TEST_EXISTS) )
385 pluginpath = g_build_filename(PLUGINDIR, pluginfile, NULL);
386 if( !g_file_test(pluginpath, G_FILE_TEST_EXISTS) )
390 g_set_error(error, CHIMARA_ERROR, CHIMARA_PLUGIN_NOT_FOUND, _("No appropriate %s interpreter plugin was found"), interpreter_names[interpreter]);
396 /* Decide what arguments to pass to the interpreters; currently only the
397 Z-machine interpreters accept command line arguments other than the game */
399 gchar *terpnumstr = NULL, *randomstr = NULL;
400 args = g_slist_prepend(args, pluginpath);
401 args = g_slist_prepend(args, gamefile);
404 case CHIMARA_IF_INTERPRETER_FROTZ:
405 if(priv->flags & CHIMARA_IF_PIRACY_MODE)
406 args = g_slist_prepend(args, "-P");
407 if(priv->flags & CHIMARA_IF_TANDY_BIT)
408 args = g_slist_prepend(args, "-t");
409 if(priv->flags & CHIMARA_IF_EXPAND_ABBREVIATIONS)
410 args = g_slist_prepend(args, "-x");
411 if(priv->flags & CHIMARA_IF_IGNORE_ERRORS)
412 args = g_slist_prepend(args, "-i");
413 if(priv->interpreter_number != CHIMARA_IF_ZMACHINE_DEFAULT)
415 terpnumstr = g_strdup_printf("-I%u", priv->interpreter_number);
416 args = g_slist_prepend(args, terpnumstr);
418 if(priv->random_seed_set)
420 randomstr = g_strdup_printf("-s%d", priv->random_seed);
421 args = g_slist_prepend(args, randomstr);
424 case CHIMARA_IF_INTERPRETER_NITFOL:
425 if(priv->flags & CHIMARA_IF_PIRACY_MODE)
426 args = g_slist_prepend(args, "-pirate");
427 if(priv->flags & CHIMARA_IF_TANDY_BIT)
428 args = g_slist_prepend(args, "-tandy");
429 if(!(priv->flags & CHIMARA_IF_EXPAND_ABBREVIATIONS))
430 args = g_slist_prepend(args, "-no-expand");
431 if(priv->flags & CHIMARA_IF_IGNORE_ERRORS)
432 args = g_slist_prepend(args, "-ignore");
433 if(!(priv->flags & CHIMARA_IF_TYPO_CORRECTION))
434 args = g_slist_prepend(args, "-no-spell");
435 if(priv->interpreter_number != CHIMARA_IF_ZMACHINE_DEFAULT)
437 terpnumstr = g_strdup_printf("-terpnum%u", priv->interpreter_number);
438 args = g_slist_prepend(args, terpnumstr);
440 if(priv->random_seed_set)
442 randomstr = g_strdup_printf("-random%d", priv->random_seed);
443 args = g_slist_prepend(args, randomstr);
450 /* Allocate argv to hold the arguments */
451 int argc = g_slist_length(args);
452 args = g_slist_prepend(args, NULL);
453 char **argv = g_new0(char *, argc + 1);
456 args = g_slist_reverse(args);
459 for(count = 0, ptr = args; ptr; count++, ptr = g_slist_next(ptr))
460 argv[count] = ptr->data;
462 gboolean retval = chimara_glk_run(CHIMARA_GLK(self), pluginpath, argc, argv, error);
470 /* Set current format and interpreter if plugin was started successfully */
473 priv->format = format;
474 priv->interpreter = interpreter;