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();
}
