int display_wood(void) { m_hide(); v_box(3,0,190,40,198,140); v_box(3,2,190,40,198,40+men.wood*10); m_show(); }
static void game_draw(context *ctx) { struct game_context *game = (struct game_context *)ctx; struct config_info *conf = get_config(); struct world *mzx_world = ctx->world; // No game state change has happened (yet) mzx_world->change_game_state = CHANGE_STATE_NONE; if(game->is_title && game->fade_in) { // Focus on center int x, y; set_screen_coords(640/2, 350/2, &x, &y); focus_pixel(x, y); } if(!mzx_world->active) { // There is no MZX_SPEED to derive a framerate from, so use the UI rate. set_context_framerate_mode(ctx, FRAMERATE_UI); if(!conf->standalone_mode) draw_intro_mesg(mzx_world); m_show(); return; } set_context_framerate_mode(ctx, FRAMERATE_MZX_SPEED); update_world(ctx, game->is_title); draw_world(ctx, game->is_title); }
int kill_greble( int x, int y, int m, int viewx, int viewy ) { if( men.wood > 0 & map[m].greble!=COLONIST/*6*/ ) { int xpos = ( x - viewx ) * LEN1/*16*/; int ypos = ( y - viewy ) * LEN1/*16*/; map[m].greble = 0; men.wood--; cond_hide( xpos, ypos); v_putsprite( fight, xpos, ypos, LEN1, LEN1 /*16, 16*/, 0 ); m_show(); delay(FIGHT_DELAY/*1000*/); display_tera( xpos, ypos, map[m].tera ); displaymen( viewx, viewy ); display_wood(); } if( map[m].greble==COLONIST/*6*/ & map[m].food > 6 & men.wood < MAX_WOOD /*10*/ ) { men.wood = men.wood + 1; map[m].food = map[m].food - 3; display_wood(); } }
int displayall(void) { int x ,y ,m, grebles=0, home=0; m_hide(); v_box( 15, 0, 49, 49, 150, 170 ); for(x=0; x<DIM_X/*60*/; x++) { for(y=0; y<DIM_Y/*30*/; y++) { m = x * DIM_Y/*30*/ + y; if(map[m].tera > 0) { v_box( 1, 0, 50+y*2, 50+x*2, 51+y*2, 51+x*2 ); } if(map[m].greble > 0 & map[m].greble!=COLONIST/*6*/) { v_box( 2, 0, 50+y*2, 50+x*2, 51+y*2, 51+x*2 ); grebles++; } if(map[m].greble==COLONIST/*6*/) { v_box( 3, 0, 50+y*2, 50+x*2, 51+y*2, 51+x*2 ); home++; } } } v_box( 4, 0, 50+men.y*2, 50+men.x*2, 51+men.y*2, 51+men.x*2 ); v_cprintf( 36, 0, 60, 115, 1, 0, "%i Grebles", grebles ); v_cprintf( 36, 0, 60, 135, 1, 0, "%i Homes", home ); bioskey(0); m_show(); if(grebles==0) { return(1); } else { return(0); } }
static bool reissue_connection(struct config_info *conf, struct host **h, char *host_name) { bool ret = false; int buf_len; assert(h != NULL); /* We might be passed an existing socket. If we have been, close * and destroy the associated host, and create a new one. */ if(*h) host_destroy(*h); *h = host_create(HOST_TYPE_TCP, HOST_FAMILY_IPV4); if(!*h) { error("Failed to create TCP client socket.", 1, 8, 0); goto err_out; } m_hide(); buf_len = snprintf(widget_buf, WIDGET_BUF_LEN, "Connecting to \"%s\". Please wait..", host_name); widget_buf[WIDGET_BUF_LEN - 1] = 0; draw_window_box(3, 11, 76, 13, DI_MAIN, DI_DARK, DI_CORNER, 1, 1); write_string(widget_buf, (WIDGET_BUF_LEN - buf_len) >> 1, 12, DI_TEXT, 0); update_screen(); if(!host_connect(*h, host_name, OUTBOUND_PORT)) { buf_len = snprintf(widget_buf, WIDGET_BUF_LEN, "Connection to \"%s\" failed.", host_name); widget_buf[WIDGET_BUF_LEN - 1] = 0; error(widget_buf, 1, 8, 0); } else ret = true; clear_screen(32, 7); m_show(); update_screen(); err_out: return ret; }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RimWellLogTrack::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) { if (changedField == &m_show) { if (m_wellLogTrackPlotWidget) { m_wellLogTrackPlotWidget->setVisible(m_show()); } RimWellLogPlot* wellLogPlot; this->firstAnchestorOrThisOfType(wellLogPlot); if (wellLogPlot) { wellLogPlot->calculateAvailableDepthRange(); wellLogPlot->updateDepthZoom(); if (wellLogPlot->viewer()) wellLogPlot->viewer()->updateChildrenLayout(); } } else if (changedField == &m_visibleXRangeMin || changedField == &m_visibleXRangeMax) { m_wellLogTrackPlotWidget->setXRange(m_visibleXRangeMin, m_visibleXRangeMax); m_wellLogTrackPlotWidget->replot(); m_isAutoScaleXEnabled = false; } else if (changedField == &m_isAutoScaleXEnabled) { if (m_isAutoScaleXEnabled()) { this->zoomAllXAxisIfAutoScale(); computeAndSetXRangeMinForLogarithmicScale(); if (m_wellLogTrackPlotWidget) m_wellLogTrackPlotWidget->replot(); } } else if (changedField == &m_isLogarithmicScaleEnabled) { updateAxisScaleEngine(); this->zoomAllXAxisIfAutoScale(); computeAndSetXRangeMinForLogarithmicScale(); m_wellLogTrackPlotWidget->setXRange(m_visibleXRangeMin, m_visibleXRangeMax); m_wellLogTrackPlotWidget->replot(); } }
int displaymen( int viewx, int viewy ) { int x, y, m; x = ( men.x - viewx ) * LEN1 /*16*/; y = ( men.y - viewy ) * LEN1 /*16*/; cond_hide( x, y ); if(men.boat == 0) { v_putsprite( unit, x, y, LEN1, LEN1 /*16, 16*/, 0); } else { v_putsprite( boat, x, y, LEN1, LEN1 /*16, 16*/, 0); } m_show(); }
int eattree( int x, int y, int m, int viewx, int viewy ) { int xpos = ( x - viewx ) * LEN1/*16*/; int ypos = ( y - viewy ) * LEN1/*16*/; if( men.wood < MAX_WOOD/*10*/ & ( map[m].tera == LAND/*5*/ | map[m].tera == FENCE/*16*/ ) ) { men.wood++; map[m].food = map[m].food - TREE/*40*/; cond_hide(xpos, ypos); v_putsprite( fight, xpos, ypos, LEN1, LEN1 /*16, 16*/ , 0 ); m_show(); delay(FIGHT_DELAY/*1000*/); display_tera( xpos, ypos, map[m].tera ); displaymen( viewx, viewy ); display_wood(); } }
int display_greble( uint x, uint y, uint m ) { cond_hide( x, y); switch(map[m].greble) { case 0: if(map[m].food == TREE/*40*/ & (map[m].tera == LAND/*5*/ | map[m].tera == FENCE/*16*/) ) { v_putsprite( tree, x+4, y+4, 8, 8, 0 ); } break; case 1: v_putsprite( greble1, x + 4, y + 4, 8, 8, 0 ); break; case 2: v_putsprite( greble2, x + 4, y + 4, 8, 8, 0 ); break; case 3: v_putsprite( greble3, x + 4, y + 4, 8, 8, 0 ); break; case 4: v_putsprite( greble4, x + 4, y + 4, 8, 8, 0 ); break; case 5: v_putsprite( greble5, x + 4, y + 4, 8, 8, 0 ); break; case 6: v_putsprite( home, x + 4, y + 4, 8, 8, 0 ); break; } m_show(); }
int error(const char *string, unsigned int type, unsigned int options, unsigned int code) { const char *type_name; int t1 = 9, ret = 0; char temp[5]; int x; // Find the name of this error type. if(type >= sizeof(error_type_names) / sizeof(*error_type_names)) type = 0; type_name = error_type_names[type]; // If graphics couldn't initialize, print the error to stderr and abort. if(!has_video_initialized()) { fprintf(stderr, "%s%s\n", type_name, string); exit(-1); } // Window set_context(code >> 8); m_hide(); save_screen(); dialog_fadein(); draw_window_box(1, 10, 78, 14, 76, 64, 72, 1, 1); // Add title and error name x = 40 - (int)strlen(type_name)/2; write_string(type_name, x, 10, 78, 0); write_string(string, 40 - ((Uint32)strlen(string) / 2), 11, 79, 0); // Add options write_string("Press", 4, 13, 78, 0); if(options & ERROR_OPT_FAIL) { write_string(", F for Fail", t1, 13, 78, 0); t1 += 12; } if(options & ERROR_OPT_RETRY) { write_string(", R to Retry", t1, 13, 78, 0); t1 += 12; } if(options & ERROR_OPT_EXIT) { write_string(", E to Exit", t1, 13, 78, 0); t1 += 11; } if(options & ERROR_OPT_OK) { write_string(", O for OK", t1, 13, 78, 0); t1 += 10; } draw_char('.', 78, t1, 13); draw_char(':', 78, 9, 13); // Add code if not 0 if(code != 0) { write_string(" Debug code:0000h ", 30, 14, 64, 0); sprintf(temp, "%x", code); write_string(temp, 46 - (Uint32)strlen(temp), 14, 64, 0); } update_screen(); // Get key do { wait_event(); t1 = get_key(keycode_internal); //Process switch(t1) { case IKEY_f: fail: if(!(options & ERROR_OPT_FAIL)) break; ret = ERROR_OPT_FAIL; break; case IKEY_r: retry: if(!(options & ERROR_OPT_RETRY)) break; ret = ERROR_OPT_RETRY; break; case IKEY_e: exit: if(!(options & ERROR_OPT_EXIT)) break; ret = ERROR_OPT_EXIT; break; case IKEY_o: ok: if(!(options & ERROR_OPT_OK)) break; ret = ERROR_OPT_OK; break; case IKEY_h: if(!(options & ERROR_OPT_HELP)) break; // Call help break; case IKEY_ESCAPE: // Escape. Order of options this applies to- // Fail, Ok, Retry, Exit. if(options & ERROR_OPT_FAIL ) goto fail; if(options & ERROR_OPT_OK ) goto ok; if(options & ERROR_OPT_RETRY) goto retry; goto exit; case IKEY_RETURN: // Enter. Order of options this applies to- // OK, Retry, Fail, Exit. if(options & ERROR_OPT_OK ) goto ok; if(options & ERROR_OPT_RETRY) goto retry; if(options & ERROR_OPT_FAIL ) goto fail; goto exit; } } while(ret == 0); pop_context(); // Restore screen and exit appropriately dialog_fadeout(); restore_screen(); m_show(); if(ret == ERROR_OPT_EXIT) // Exit the program { platform_quit(); exit(-1); } return ret; }
static void __check_for_updates(struct world *mzx_world, struct config_info *conf) { int cur_host; char *update_host; bool try_next_host = true; bool ret = false; set_context(CTX_UPDATER); if(conf->update_host_count < 1) { error("No updater hosts defined! Aborting.", 1, 8, 0); goto err_out; } if(!swivel_current_dir(true)) goto err_out; for(cur_host = 0; (cur_host < conf->update_host_count) && try_next_host; cur_host++) { char **list_entries, buffer[LINE_BUF_LEN], *url_base, *value; struct manifest_entry *removed, *replaced, *added, *e; int i = 0, entries = 0, buf_len, result; char update_branch[LINE_BUF_LEN]; const char *version = VERSION; int list_entry_width = 0; enum host_status status; struct host *h = NULL; unsigned int retries; FILE *f; // Acid test: Can we write to this directory? f = fopen_unsafe(UPDATES_TXT, "w+b"); if(!f) { error("Failed to create \"" UPDATES_TXT "\". Check permissions.", 1, 8, 0); goto err_chdir; } update_host = conf->update_hosts[cur_host]; if(!reissue_connection(conf, &h, update_host)) goto err_host_destroy; for(retries = 0; retries < MAX_RETRIES; retries++) { // Grab the file containing the names of the current Stable and Unstable status = host_recv_file(h, "/" UPDATES_TXT, f, "text/plain"); rewind(f); if(status == HOST_SUCCESS) break; if(!reissue_connection(conf, &h, update_host)) goto err_host_destroy; } if(retries == MAX_RETRIES) { snprintf(widget_buf, WIDGET_BUF_LEN, "Failed to download \"" UPDATES_TXT "\" (err=%d).\n", status); widget_buf[WIDGET_BUF_LEN - 1] = 0; error(widget_buf, 1, 8, 0); goto err_host_destroy; } snprintf(update_branch, LINE_BUF_LEN, "Current-%s", conf->update_branch_pin); // Walk this list (of two, hopefully) while(true) { char *m = buffer, *key; value = NULL; // Grab a single line from the manifest if(!fgets(buffer, LINE_BUF_LEN, f)) break; key = strsep(&m, ":\n"); if(!key) break; value = strsep(&m, ":\n"); if(!value) break; if(strcmp(key, update_branch) == 0) break; } fclose(f); unlink(UPDATES_TXT); /* There was no "Current-XXX: Version" found; we cannot proceed with the * update because we cannot compute an update URL below. */ if(!value) { error("Failed to identify applicable update version.", 1, 8, 0); goto err_host_destroy; } /* There's likely to be a space prepended to the version number. * Skip it here. */ if(value[0] == ' ') value++; /* We found the latest update version, but we should check to see if that * matches the version we're already using. The user may choose to receive * "stability" updates for their current major version, or upgrade to the * newest one. */ if(strcmp(value, version) != 0) { struct element *elements[6]; struct dialog di; buf_len = snprintf(widget_buf, WIDGET_BUF_LEN, "A new major version is available (%s)", value); widget_buf[WIDGET_BUF_LEN - 1] = 0; elements[0] = construct_label((55 - buf_len) >> 1, 2, widget_buf); elements[1] = construct_label(2, 4, "You can continue to receive updates for the version\n" "installed (if available), or you can upgrade to the\n" "newest major version (recommended)."); elements[2] = construct_label(2, 8, "If you do not upgrade, this question will be asked\n" "again the next time you run the updater.\n"); elements[3] = construct_button(9, 11, "Upgrade", 0); elements[4] = construct_button(21, 11, "Update Old", 1); elements[5] = construct_button(36, 11, "Cancel", 2); construct_dialog(&di, "New Major Version", 11, 6, 55, 14, elements, 6, 3); result = run_dialog(mzx_world, &di); destruct_dialog(&di); // User pressed Escape, abort all updates if(result < 0 || result == 2) { try_next_host = false; goto err_host_destroy; } // User pressed Upgrade, use new major if(result == 0) version = value; } /* We can now compute a unique URL base for the updater. This will * be composed of a user-selected version and a static platform-archicture * name. */ url_base = cmalloc(LINE_BUF_LEN); snprintf(url_base, LINE_BUF_LEN, "/%s/" PLATFORM, version); debug("Update base URL: %s\n", url_base); /* The call to manifest_get_updates() destroys any existing manifest * file in this directory. Since we still allow user to abort after * this call, and downloading the updates may fail, we copy the * old manifest to a backup location and optionally restore it later. */ if(!backup_original_manifest()) { error("Failed to back up manifest. Check permissions.", 1, 8, 0); try_next_host = false; goto err_free_url_base; } for(retries = 0; retries < MAX_RETRIES; retries++) { bool m_ret; m_hide(); draw_window_box(3, 11, 76, 13, DI_MAIN, DI_DARK, DI_CORNER, 1, 1); write_string("Computing manifest deltas (added, replaced, deleted)..", 13, 12, DI_TEXT, 0); update_screen(); m_ret = manifest_get_updates(h, url_base, &removed, &replaced, &added); clear_screen(32, 7); m_show(); update_screen(); if(m_ret) break; if(!reissue_connection(conf, &h, update_host)) goto err_roll_back_manifest; } if(retries == MAX_RETRIES) { error("Failed to compute update manifests", 1, 8, 0); goto err_roll_back_manifest; } // At this point, we have a successful manifest, so we won't need another host try_next_host = false; if(!removed && !replaced && !added) { struct element *elements[3]; struct dialog di; elements[0] = construct_label(2, 2, "This client is already current."); elements[1] = construct_button(7, 4, "OK", 0); elements[2] = construct_button(13, 4, "Try next host", 1); construct_dialog(&di, "No Updates", 22, 9, 35, 6, elements, 3, 1); result = run_dialog(mzx_world, &di); destruct_dialog(&di); if((result == 1) && (cur_host < conf->update_host_count)) try_next_host = true; goto err_free_update_manifests; } for(e = removed; e; e = e->next, entries++) list_entry_width = MAX(list_entry_width, 2 + (int)strlen(e->name)+1+1); for(e = replaced; e; e = e->next, entries++) list_entry_width = MAX(list_entry_width, 2 + (int)strlen(e->name)+1+1); for(e = added; e; e = e->next, entries++) list_entry_width = MAX(list_entry_width, 2 + (int)strlen(e->name)+1+1); // We don't want the listbox to be too wide list_entry_width = MIN(list_entry_width, 60); list_entries = cmalloc(entries * sizeof(char *)); for(e = removed; e; e = e->next, i++) { list_entries[i] = cmalloc(list_entry_width); snprintf(list_entries[i], list_entry_width, "- %s", e->name); list_entries[i][list_entry_width - 1] = 0; } for(e = replaced; e; e = e->next, i++) { list_entries[i] = cmalloc(list_entry_width); snprintf(list_entries[i], list_entry_width, "* %s", e->name); list_entries[i][list_entry_width - 1] = 0; } for(e = added; e; e = e->next, i++) { list_entries[i] = cmalloc(list_entry_width); snprintf(list_entries[i], list_entry_width, "+ %s", e->name); list_entries[i][list_entry_width - 1] = 0; } draw_window_box(19, 1, 59, 4, DI_MAIN, DI_DARK, DI_CORNER, 1, 1); write_string(" Task Summary ", 33, 1, DI_TITLE, 0); write_string("ESC - Cancel [+] Add [-] Delete", 21, 2, DI_TEXT, 0); write_string("ENTER - Proceed [*] Replace ", 21, 3, DI_TEXT, 0); result = list_menu((const char **)list_entries, list_entry_width, NULL, 0, entries, ((80 - (list_entry_width + 9)) >> 1) + 1, 4); for(i = 0; i < entries; i++) free(list_entries[i]); free(list_entries); clear_screen(32, 7); update_screen(); if(result < 0) goto err_free_update_manifests; /* Defer deletions until we restart; any of these files may still be * in use by this (old) process. Reduce the number of entries by the * number of removed items for the progress meter below. */ for(e = removed; e; e = e->next, entries--) delete_hook(e->name); /* Since the operations for adding and replacing a file are identical, * we modify the replaced list and tack on the added list to the end. * * Either list may be NULL; in the case that `replaced' is NULL, simply * re-assign the `added' pointer. `added' being NULL has no effect. * * Later, we need only free the replaced list (see below). */ if(replaced) { for(e = replaced; e->next; e = e->next) ; e->next = added; } else replaced = added; cancel_update = false; host_set_callbacks(h, NULL, recv_cb, cancel_cb); i = 1; for(e = replaced; e; e = e->next, i++) { for(retries = 0; retries < MAX_RETRIES; retries++) { char name[72]; bool m_ret; if(!check_create_basedir(e->name)) goto err_free_delete_list; final_size = (long)e->size; m_hide(); snprintf(name, 72, "%s (%ldb) [%u/%u]", e->name, final_size, i, entries); meter(name, 0, final_size); update_screen(); m_ret = manifest_entry_download_replace(h, url_base, e, delete_hook); clear_screen(32, 7); m_show(); update_screen(); if(m_ret) break; if(cancel_update) { error("Download was cancelled; update aborted.", 1, 8, 0); goto err_free_delete_list; } if(!reissue_connection(conf, &h, update_host)) goto err_free_delete_list; host_set_callbacks(h, NULL, recv_cb, cancel_cb); } if(retries == MAX_RETRIES) { snprintf(widget_buf, WIDGET_BUF_LEN, "Failed to download \"%s\" (after %d attempts).", e->name, retries); widget_buf[WIDGET_BUF_LEN - 1] = 0; error(widget_buf, 1, 8, 0); goto err_free_delete_list; } } if(delete_list) { f = fopen_unsafe(DELETE_TXT, "wb"); if(!f) { error("Failed to create \"" DELETE_TXT "\". Check permissions.", 1, 8, 0); goto err_free_delete_list; } for(e = delete_list; e; e = e->next) { fprintf(f, "%08x%08x%08x%08x%08x%08x%08x%08x %lu %s\n", e->sha256[0], e->sha256[1], e->sha256[2], e->sha256[3], e->sha256[4], e->sha256[5], e->sha256[6], e->sha256[7], e->size, e->name); } fclose(f); } try_next_host = false; ret = true; err_free_delete_list: manifest_list_free(&delete_list); delete_list = delete_p = NULL; err_free_update_manifests: manifest_list_free(&removed); manifest_list_free(&replaced); err_roll_back_manifest: restore_original_manifest(ret); err_free_url_base: free(url_base); err_host_destroy: host_destroy(h); pop_context(); } //end host for loop err_chdir: swivel_current_dir_back(true); err_out: /* At this point we found updates and we successfully updated * to them. Reload the program with the original argv. */ if(ret) { const void *argv = process_argv; struct element *elements[2]; struct dialog di; elements[0] = construct_label(2, 2, "This client will now attempt to restart itself."); elements[1] = construct_button(23, 4, "OK", 0); construct_dialog(&di, "Update Successful", 14, 9, 51, 6, elements, 2, 1); run_dialog(mzx_world, &di); destruct_dialog(&di); execv(process_argv[0], argv); perror("execv"); error("Attempt to invoke self failed!", 1, 8, 0); return; } }
int main(int argc, char **argv) { SCANNED_ARG *s_arg; SDDS_DATASET inputPage, outputPage; char *inputfile, *outputfile; char **inputColumnName, **inputStringColumnName, **inputDoubleColumnName; char **outputStringColumnName, **outputDoubleColumnName, **matchColumn=NULL; long inputRows, inputDoubleColumns, inputStringColumns, indexColumn=0, matchColumns=0, noOldColumnNamesColumn=0; long outputRows, outputDoubleColumns, outputStringColumns; char **inputParameterName; int32_t inputParameters, inputColumns; char *inputDescription, *inputContents; char *outputDescription; long i, i_arg, col; char *buffer; char **columnOfStrings; long buffer_size; #define BUFFER_SIZE_INCREMENT 16384 MATRIX *R, *RInv; long OldStringColumnsDefined; char *inputStringRows, *outputStringRows; char **stringArray, *stringParameter; long token_length; long verbose; char format[32]; long digits; char *Symbol, *Root; void *parameterPointer; long ascii; unsigned long pipeFlags, majorOrderFlag; long tmpfile_used, noWarnings; long ipage=0, columnType; char *oldColumnNames, *newColumnNamesColumn; short columnMajorOrder=-1; inputColumnName = outputStringColumnName = outputDoubleColumnName = inputParameterName = NULL; outputRows = outputDoubleColumns = outputStringColumns = OldStringColumnsDefined = 0; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc==1) bomb(NULL, USAGE); inputfile = outputfile = NULL; verbose = 0; Symbol = Root = NULL; ascii = 0; digits=3; pipeFlags = 0; tmpfile_used = 0; noWarnings = 0; oldColumnNames = NULL; newColumnNamesColumn = NULL; for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { switch(match_string(s_arg[i_arg].list[0], commandline_option, COMMANDLINE_OPTIONS, UNIQUE_MATCH)) { case CLO_MAJOR_ORDER: majorOrderFlag=0; s_arg[i_arg].n_items--; if (s_arg[i_arg].n_items>0 && (!scanItemList(&majorOrderFlag, s_arg[i_arg].list+1, &s_arg[i_arg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) SDDS_Bomb("invalid -majorOrder syntax/values"); if (majorOrderFlag&SDDS_COLUMN_MAJOR_ORDER) columnMajorOrder=1; else if (majorOrderFlag&SDDS_ROW_MAJOR_ORDER) columnMajorOrder=0; break; case CLO_MATCH_COLUMN: matchColumns = s_arg[i_arg].n_items-1; matchColumn = s_arg[i_arg].list+1; break; case CLO_INDEX_COLUMN: indexColumn = 1; break; case CLO_NO_OLDCOLUMNNAMES: noOldColumnNamesColumn = 1; break; case CLO_VERBOSE: verbose=1; break; case CLO_ASCII: ascii=1; break; case CLO_DIGITS: if (!(get_long(&digits, s_arg[i_arg].list[1]))) bomb("no string given for option -digits", USAGE); break; case CLO_COLUMNROOT: if (!(Root=s_arg[i_arg].list[1])) SDDS_Bomb("No root string given"); break; case CLO_SYMBOL: if (!(Symbol=s_arg[i_arg].list[1])) SDDS_Bomb("No symbol string given"); break; case CLO_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case CLO_OLDCOLUMNNAMES: if (!(oldColumnNames=s_arg[i_arg].list[1])) SDDS_Bomb("No oldColumnNames string given"); break; case CLO_NEWCOLUMNNAMES: if (s_arg[i_arg].n_items!=2 || SDDS_StringIsBlank(newColumnNamesColumn = s_arg[i_arg].list[1])) SDDS_Bomb("Invalid -newColumnNames syntax/value"); break; default: bomb("unrecognized option given", USAGE); } } else { if (!inputfile) inputfile = s_arg[i_arg].list[0]; else if (!outputfile) outputfile = s_arg[i_arg].list[0]; else bomb("too many filenames given", USAGE); } } processFilenames("sddstranpose", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used); if (newColumnNamesColumn && Root) SDDS_Bomb("-root and -newColumnNames are incompatible"); if (!SDDS_InitializeInput(&inputPage, inputfile) || !(inputParameterName=(char**)SDDS_GetParameterNames(&inputPage, &inputParameters)) || !SDDS_GetDescription(&inputPage, &inputDescription, &inputContents)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); if (matchColumns) inputColumnName = getMatchingSDDSNames(&inputPage, matchColumn, matchColumns, &inputColumns, SDDS_MATCH_COLUMN); else { if (!(inputColumnName=(char**)SDDS_GetColumnNames(&inputPage, &inputColumns))) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } inputDoubleColumns=0; inputStringColumns=0; inputDoubleColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputStringColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputRows = 0; /*********** \ * read data * \***********/ while (0<SDDS_ReadTable(&inputPage)) { ipage ++; #if defined(DEBUG) fprintf(stderr, "working on page %ld\n", ipage); #endif if (ipage==1) { SDDS_DeferSavingLayout(1); if( !SDDS_SetColumnFlags(&inputPage, 0)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); /* count the string and numerical columns in the input file */ for (i=0;i<inputColumns;i++) { if ( SDDS_NUMERIC_TYPE( columnType = SDDS_GetColumnType( &inputPage, i))) { inputDoubleColumnName[inputDoubleColumns]=inputColumnName[i]; inputDoubleColumns++; } } for (i=0; i<inputPage.layout.n_columns; i++) { if (inputPage.layout.column_definition[i].type == SDDS_STRING ) { inputStringColumnName[inputStringColumns] = inputPage.layout.column_definition[i].name; inputStringColumns++; } } if( !(inputRows=SDDS_CountRowsOfInterest(&inputPage))) SDDS_Bomb("No rows in dataset."); } else { /* these statements are executed on the subsequent pages */ if (inputRows != SDDS_CountRowsOfInterest(&inputPage)) { SDDS_Bomb("Datasets don't have the same number of rows.\nProcessing stopped before reaching the end of the input file."); } } #if defined(DEBUG) fprintf(stderr, "row flags set\n"); #endif if (inputDoubleColumns == 0) SDDS_Bomb("No numerical columns in file."); if ((ipage==1) && verbose) { fprintf(stderr, "No. of double/float/integer columns: %ld.\n", inputDoubleColumns); fprintf(stderr, "No. of string columns: %ld.\n", inputStringColumns); fprintf(stderr, "No. of rows: %ld.\n", inputRows); } /****************\ * transpose data * \****************/ if (inputDoubleColumns) { if (ipage == 1) { m_alloc(&RInv, inputRows, inputDoubleColumns); m_alloc(&R, inputDoubleColumns, inputRows); } for (col=0;col<inputDoubleColumns;col++){ if (!(R->a[col]=(double*)SDDS_GetColumnInDoubles(&inputPage, inputDoubleColumnName[col]))) { SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (verbose) { m_show(R, "%9.6le ", "Transpose of input matrix:\n", stdout); } m_trans(RInv, R); } /***************************\ * determine existence of * * transposed string columns * \***************************/ if (ipage == 1) { OldStringColumnsDefined=0; switch(SDDS_CheckParameter(&inputPage, OLD_STRING_COLUMN_NAMES, NULL, SDDS_STRING, NULL)){ case SDDS_CHECK_OKAY: OldStringColumnsDefined=1; break; case SDDS_CHECK_NONEXISTENT: break; case SDDS_CHECK_WRONGTYPE: case SDDS_CHECK_WRONGUNITS: fprintf(stderr, "Something wrong with parameter OldStringColumns.\n"); exit(1); break; } if (OldStringColumnsDefined){ /* decompose OldStringColumns into names of string columns for the output file */ if (!SDDS_GetParameter(&inputPage, OLD_STRING_COLUMN_NAMES, &inputStringRows)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Parameter OldStringColumns: %s.\n", inputStringRows); } outputStringColumnName=(char**)malloc(sizeof(char*)); outputStringColumns=0; buffer_size=BUFFER_SIZE_INCREMENT; buffer=(char*)malloc(sizeof(char)*buffer_size); while ( 0 <= (token_length = SDDS_GetToken(inputStringRows, buffer, BUFFER_SIZE_INCREMENT))){ if (!token_length) SDDS_Bomb("A null string was detected in parameter OldStringColumns.\n"); if (!SDDS_CopyString(&outputStringColumnName[outputStringColumns], buffer)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Output string column: %s\n", outputStringColumnName[outputStringColumns]); } outputStringColumns++; } } } /*********************\ * define output page * \*********************/ if ( ipage == 1 ) { outputRows = inputDoubleColumns; outputDoubleColumns = inputRows; if (inputDescription){ outputDescription = (char*) malloc( sizeof(char) * (strlen("Transpose of ") + strlen(inputDescription) + 1)); strcat(strcpy(outputDescription, "Transpose of "), inputDescription); if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, outputDescription, inputContents, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, NULL, NULL, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (columnMajorOrder!=-1) outputPage.layout.data_mode.column_major = columnMajorOrder; else outputPage.layout.data_mode.column_major = inputPage.layout.data_mode.column_major; /***********************************\ * define names for double columns * \***********************************/ if (!Root && inputStringColumns ) { /* use specified string column, or first string column encountered */ if (!newColumnNamesColumn) /* first string column encountered */ outputDoubleColumnName = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[0]); else { /* use specified string column */ if (SDDS_CheckColumn(&inputPage, newColumnNamesColumn, NULL, SDDS_STRING, stderr)!=SDDS_CHECK_OKAY) SDDS_Bomb("column named with -newColumnNames does not exist in input"); outputDoubleColumnName = (char**)SDDS_GetColumn(&inputPage, newColumnNamesColumn); } for (i=1; i<inputRows; i++) { if (match_string(outputDoubleColumnName[i-1], outputDoubleColumnName+i, inputRows-i, EXACT_MATCH)>=0) { fprintf(stderr, "Error, duplicate %s found in input file string column %s, can not be used as output column names\n", outputDoubleColumnName[i-1], newColumnNamesColumn ? newColumnNamesColumn : inputStringColumnName[0]); exit(1); } } } else { /* use command line options to produce column names in the output file */ outputDoubleColumnName = (char**) malloc( outputDoubleColumns * sizeof(char*) ); digits = MAX(digits, log10(inputRows) + 1); if (!Root){ Root = (char*) malloc( sizeof(char) * (strlen("Column")+1) ); strcpy(Root, "Column"); } if (outputDoubleColumns!=1) { for ( i=0; i < outputDoubleColumns; i++){ outputDoubleColumnName[i] = (char*) malloc( sizeof(char) * (strlen(Root)+digits+1)); sprintf(format, "%s%%0%ldld", Root, digits); sprintf(outputDoubleColumnName[i], format, i); } } else {/* only one row to transpose */ outputDoubleColumnName[0] = (char*) malloc( sizeof(char) * (strlen(Root)+1)); strcpy( outputDoubleColumnName[0], Root); } } /*************************\ * define string columns * \*************************/ if (OldStringColumnsDefined) { if (!SDDS_DefineSimpleColumns(&outputPage, outputStringColumns, outputStringColumnName, NULL, SDDS_STRING)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { /* by default there should be at least one string column, that of the old column names. */ if (!noOldColumnNamesColumn) { outputStringColumns = 1; outputStringColumnName = (char**) malloc( sizeof(char*)); if (oldColumnNames) { /* commanline option specification */ outputStringColumnName[0] = oldColumnNames; } else { outputStringColumnName[0] = (char*) malloc( sizeof(char) * (strlen("OldColumnNames") + 1)); strcpy(outputStringColumnName[0], "OldColumnNames"); } if ( 0 > SDDS_DefineColumn(&outputPage, outputStringColumnName[0], NULL, NULL, NULL, NULL, SDDS_STRING, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (indexColumn && !SDDS_DefineSimpleColumn(&outputPage, "Index", NULL, SDDS_LONG)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /*************************\ * define double columns * \*************************/ for ( i=0; i < outputDoubleColumns; i++) if (Symbol){ if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], Symbol, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /********************************\ * define string parameters * * i.e. transposed string columns * \********************************/ if ( inputStringColumns>1 ) { if (0>SDDS_DefineParameter(&outputPage, OLD_STRING_COLUMN_NAMES, NULL, NULL, "Transposed string columns", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for ( i=0; i < inputStringColumns; i++){ if (0>SDDS_DefineParameter(&outputPage, inputStringColumnName[i], NULL, NULL, "Transposed string column data", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /*************************\ * transfer parameters not * * associated with old * * string columns * \*************************/ if (inputParameters) { for ( i=0; i < inputParameters; i++) { if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) if ( 0 > SDDS_TransferParameterDefinition(&outputPage, &inputPage, inputParameterName[i], NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /***************\ * write layout * \***************/ SDDS_DeferSavingLayout(0); /* if InputFile is not already transfered ot the output file, then create it. */ switch( SDDS_CheckParameter(&outputPage, "InputFile", NULL, SDDS_STRING, NULL) ) { case SDDS_CHECK_NONEXISTENT: if (0>SDDS_DefineParameter(&outputPage, "InputFile", NULL, NULL, "Original matrix file", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; default: break; } if (!SDDS_WriteLayout(&outputPage) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "table layout defined\n"); #endif if (!SDDS_StartTable(&outputPage, outputRows) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (ipage == 1) { if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "InputFile", inputfile?inputfile:"pipe", NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /***************************************\ * assign string columns from input * * to string parameters in output * \**************************************/ if ( inputStringColumns > 1) { for ( i=0; i < inputStringColumns; i++){ columnOfStrings = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[i]); stringParameter = JoinStrings(columnOfStrings, inputRows, BUFFER_SIZE_INCREMENT); if ( !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, inputStringColumnName[i], stringParameter, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(columnOfStrings); free(stringParameter); } outputStringRows = JoinStrings(inputStringColumnName, inputStringColumns, BUFFER_SIZE_INCREMENT); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, OLD_STRING_COLUMN_NAMES, outputStringRows, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string parameters assigned\n"); #endif if (inputParameters){ for ( i=0; i < inputParameters; i++){ if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) { parameterPointer = (void*) SDDS_GetParameter(&inputPage, inputParameterName[i], NULL); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputParameterName[i], parameterPointer, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(parameterPointer); } } } #if defined(DEBUG) fprintf(stderr, "input parameters assigned\n"); #endif /**********************************\ * assign data to * * output table part of data set * \**********************************/ if (outputRows) { /***************************\ * assign string column data * \***************************/ if (OldStringColumnsDefined){ for ( i=0 ; i < outputStringColumns; i++){ if (!SDDS_GetParameter(&inputPage, outputStringColumnName[i], &stringParameter)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); stringArray=TokenizeString(stringParameter, outputRows); if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, stringArray, outputRows, outputStringColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } else { if (!noOldColumnNamesColumn && !SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputDoubleColumnName, outputRows, outputStringColumnName[0])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string data columns assigned\n"); #endif /***************************\ * assign double column data * \***************************/ for ( i=0 ; i < outputDoubleColumns; i++) /* i is the row index */ if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, RInv->a[i], outputRows, outputDoubleColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (indexColumn) { for (i=0; i<outputRows; i++) if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, i, "Index", i, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "double data columns assigned\n"); #endif } #if defined(DEBUG) fprintf(stderr, "data assigned\n"); #endif if (!SDDS_WriteTable(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); #if defined(DEBUG) fprintf(stderr, "data written out\n"); #endif } if (inputDoubleColumns) { m_free(&RInv); m_free(&R); } if (inputColumnName) { SDDS_FreeStringArray(inputColumnName, inputColumns); free(inputColumnName); } if (inputStringColumns) free(inputStringColumnName); if (inputDescription) free(inputDescription); if (inputParameterName) { SDDS_FreeStringArray(inputParameterName, inputParameters); free(inputParameterName); } if (outputDoubleColumns) { SDDS_FreeStringArray(outputDoubleColumnName, outputDoubleColumns); free(outputDoubleColumnName); } if (!SDDS_Terminate(&inputPage) || !SDDS_Terminate(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile)) exit(1); return(0); }
int initial(void) { uint count, land, rounds, x, y, opt; v_setmode13(); m_init(); /* INTRODUCTION */ v_cprintf(45,0,0,0,1,0,"Colony on Greblis (Version 1.2)"); v_cprintf(45,0,0,10,1,0,"(C) Copyright 1995 Peter Harrison"); v_cprintf(54,0,0,30,1,0,"To Start, Type Level Number :"); v_cprintf(54,0,0,40,1,0,"1 - Easy, 2 - Medium, 3 - Hard"); v_cprintf(54,0,0,70,0,0,"ARROW KEYS to Move"); v_cprintf(54,0,0,80,0,0,"INSERT to Fence or Net"); v_cprintf(54,0,0,90,0,0,"HOME to Build Colony"); v_cprintf(54,0,0,100,0,0,"PAGE-UP to View Situation"); v_cprintf(54,0,0,110,0,0,"ESC to Exit"); v_cprintf(54,0,0,130,0,0,"View COLONY.TXT for Help"); v_cprintf(54,0,0,140,0,0,"Internet : [email protected]"); v_putimage(tera16,220,75, 16,16); v_putimage(unit, 240, 85, 16, 16); v_putimage(tera5, 220,95, 16, 16); v_putsprite(tree, 220, 100, 8, 8, 0); v_putsprite(greble1, 228, 95, 8, 8, 0); v_putimage(fight, 240, 105, 16, 16); opt = bioskey(0); switch(opt) { case 561: level = 500000; v_cprintf(45,0,0,181,1,0,"Level Easy :"); break; case 818: level = 200000; v_cprintf(45,0,0,181,1,0,"Level Medium :"); break; case 1075: v_cprintf(45,0,0,181,1,0,"Level Hard :"); level = 50000; break; default : v_cprintf(45,0,0,181,1,0,"Level Novice :"); level = 1000000; break; }; v_cprintf(45,0,0,190,1,0,"Wood"); v_putimage(tera16,220,180, 16,16); v_putimage(unit, 240, 180, 16, 16); v_putimage(tera5, 260,180, 16, 16); v_putsprite(tree, 260, 185, 8, 8, 0); v_putsprite(greble1, 268, 180, 8, 8, 0); v_putimage(fight, 280, 180, 16, 16); display_wood(); m_show(); /* CREATE LAND */ randomize(); for(count=0; count < 1801 ; count++) { map[count].greble = 0; map[count].food = random(MAXFOOD /*50*/); if( random(100) > PROBA_SEA /*55*/) { map[count].tera = LAND /*5*/; } else { map[count].tera = SEA /*0*/; } } /* CLEAN SEA AND LAND */ for(rounds=0; rounds < 1; rounds++ ) { for(count=0; count < DIM /*1801*/; count++) { if( seearound( count, SEA /*0*/ ) < 3 ) map[count].tera = LAND /*5*/; } for(count=0; count < DIM /*1801*/; count++) { if( seearound( count, LAND /*5*/ ) < 3 ) map[count].tera = SEA /*0*/; } } /* PUT EDGE TERRAIN ON MAP */ for(count=0; count<DIM /*1801*/; count++) { land = 0; if( map[count].tera == SEA /*0*/ ) { if( (count+1) < DIM /*1801*/) { if( map[count+1].tera == LAND /*5*/ ) land = land + 1; } if( (count-1) > 0) { if( map[count-1].tera == LAND /*5*/ ) land = land + 2; } if( (count+DIM_Y/*30*/) < DIM /*1801*/) { if( map[count+DIM_Y/*30*/].tera == LAND/*5*/ ) land = land + 4; } if( (count-DIM_Y /*30*/) > 0) { if( map[count-DIM_Y/*30*/].tera == LAND/*5*/ ) land = land + 8; } } switch(land) { case 1: map[count].tera = 2; break; case 2: map[count].tera = 8; break; case 3: map[count].tera = 10; break; case 4: map[count].tera = 4; break; case 5: map[count].tera = 1; break; case 6: map[count].tera = 7; break; case 7: map[count].tera = 14; break; case 8: map[count].tera = 6; break; case 9: map[count].tera = 3; break; case 10: map[count].tera = 9; break; case 11: map[count].tera = 15; break; case 12: map[count].tera = 11; break; case 13: map[count].tera = 12; break; case 14: map[count].tera = 13; break; case 15: map[count].tera = 5; break; } } /* SET UP MEN / UNITS */ #ifdef OLD men.x = random(60); men.y = random(30); men.wood = 0; land = ( men.x * 30 ) + men.y; while( map[land].tera != 5 ) { men.x = random(60); men.y = random(30); land = ( men.x * 30 ) + men.y; } #else do { men.x = random(DIM_X); men.y = random(DIM_Y); land = ( men.x * DIM_Y ) + men.y; } while( map[land].tera != LAND ); #endif /* SET UP GREBLES */ for( count=0; count<N_GREBLES_INIT/*100*/; count++) { x = random(DIM_X/*60*/); y = random(DIM_Y/*30*/); land = ( x * DIM_Y/*30*/ ) + y; if( map[land].tera == SEA/*0*/ ) { map[land].greble = 2; } if( map[land].tera == LAND/*5*/ ) { map[land].greble = 1; } } }
int display_tera( uint x, uint y, uint m ) { cond_hide( x, y); #ifndef OLD v_putimage (tera[m], x, y, LEN1, LEN1); #else switch(m) { case 0: v_putimage( tera0, x, y, 16, 16); break; case 1: v_putimage( tera1, x, y, 16, 16); break; case 2: v_putimage( tera2, x, y, 16, 16); break; case 3: v_putimage( tera3, x, y, 16, 16); break; case 4: v_putimage( tera4, x, y, 16, 16); break; case 5: v_putimage( tera5, x, y, 16, 16); break; case 6: v_putimage( tera6, x, y, 16, 16); break; case 7: v_putimage( tera7, x, y, 16, 16); break; case 8: v_putimage( tera8, x, y, 16, 16); break; case 9: v_putimage( tera9, x, y, 16, 16); break; case 10: v_putimage( tera10, x, y, 16, 16); break; case 11: v_putimage( tera11, x, y, 16, 16); break; case 12: v_putimage( tera12, x, y, 16, 16); break; case 13: v_putimage( tera13, x, y, 16, 16); break; case 14: v_putimage( tera14, x, y, 16, 16); break; case 15: v_putimage( tera15, x, y, 16, 16); break; case 16: v_putimage( tera16, x, y, 16, 16); break; case 17: v_putimage( tera17, x, y, 16, 16); break; } #endif m_show(); }