void create()
{
if(file_exists(ACCOUNT_DATA)) {
restore_object(ACCOUNT_DATA);
}
save_object(ACCOUNT_DATA);
}
SetUser(name,what)
{
if (!ok()) return;
if (!mappingp(what)) return;
data[name]=what;
save_object(SAVEFILE);
}
gboolean
mu_msg_part_save (MuMsg *msg, MuMsgOptions opts,
const char *fullpath, guint partidx, GError **err)
{
GMimeObject *part;
g_return_val_if_fail (msg, FALSE);
g_return_val_if_fail (fullpath, FALSE);
g_return_val_if_fail (!((opts & MU_MSG_OPTION_OVERWRITE) &&
(opts & MU_MSG_OPTION_USE_EXISTING)), FALSE);
if (!mu_msg_load_msg_file (msg, err))
return FALSE;
part = get_mime_object_at_index (msg, opts, partidx);
if (!GMIME_IS_PART(part) || GMIME_IS_MESSAGE_PART(part)) {
g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME,
"unexpected type %s for part %u",
G_OBJECT_TYPE_NAME((GObject*)part),
partidx);
return FALSE;
}
return save_object (part, opts, fullpath, err);
}
int cmd_tstats(string str) {
string *users;
int i;
if(!players) players = ([]);
if(!str) {
users = keys(players);
i = sizeof(users);
while(i--) {
write ( capitalize(users[i] + " : " + players[users[i]] + "") );
}
}
else {
if(!find_player(str))
return notify_fail("player not found\n");
else if(!players[str])
players[str] = 1;
else
players[str]++;
write("+1 ("+str+")\n");
}
seteuid(UID_CRESAVE);
save_object("/wizards/daos/save/trivia");
seteuid(geteuid());
return 1;
}
int
main() {
asn_TYPE_descriptor_t *td = &asn_DEF_UserIdentifier;
UserIdentifier_t user;
UserIdentifier_t user_new;
int ret;
memset(&user, 0, sizeof user);
memset(&user_new, 0, sizeof user_new);
user.present = UserIdentifier_PR_phoneNumber;
OCTET_STRING_fromBuf(
&user.choice.phoneNumber,
"0123456789", -1);
/* Save->Load must succeed */
save_object(&user, td);
ret = load_object(&user_new, td);
assert(user_new.present == UserIdentifier_PR_phoneNumber);
assert(ret == 0);
printf("OK\n");
return ret;
}
int save_data_conn() {
if (!name || name == "logon" || !password) return 0;
// A fix from Dm, after an idea from Robo, added by Leto
// if(file_size(PDATA_DIR+name+".o") < 1) return 0;
assure_user_save_dir(this_object());
save_object(user_data_file(this_object())+__SAVE_EXTENSION__);
return 1;
}
// save.c
// Copyright (C) 1995 - 2001, by FengYun Workshop. All rights reserved.
// This software can not be used, copied, or modified in any form without
// the written permission from authors.
//
int save() {
string file;
if(stringp(file = this_object()->query_save_file())) {
assure_file(file+ __SAVE_EXTENSION__);
return save_object(file);
}
return 0;
}
int remove_high_lord(string str) {
if (high_programmer(geteuid(previous_object())) &&
positions[str] == HIGH_LORD) {
map_delete(positions, str);
save_object("/secure/master");
return 1;
}
return 0;
} /* remove_high_lord() */
int add_high_lord(string str) {
if ("/secure/login"->test_user(str) &&
high_programmer(geteuid(previous_object()))) {
positions[str] = HIGH_LORD;
save_object("/secure/master");
return 1;
}
return 0;
} /* add_high_lord() */
void save_students() {
string err;
err = catch( save_object(SAVE_FILE) );
if(err) log_file(ERROR_LOG, "[" + extract(ctime(time()),4,15) +
"] Error in save_students()\n " + err + "\n");
}
/*
* write one list of objects
*/
void save_inventory(inv_t *i, FILE *f)
{
int j;
fwrite("INVENTORY", sizeof(char), 9, f);
fwrite(&i->num_used, sizeof(short), 1, f);
fwrite(&i->gold, sizeof(int), 1, f);
for(j = 0; j < 52; j++)
save_object(i->object[j], f);
}
int vote(string str) {
string me;
me=(string)this_player()->query_name();
if(str!="a" && str!="b") {
notify_fail("You may only vote for a or b.\n");
return 0;
}
if(this_player()->query_level() < 5 && !wizardp(this_player())) {
write("You are too small of an adventurer to partake in such events.");
return 1;
}
if(MULTI_D->non_voter(me)) {
write("You are listed as a second character. You may not vote.");
return 1;
}
if(vote[me]) {
write("You have already voted.");
return 1;
}
if(str=="a") {
vote[me]="a";
a++;
write("Vote counted. Thank you.");
seteuid(UID_VOTESAVE);
save_object(DIR_VOTES+"/question");
seteuid(geteuid());
return 1;
}
if(str=="b") {
vote[me]="b";
b++;
write("Vote counted. Thank you.");
seteuid(UID_VOTESAVE);
save_object(DIR_VOTES+"/question");
seteuid(geteuid());
return 1;
}
}
int do_messages() {
int i;
if(sizeof(messages) < 1) {
write("Your notepad is empty.\n");
return 1;
}
write("Your messages:\n");
for(i = 0; i < sizeof(messages); i++) {
write(" "+(i+1)+". "+messages[i]+"\n");
}
save_object("/wiz/b/bart/save/notepad");
return 1;
}
load_player() {
loaded = 1;
if (!restore_object(NAME + this_player()->query_real_name()) ||
messages == "" || messages == 0) {
arr_messages = 0;
messages = "";
return;
}
if (new_mail) {
new_mail = 0;
save_object(NAME + this_player()->query_real_name());
}
arr_messages = explode(messages, "\n**\n");
}
int clear() {
if(!tmp_clear) {
write("Type clear again to clear the votes.");
tmp_clear=1;
return 1;
}
vote=([]);
a=0;
b=0;
write("Vote counted. Thank you.");
seteuid(UID_VOTESAVE);
save_object(DIR_VOTES+"/question");
seteuid(geteuid());
write("Vote system cleared.");
return 1;
}
/*****************************************************************************
Name: save_objects
Purpose: Save #OBJECTS section of an area file.
Called by: save_area(olc_save.c).
Notes: Changed for ROM OLC.
****************************************************************************/
void save_objects( FILE *fp, AREA_DATA *pArea )
{
int i;
OBJ_INDEX_DATA *pObj;
fprintf( fp, "#OBJECTS\n" );
for( i = pArea->min_vnum; i <= pArea->max_vnum; i++ )
{
if ( (pObj = get_obj_index( i )) )
save_object( fp, pObj );
}
fprintf( fp, "#0\n\n\n\n" );
return;
}
bool Model::Save3DO (const char *fn, IProgressCtl& progctl)
{
FILE *f = fopen(fn, "wb");
if (!f)
return false;
MdlObject *cl = root->Clone();
IterateObjects (cl, ApplyOrientationAndScaling);
vector<MdlObject*> tmp;
tmp.push_back (cl);
save_object (f, 0, tmp.begin());
fclose (f);
delete cl;
return true;
}
//#################### SAVING METHODS ####################
void ObjectsSection::save(std::ostream& os, const ObjectManager_Ptr& objectManager)
{
objectManager->consolidate_object_ids();
os << "Objects\n";
os << "{\n";
os << '\t';
int objectCount = objectManager->object_count();
FieldIO::write_typed_field(os, "Count", objectCount);
// Note: The objects with the specified IDs are guaranteed to exist because we called consolidate_object_ids() above.
// This would not necessarily be the case otherwise, as the IDs of the objects may not form a contiguous series.
for(int i=0; i<objectCount; ++i)
{
std::vector<IObjectComponent_Ptr> components = objectManager->get_components(ObjectID(i));
save_object(os, components, objectManager->component_property_types());
}
os << "}\n";
}
int pop_mud( string mudname ) {
init_queue();
if( !file_exists( SAVE_FILE( mudname ) + SAVE_EXTENSION ) )
return 0;
if( !restore_object( SAVE_FILE( mudname ) ) ) {
log_file( "mail_q", "Could not restore " + SAVE_FILE( mudname ) +
SAVE_EXTENSION + "\n" );
return 0;
}
if( !out_queue )
init_queue();
out_queue = exclude_array( out_queue, 0 );
if( !sizeof( out_queue ) )
rm( SAVE_FILE( mudname ) + SAVE_EXTENSION );
else
save_object( SAVE_FILE( mudname ) );
return 1;
}
int pop_mud( string mudname ) {
init_queue();
if( !file_exists( SAVE_FILE( mudname ) + SAVE_EXTENSION ) )
return 0;
if( !restore_object( SAVE_FILE( mudname ) ) ) {
rm( SAVE_FILE( mudname ) + SAVE_EXTENSION );
return 0;
}
if( !out_queue )
init_queue();
TELL( sizeof(out_queue) );
out_queue = out_queue[1..<1];
TELL(sizeof(out_queue ) );
if( !sizeof( out_queue ) )
rm( SAVE_FILE( mudname ) + SAVE_EXTENSION );
else
save_object( SAVE_FILE( mudname ) );
return 1;
}
static void save_object(FILE *f, MdlObject *parent, std::vector<MdlObject*>::iterator cur)
{
TA_Object n;
MdlObject *obj = *cur++;
memset (&n, 0, sizeof(TA_Object));
int header = ftell(f);
fseek (f, sizeof(TA_Object), SEEK_CUR);
n.VersionSignature = 1;
n.NumberOfPrimitives = obj->poly.size();
n.XFromParent = TO_TA(obj->position.v[0]);
n.YFromParent = TO_TA(obj->position.v[1]);
n.ZFromParent = TO_TA(obj->position.v[2]);
n.NumberOfVertexes = obj->verts.size();
n.OffsetToObjectName = ftell(f);
WriteZStr (f, obj->name);
n.OffsetToVertexArray = ftell(f);
for (int a=0;a<obj->verts.size();a++)
{
long v[3];
Vector3 *p = &obj->verts[a].pos;
for (int i=0;i<3;i++) v[i] = TO_TA(p->v[i]);
fwrite (v, sizeof(long), 3, f);
}
n.OffsetToPrimitiveArray = ftell(f);
TA_Polygon *tapl = new TA_Polygon [obj->poly.size()];
fseek (f, sizeof(TA_Polygon) * obj->poly.size(), SEEK_CUR);
memset (tapl,0,sizeof(TA_Polygon)*obj->poly.size());
for (int a=0;a<obj->poly.size();a++)
{
Poly *pl = obj->poly [a];
if (pl->taColor >= 0)
tapl[a].PaletteIndex = pl->taColor;
else
tapl[a].PaletteIndex = palette.FindIndex(pl->color);
tapl[a].TexnameOfs = ftell(f);
WriteZStr (f,pl->texname);
tapl[a].VertOfs = ftell(f);
for (int b=0;b<pl->verts.size();b++)
{
unsigned short v;
v = pl->verts[b];
fwrite (&v, sizeof(short), 1, f);
}
tapl[a].VertNum = pl->verts.size();
tapl[a].Unknown_1 = 0;
tapl[a].Unknown_2 = 0;
tapl[a].Unknown_3 = 0;
}
int old = ftell(f);
fseek (f, n.OffsetToPrimitiveArray, SEEK_SET);
fwrite (tapl, sizeof(TA_Polygon), obj->poly.size(),f);
fseek (f, old, SEEK_SET);
if (parent) {
if (cur != parent->childs.end()) {
n.OffsetToSiblingObject = ftell(f);
save_object (f, parent, cur);
}
}
if (obj->childs.size()) {
n.OffsetToChildObject = ftell(f);
save_object (f, obj, obj->childs.begin());
}
old=ftell(f);
fseek (f, header, SEEK_SET);
fwrite (&n, sizeof(TA_Object), 1, f);
fseek (f,old, SEEK_SET);
}
void save_quests() {
seteuid((string)"secure/master"->get_root_uid());
save_object(SAVE_FILE);
seteuid("Room");
}
void do_save() {
save_object(SAVE_FILE);
}
/** Used to backup the file security data to disk. All modifications of the
* file security information call this immediately, so you don't have people
* "undoing" changes by calling load_self().
*/
void save_self() {
save_object( FILE_SECURITY_DATA );
}
int
main() {
asn_TYPE_descriptor_t *td1 = &asn_DEF_T1;
asn_TYPE_descriptor_t *td2 = &asn_DEF_T2;
T1_t t1, t1_new;
T2_t t2, t2_new;
int ret;
/*
* Test the T1 with constructed indefinite length ANY encoding.
*/
memset(&t1, 0, sizeof(t1));
memset(&t1_new, 0, sizeof(t1_new));
t1.i = 112233;
t1.any.buf = test_any_buf1;
t1.any.size = sizeof(test_any_buf1);
/* Save->Load must succeed */
save_object(&t1, td1);
ret = load_object(&t1_new, td1);
assert(ret == 0);
assert(t1_new.i == 112233);
assert(t1_new.any.size == sizeof(test_any_buf1));
assert(memcmp(t1_new.any.buf, test_any_buf1, sizeof(test_any_buf1)) == 0);
/*
* Test the T1 with primitive encoding.
*/
memset(&t1, 0, sizeof(t1));
memset(&t1_new, 0, sizeof(t1_new));
t1.i = -112233;
t1.any.buf = test_any_buf2;
t1.any.size = sizeof(test_any_buf2);
/* Save->Load must succeed */
save_object(&t1, td1);
ret = load_object(&t1_new, td1);
assert(ret == 0);
assert(t1_new.i == -112233);
assert(t1_new.any.size == sizeof(test_any_buf2));
assert(memcmp(t1_new.any.buf, test_any_buf2, sizeof(test_any_buf2)) == 0);
/*
* Test the T2 empty sequence.
*/
memset(&t2, 0, sizeof(t2));
memset(&t2_new, 0, sizeof(t2_new));
t2.i = 332211;
t2.any = calloc(1, sizeof(*t2.any));
t2.any->buf = 0;
t2.any->size = 0;
/* Save->Load must succeed */
save_object(&t2, td2);
ret = load_object(&t2_new, td2);
assert(ret == 0);
assert(t2_new.i == 332211);
assert(t2_new.any->size == 0);
/*
* Test the T2 sequence.
*/
memset(&t2, 0, sizeof(t2));
memset(&t2_new, 0, sizeof(t2_new));
t2.i = 332211;
t2.any = calloc(1, sizeof(*t2.any));
t2.any->buf = test_any_buf1;
t2.any->size = sizeof(test_any_buf1);
/* Save->Load must succeed */
save_object(&t2, td2);
ret = load_object(&t2_new, td2);
assert(ret == 0);
assert(t2_new.i == 332211);
assert(t2_new.any->size == sizeof(test_any_buf1));
assert(memcmp(t2_new.any->buf, test_any_buf1, sizeof(test_any_buf1)) == 0);
/*
* Test the T2 sequence with primitive encoding.
*/
memset(&t2, 0, sizeof(t2));
memset(&t2_new, 0, sizeof(t2_new));
t2.i = 0;
t2.any = calloc(1, sizeof(*t2.any));
t2.any->buf = test_any_buf2;
t2.any->size = sizeof(test_any_buf2);
/* Save->Load must succeed */
save_object(&t2, td2);
ret = load_object(&t2_new, td2);
assert(ret == 0);
assert(t2_new.i == 0);
assert(t2_new.any->size == sizeof(test_any_buf2));
assert(memcmp(t2_new.any->buf, test_any_buf2, sizeof(test_any_buf2)) == 0);
/*
* Test T2 with ANY element omitted.
*/
free(t2.any);
t2.any = 0;
memset(&t2_new, 0, sizeof(t2_new));
save_object(&t2, td2);
ret = load_object(&t2_new, td2);
assert(ret == 0);
assert(t2_new.i == 0);
assert(t2_new.any == 0);
printf("OK\n");
return ret;
}
static void save() {
seteuid(UID_DAEMONSAVE);
save_object(SAVE_FILE);
seteuid(getuid());
}
int cmd_pay(string str)
{
int year;
int mo;
string month;
string guild;
int error;
if( !this_player()->query_guild() )
return 0;
if( this_player()->query_guild_position() != "leader" &&
this_player()->query_guild_position() != "main" )
{
return 0;
}
if( !str || str != "dues" )
return notify_fail("Pay what?\n");
seteuid(UID_DAEMONSAVE);
restore_object(SAVE_FILE);
seteuid(getuid());
year = EVENTS_D->query_year(time());
mo = EVENTS_D->query_month(time()) - 1;
month = MONTHS[mo];
guild = (string)(environment(this_player())->query_guild());
if( !sizeof(guild) )
return notify_fail("You must be in your treasury to do that.\n");
if( !payments )
payments = ([]);
if( !payments[guild] )
payments[guild] = ([]);
if( !payments[guild][year] )
payments[guild][year] = ([]);
if( !payments[guild][year][mo] )
{
error = TREASURY_D->withdraw(this_player()->query_name(), guild,
DUES_AMOUNT, "gold");
switch( error )
{
case INSF:
return notify_fail("You need at least " + DUES_AMOUNT
+ " gold in your treasury.\n");
break;
case NO_ACCOUNT:
return notify_fail("Your guild doesn't have a treasury!\n");
break;
case BAD_ACCESS:
return notify_fail("You don't have access to the guild's " +
"treasury!\n");
break;
case TRANSACTION_OK:
payments[guild][year][mo] = DUES_AMOUNT;
message("info", "You have paid your dues for " +
capitalize(month) + ".", this_player());
seteuid(UID_DAEMONSAVE);
save_object(SAVE_FILE);
seteuid(getuid());
TREASURY_D->update_summary(
this_player()->query_original_guild(),
"Guild dues", "gold", DUES_AMOUNT);
environment(this_player())->do_scroll_write(
capitalize(this_player()->query_name()) + " (dues)",
WITHDRAW, DUES_AMOUNT, "gold");
return 1;
break;
default:
/* Edit eventually to log the error */
return notify_fail("An error occured; please contact an " +
"Admin.\n");
break;
}
}
else
{
return notify_fail("Your dues have already been paid for this month.\n");
}
// Should never get here, but just in case
return 0;
}
static void
save_set_all(FILE *fp)
{
struct text_label *this_label;
struct arrow_def *this_arrow;
struct linestyle_def *this_linestyle;
struct arrowstyle_def *this_arrowstyle;
legend_key *key = &keyT;
int axis;
/* opinions are split as to whether we save term and outfile
* as a compromise, we output them as comments !
*/
if (term)
fprintf(fp, "# set terminal %s %s\n", term->name, term_options);
else
fputs("# set terminal unknown\n", fp);
if (outstr)
fprintf(fp, "# set output '%s'\n", outstr);
else
fputs("# set output\n", fp);
fprintf(fp, "\
%sset clip points\n\
%sset clip one\n\
%sset clip two\n\
set bar %f %s\n",
(clip_points) ? "" : "un",
(clip_lines1) ? "" : "un",
(clip_lines2) ? "" : "un",
bar_size, (bar_layer == LAYER_BACK) ? "back" : "front");
if (draw_border) {
fprintf(fp, "set border %d %s", draw_border, border_layer == 0 ? "back" : "front");
save_linetype(fp, &border_lp, FALSE);
fprintf(fp, "\n");
} else
fputs("unset border\n", fp);
for (axis = FIRST_AXES; axis < LAST_REAL_AXIS; axis++) {
if (axis == SECOND_Z_AXIS) continue;
if (strlen(axis_array[axis].timefmt))
fprintf(fp, "set timefmt %s \"%s\"\n", axis_defaults[axis].name,
conv_text(axis_array[axis].timefmt));
if (axis == COLOR_AXIS) continue;
fprintf(fp, "set %sdata %s\n", axis_defaults[axis].name,
axis_array[axis].datatype == DT_TIMEDATE ? "time" :
"");
}
if (boxwidth < 0.0)
fputs("set boxwidth\n", fp);
else
fprintf(fp, "set boxwidth %g %s\n", boxwidth,
(boxwidth_is_absolute) ? "absolute" : "relative");
fprintf(fp, "set style fill ");
save_fillstyle(fp, &default_fillstyle);
#ifdef EAM_OBJECTS
/* Default rectangle style */
fprintf(fp, "set style rectangle %s fc ",
default_rectangle.layer > 0 ? "front" :
default_rectangle.layer < 0 ? "behind" : "back");
if (default_rectangle.lp_properties.use_palette)
save_pm3dcolor(fp, &default_rectangle.lp_properties.pm3d_color);
else
fprintf(fp, "lt %d",default_rectangle.lp_properties.l_type+1);
fprintf(fp, " fillstyle ");
save_fillstyle(fp, &default_rectangle.fillstyle);
/* Default circle properties */
fprintf(fp, "set style circle radius ");
save_position(fp, &default_circle.o.circle.extent, FALSE);
fputs(" \n", fp);
/* Default ellipse properties */
fprintf(fp, "set style ellipse size ");
save_position(fp, &default_ellipse.o.ellipse.extent, FALSE);
fprintf(fp, " angle %g ", default_ellipse.o.ellipse.orientation);
fputs("units ", fp);
switch (default_ellipse.o.ellipse.type) {
case ELLIPSEAXES_XY:
fputs("xy\n", fp);
break;
case ELLIPSEAXES_XX:
fputs("xx\n", fp);
break;
case ELLIPSEAXES_YY:
fputs("yy\n", fp);
break;
}
#endif
if (dgrid3d) {
if( dgrid3d_mode == DGRID3D_QNORM ) {
fprintf(fp, "set dgrid3d %d,%d, %d\n",
dgrid3d_row_fineness,
dgrid3d_col_fineness,
dgrid3d_norm_value);
} else if( dgrid3d_mode == DGRID3D_SPLINES ) {
fprintf(fp, "set dgrid3d %d,%d splines\n",
dgrid3d_row_fineness, dgrid3d_col_fineness );
} else {
fprintf(fp, "set dgrid3d %d,%d %s%s %f,%f\n",
dgrid3d_row_fineness,
dgrid3d_col_fineness,
reverse_table_lookup(dgrid3d_mode_tbl, dgrid3d_mode),
dgrid3d_kdensity ? " kdensity2d" : "",
dgrid3d_x_scale,
dgrid3d_y_scale );
}
}
fprintf(fp, "set dummy %s,%s\n", set_dummy_var[0], set_dummy_var[1]);
#define SAVE_FORMAT(axis) \
fprintf(fp, "set format %s \"%s\"\n", axis_defaults[axis].name, \
conv_text(axis_array[axis].formatstring));
SAVE_FORMAT(FIRST_X_AXIS );
SAVE_FORMAT(FIRST_Y_AXIS );
SAVE_FORMAT(SECOND_X_AXIS);
SAVE_FORMAT(SECOND_Y_AXIS);
SAVE_FORMAT(FIRST_Z_AXIS );
SAVE_FORMAT(COLOR_AXIS );
SAVE_FORMAT(POLAR_AXIS );
#undef SAVE_FORMAT
fprintf(fp, "set angles %s\n",
(ang2rad == 1.0) ? "radians" : "degrees");
/* Grid back/front controls tics also. Make sure it is saved */
if (grid_layer >= 0)
fprintf(fp,"set tics %s\n", grid_layer == 0 ? "back" : "front");
if (! some_grid_selected())
fputs("unset grid\n", fp);
else {
if (polar_grid_angle) /* set angle already output */
fprintf(fp, "set grid polar %f\n", polar_grid_angle / ang2rad);
else
fputs("set grid nopolar\n", fp);
#define SAVE_GRID(axis) \
fprintf(fp, " %s%stics %sm%stics", \
axis_array[axis].gridmajor ? "" : "no", \
axis_defaults[axis].name, \
axis_array[axis].gridminor ? "" : "no", \
axis_defaults[axis].name);
fputs("set grid", fp);
SAVE_GRID(FIRST_X_AXIS);
SAVE_GRID(FIRST_Y_AXIS);
SAVE_GRID(FIRST_Z_AXIS);
fputs(" \\\n", fp);
SAVE_GRID(SECOND_X_AXIS);
SAVE_GRID(SECOND_Y_AXIS);
SAVE_GRID(COLOR_AXIS);
fputs("\n", fp);
#undef SAVE_GRID
fprintf(fp, "set grid %s ", (grid_layer==-1) ? "layerdefault" : ((grid_layer==0) ? "back" : "front"));
save_linetype(fp, &grid_lp, FALSE);
fprintf(fp, ", ");
save_linetype(fp, &mgrid_lp, FALSE);
fputc('\n', fp);
}
fprintf(fp, "%sset raxis\n", raxis ? "" : "un");
fprintf(fp, "set key title \"%s\"", conv_text(key->title));
if (key->font)
fprintf(fp, " font \"%s\"", key->font);
if (key->textcolor.type != TC_LT || key->textcolor.lt != LT_BLACK)
save_textcolor(fp, &key->textcolor);
fputs("\n", fp);
fputs("set key ", fp);
switch (key->region) {
case GPKEY_AUTO_INTERIOR_LRTBC:
fputs("inside", fp);
break;
case GPKEY_AUTO_EXTERIOR_LRTBC:
fputs("outside", fp);
break;
case GPKEY_AUTO_EXTERIOR_MARGIN:
switch (key->margin) {
case GPKEY_TMARGIN:
fputs("tmargin", fp);
break;
case GPKEY_BMARGIN:
fputs("bmargin", fp);
break;
case GPKEY_LMARGIN:
fputs("lmargin", fp);
break;
case GPKEY_RMARGIN:
fputs("rmargin", fp);
break;
}
break;
case GPKEY_USER_PLACEMENT:
fputs("at ", fp);
save_position(fp, &key->user_pos, FALSE);
break;
}
if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN
&& (key->margin == GPKEY_LMARGIN || key->margin == GPKEY_RMARGIN))) {
switch (key->hpos) {
case RIGHT:
fputs(" right", fp);
break;
case LEFT:
fputs(" left", fp);
break;
case CENTRE:
fputs(" center", fp);
break;
}
}
if (!(key->region == GPKEY_AUTO_EXTERIOR_MARGIN
&& (key->margin == GPKEY_TMARGIN || key->margin == GPKEY_BMARGIN))) {
switch (key->vpos) {
case JUST_TOP:
fputs(" top", fp);
break;
case JUST_BOT:
fputs(" bottom", fp);
break;
case JUST_CENTRE:
fputs(" center", fp);
break;
}
}
fprintf(fp, " %s %s %sreverse %senhanced %s ",
key->stack_dir == GPKEY_VERTICAL ? "vertical" : "horizontal",
key->just == GPKEY_LEFT ? "Left" : "Right",
key->reverse ? "" : "no",
key->enhanced ? "" : "no",
key->auto_titles == COLUMNHEAD_KEYTITLES ? "autotitles columnhead"
: key->auto_titles == FILENAME_KEYTITLES ? "autotitles"
: "noautotitles" );
if (key->box.l_type > LT_NODRAW) {
fputs("box", fp);
save_linetype(fp, &(key->box), FALSE);
} else
fputs("nobox", fp);
/* Put less common options on separate lines */
fprintf(fp, "\nset key %sinvert samplen %g spacing %g width %g height %g ",
key->invert ? "" : "no",
key->swidth, key->vert_factor, key->width_fix, key->height_fix);
fprintf(fp, "\nset key maxcolumns %d maxrows %d",key->maxcols,key->maxrows);
fputc('\n', fp);
fprintf(fp, "set key %sopaque\n", key->front ? "" : "no");
if (!(key->visible))
fputs("unset key\n", fp);
fputs("unset label\n", fp);
for (this_label = first_label; this_label != NULL;
this_label = this_label->next) {
fprintf(fp, "set label %d \"%s\" at ",
this_label->tag,
conv_text(this_label->text));
save_position(fp, &this_label->place, FALSE);
switch (this_label->pos) {
case LEFT:
fputs(" left", fp);
break;
case CENTRE:
fputs(" centre", fp);
break;
case RIGHT:
fputs(" right", fp);
break;
}
if (this_label->rotate)
fprintf(fp, " rotate by %d", this_label->rotate);
else
fprintf(fp, " norotate");
if (this_label->font != NULL)
fprintf(fp, " font \"%s\"", this_label->font);
fprintf(fp, " %s", (this_label->layer==0) ? "back" : "front");
if (this_label->noenhanced)
fprintf(fp, " noenhanced");
save_textcolor(fp, &(this_label->textcolor));
if (this_label->lp_properties.pointflag == 0)
fprintf(fp, " nopoint");
else {
fprintf(fp, " point");
save_linetype(fp, &(this_label->lp_properties), TRUE);
}
save_position(fp, &this_label->offset, TRUE);
fputc('\n', fp);
}
fputs("unset arrow\n", fp);
for (this_arrow = first_arrow; this_arrow != NULL;
this_arrow = this_arrow->next) {
fprintf(fp, "set arrow %d from ", this_arrow->tag);
save_position(fp, &this_arrow->start, FALSE);
fputs(this_arrow->relative ? " rto " : " to ", fp);
save_position(fp, &this_arrow->end, FALSE);
fprintf(fp, " %s %s %s",
arrow_head_names[this_arrow->arrow_properties.head],
(this_arrow->arrow_properties.layer==0) ? "back" : "front",
( (this_arrow->arrow_properties.head_filled==2) ? "filled" :
( (this_arrow->arrow_properties.head_filled==1) ? "empty" :
"nofilled" )) );
save_linetype(fp, &(this_arrow->arrow_properties.lp_properties), FALSE);
if (this_arrow->arrow_properties.head_length > 0) {
static char *msg[] = {"first", "second", "graph", "screen",
"character"};
fprintf(fp, " size %s %.3f,%.3f,%.3f",
msg[this_arrow->arrow_properties.head_lengthunit],
this_arrow->arrow_properties.head_length,
this_arrow->arrow_properties.head_angle,
this_arrow->arrow_properties.head_backangle);
}
fprintf(fp, "\n");
}
fprintf(fp, "set style increment %s\n", prefer_line_styles ? "userstyles" : "default");
fputs("unset style line\n", fp);
for (this_linestyle = first_linestyle; this_linestyle != NULL;
this_linestyle = this_linestyle->next) {
fprintf(fp, "set style line %d ", this_linestyle->tag);
save_linetype(fp, &(this_linestyle->lp_properties), TRUE);
fprintf(fp, "\n");
}
fputs("unset style arrow\n", fp);
for (this_arrowstyle = first_arrowstyle; this_arrowstyle != NULL;
this_arrowstyle = this_arrowstyle->next) {
fprintf(fp, "set style arrow %d", this_arrowstyle->tag);
fprintf(fp, " %s %s %s",
arrow_head_names[this_arrowstyle->arrow_properties.head],
(this_arrowstyle->arrow_properties.layer==0)?"back":"front",
( (this_arrowstyle->arrow_properties.head_filled==2)?"filled":
( (this_arrowstyle->arrow_properties.head_filled==1)?"empty":
"nofilled" )) );
save_linetype(fp, &(this_arrowstyle->arrow_properties.lp_properties), FALSE);
if (this_arrowstyle->arrow_properties.head_length > 0) {
static char *msg[] = {"first", "second", "graph", "screen",
"character"};
fprintf(fp, " size %s %.3f,%.3f,%.3f",
msg[this_arrowstyle->arrow_properties.head_lengthunit],
this_arrowstyle->arrow_properties.head_length,
this_arrowstyle->arrow_properties.head_angle,
this_arrowstyle->arrow_properties.head_backangle);
}
fprintf(fp, "\n");
}
fprintf(fp, "set style histogram ");
switch (histogram_opts.type) {
default:
case HT_CLUSTERED:
fprintf(fp,"clustered gap %d ",histogram_opts.gap); break;
case HT_ERRORBARS:
fprintf(fp,"errorbars gap %d lw %g",histogram_opts.gap,histogram_opts.bar_lw); break;
case HT_STACKED_IN_LAYERS:
fprintf(fp,"rowstacked "); break;
case HT_STACKED_IN_TOWERS:
fprintf(fp,"columnstacked "); break;
}
fprintf(fp,"title ");
save_position(fp, &histogram_opts.title.offset, TRUE);
fprintf(fp, "\n");
#ifdef EAM_OBJECTS
save_object(fp, 0);
#endif
fputs("unset logscale\n", fp);
#define SAVE_LOG(axis) \
if (axis_array[axis].log) \
fprintf(fp, "set logscale %s %g\n", axis_defaults[axis].name, \
axis_array[axis].base);
SAVE_LOG(FIRST_X_AXIS );
SAVE_LOG(FIRST_Y_AXIS );
SAVE_LOG(SECOND_X_AXIS);
SAVE_LOG(SECOND_Y_AXIS);
SAVE_LOG(FIRST_Z_AXIS );
SAVE_LOG(COLOR_AXIS );
SAVE_LOG(POLAR_AXIS );
#undef SAVE_LOG
save_offsets(fp, "set offsets");
/* FIXME */
fprintf(fp, "\
set pointsize %g\n\
set pointintervalbox %g\n\
set encoding %s\n\
%sset polar\n\
%sset parametric\n",
pointsize, pointintervalbox,
encoding_names[encoding],
(polar) ? "" : "un",
(parametric) ? "" : "un");
if (numeric_locale)
fprintf(fp, "set decimalsign locale \"%s\"\n", numeric_locale);
if (decimalsign != NULL)
fprintf(fp, "set decimalsign '%s'\n", decimalsign);
if (!numeric_locale && !decimalsign)
fprintf(fp, "unset decimalsign\n");
fputs("set view ", fp);
if (splot_map == TRUE)
fputs("map", fp);
else {
fprintf(fp, "%g, %g, %g, %g",
surface_rot_x, surface_rot_z, surface_scale, surface_zscale);
}
if (aspect_ratio_3D)
fprintf(fp, "\nset view %s", aspect_ratio_3D == 2 ? "equal xy" :
aspect_ratio_3D == 3 ? "equal xyz": "");
fprintf(fp, "\n\
set samples %d, %d\n\
set isosamples %d, %d\n\
%sset surface\n\
%sset contour",
samples_1, samples_2,
iso_samples_1, iso_samples_2,
(draw_surface) ? "" : "un",
(draw_contour) ? "" : "un");
switch (draw_contour) {
case CONTOUR_NONE:
fputc('\n', fp);
break;
case CONTOUR_BASE:
fputs(" base\n", fp);
break;
case CONTOUR_SRF:
fputs(" surface\n", fp);
break;
case CONTOUR_BOTH:
fputs(" both\n", fp);
break;
}
if (label_contours)
fprintf(fp, "set clabel '%s'\n", contour_format);
else
fputs("unset clabel\n", fp);
#ifdef GP_MACROS
if (expand_macros)
fputs("set macros\n", fp);
#endif
fputs("set mapping ", fp);
switch (mapping3d) {
case MAP3D_SPHERICAL:
fputs("spherical\n", fp);
break;
case MAP3D_CYLINDRICAL:
fputs("cylindrical\n", fp);
break;
case MAP3D_CARTESIAN:
default:
fputs("cartesian\n", fp);
break;
}
if (missing_val != NULL)
fprintf(fp, "set datafile missing '%s'\n", missing_val);
if (df_separator != '\0')
fprintf(fp, "set datafile separator \"%c\"\n",df_separator);
else
fprintf(fp, "set datafile separator whitespace\n");
if (strcmp(df_commentschars, DEFAULT_COMMENTS_CHARS))
fprintf(fp, "set datafile commentschars '%s'\n", df_commentschars);
if (df_fortran_constants)
fprintf(fp, "set datafile fortran\n");
if (df_nofpe_trap)
fprintf(fp, "set datafile nofpe_trap\n");
save_hidden3doptions(fp);
fprintf(fp, "set cntrparam order %d\n", contour_order);
fputs("set cntrparam ", fp);
switch (contour_kind) {
case CONTOUR_KIND_LINEAR:
fputs("linear\n", fp);
break;
case CONTOUR_KIND_CUBIC_SPL:
fputs("cubicspline\n", fp);
break;
case CONTOUR_KIND_BSPLINE:
fputs("bspline\n", fp);
break;
}
fputs("set cntrparam levels ", fp);
switch (contour_levels_kind) {
case LEVELS_AUTO:
fprintf(fp, "auto %d\n", contour_levels);
break;
case LEVELS_INCREMENTAL:
fprintf(fp, "incremental %g,%g,%g\n",
contour_levels_list[0], contour_levels_list[1],
contour_levels_list[0] + contour_levels_list[1] * contour_levels);
break;
case LEVELS_DISCRETE:
{
int i;
fprintf(fp, "discrete %g", contour_levels_list[0]);
for (i = 1; i < contour_levels; i++)
fprintf(fp, ",%g ", contour_levels_list[i]);
fputc('\n', fp);
}
}
fprintf(fp, "\
set cntrparam points %d\n\
set size ratio %g %g,%g\n\
set origin %g,%g\n",
contour_pts,
aspect_ratio, xsize, ysize,
xoffset, yoffset);
fprintf(fp, "set style data ");
save_data_func_style(fp,"data",data_style);
fprintf(fp, "set style function ");
save_data_func_style(fp,"function",func_style);
save_zeroaxis(fp, FIRST_X_AXIS);
save_zeroaxis(fp, FIRST_Y_AXIS);
save_zeroaxis(fp, FIRST_Z_AXIS);
save_zeroaxis(fp, SECOND_X_AXIS);
save_zeroaxis(fp, SECOND_Y_AXIS);
if (xyplane.absolute)
fprintf(fp, "set xyplane at %g\n", xyplane.z);
else
fprintf(fp, "set ticslevel %g\n", xyplane.z);
#define SAVE_MINI(axis) \
switch(axis_array[axis].minitics & TICS_MASK) { \
case 0: \
fprintf(fp, "set nom%stics\n", axis_defaults[axis].name); \
break; \
case MINI_AUTO: \
fprintf(fp, "set m%stics\n", axis_defaults[axis].name); \
break; \
case MINI_DEFAULT: \
fprintf(fp, "set m%stics default\n", axis_defaults[axis].name); \
break; \
case MINI_USER: \
fprintf(fp, "set m%stics %f\n", axis_defaults[axis].name, \
axis_array[axis].mtic_freq); \
break; \
}
SAVE_MINI(FIRST_X_AXIS);
SAVE_MINI(FIRST_Y_AXIS);
SAVE_MINI(FIRST_Z_AXIS); /* HBB 20000506: noticed mztics were not saved! */
SAVE_MINI(SECOND_X_AXIS);
SAVE_MINI(SECOND_Y_AXIS);
SAVE_MINI(COLOR_AXIS);
#undef SAVE_MINI
save_tics(fp, FIRST_X_AXIS);
save_tics(fp, FIRST_Y_AXIS);
save_tics(fp, FIRST_Z_AXIS);
save_tics(fp, SECOND_X_AXIS);
save_tics(fp, SECOND_Y_AXIS);
save_tics(fp, COLOR_AXIS);
save_tics(fp, POLAR_AXIS);
#define SAVE_AXISLABEL_OR_TITLE(name,suffix,lab) \
{ \
fprintf(fp, "set %s%s \"%s\" ", \
name, suffix, lab.text ? conv_text(lab.text) : ""); \
fprintf(fp, "\nset %s%s ", name, suffix); \
save_position(fp, &(lab.offset), TRUE); \
fprintf(fp, " font \"%s\"", lab.font ? conv_text(lab.font) : "");\
save_textcolor(fp, &(lab.textcolor)); \
if (lab.tag == ROTATE_IN_3D_LABEL_TAG) \
fprintf(fp, " rotate parallel"); \
if (lab.rotate) \
fprintf(fp, " rotate by %d", lab.rotate); \
else \
fprintf(fp, " norotate"); \
fprintf(fp, "%s\n", (lab.noenhanced) ? " noenhanced" : ""); \
}
SAVE_AXISLABEL_OR_TITLE("", "title", title);
/* FIXME */
fprintf(fp, "set timestamp %s \n", timelabel_bottom ? "bottom" : "top");
SAVE_AXISLABEL_OR_TITLE("", "timestamp", timelabel);
save_range(fp, POLAR_AXIS);
save_range(fp, T_AXIS);
save_range(fp, U_AXIS);
save_range(fp, V_AXIS);
#define SAVE_AXISLABEL(axis) \
SAVE_AXISLABEL_OR_TITLE(axis_defaults[axis].name,"label", \
axis_array[axis].label)
SAVE_AXISLABEL(FIRST_X_AXIS);
SAVE_AXISLABEL(SECOND_X_AXIS);
save_range(fp, FIRST_X_AXIS);
save_range(fp, SECOND_X_AXIS);
SAVE_AXISLABEL(FIRST_Y_AXIS);
SAVE_AXISLABEL(SECOND_Y_AXIS);
if (splot_map == FALSE) {
save_range(fp, FIRST_Y_AXIS);
save_range(fp, SECOND_Y_AXIS);
} else { /* 'set view map' uses flipped y-axes */
splot_map_deactivate();
save_range(fp, FIRST_Y_AXIS);
save_range(fp, SECOND_Y_AXIS);
splot_map_activate();
}
SAVE_AXISLABEL(FIRST_Z_AXIS);
save_range(fp, FIRST_Z_AXIS);
SAVE_AXISLABEL(COLOR_AXIS);
save_range(fp, COLOR_AXIS);
#undef SAVE_AXISLABEL
#undef SAVE_AXISLABEL_OR_TITLE
fprintf(fp, "set zero %g\n", zero);
fprintf(fp, "set lmargin %s %g\n",
lmargin.scalex == screen ? "at screen" : "", lmargin.x);
fprintf(fp, "set bmargin %s %g\n",
bmargin.scalex == screen ? "at screen" : "", bmargin.x);
fprintf(fp, "set rmargin %s %g\n",
rmargin.scalex == screen ? "at screen" : "", rmargin.x);
fprintf(fp, "set tmargin %s %g\n",
tmargin.scalex == screen ? "at screen" : "", tmargin.x);
fprintf(fp, "set locale \"%s\"\n", get_time_locale());
fputs("set pm3d ", fp);
fputs((PM3D_IMPLICIT == pm3d.implicit ? "implicit" : "explicit"), fp);
fprintf(fp, " at %s\n", pm3d.where);
fputs("set pm3d ", fp);
switch (pm3d.direction) {
case PM3D_SCANS_AUTOMATIC: fputs("scansautomatic\n", fp); break;
case PM3D_SCANS_FORWARD: fputs("scansforward\n", fp); break;
case PM3D_SCANS_BACKWARD: fputs("scansbackward\n", fp); break;
case PM3D_DEPTH: fputs("depthorder\n", fp); break;
}
fprintf(fp, "set pm3d interpolate %d,%d", pm3d.interp_i, pm3d.interp_j);
fputs(" flush ", fp);
switch (pm3d.flush) {
case PM3D_FLUSH_CENTER: fputs("center", fp); break;
case PM3D_FLUSH_BEGIN: fputs("begin", fp); break;
case PM3D_FLUSH_END: fputs("end", fp); break;
}
fputs((pm3d.ftriangles ? " " : " no"), fp);
fputs("ftriangles", fp);
if (pm3d.hidden3d_tag > 0) fprintf(fp," hidden3d %d", pm3d.hidden3d_tag);
else fputs(pm3d.hidden3d_tag ? " hidden3d" : " nohidden3d", fp);
fputs(" corners2color ", fp);
switch (pm3d.which_corner_color) {
case PM3D_WHICHCORNER_MEAN: fputs("mean", fp); break;
case PM3D_WHICHCORNER_GEOMEAN: fputs("geomean", fp); break;
case PM3D_WHICHCORNER_MEDIAN: fputs("median", fp); break;
case PM3D_WHICHCORNER_MIN: fputs("min", fp); break;
case PM3D_WHICHCORNER_MAX: fputs("max", fp); break;
default: /* PM3D_WHICHCORNER_C1 ... _C4 */
fprintf(fp, "c%i", pm3d.which_corner_color - PM3D_WHICHCORNER_C1 + 1);
}
fputs("\n", fp);
/*
* Save palette information
*/
fprintf( fp, "set palette %s %s maxcolors %d ",
sm_palette.positive==SMPAL_POSITIVE ? "positive" : "negative",
sm_palette.ps_allcF ? "ps_allcF" : "nops_allcF",
sm_palette.use_maxcolors);
fprintf( fp, "gamma %g ", sm_palette.gamma );
if (sm_palette.colorMode == SMPAL_COLOR_MODE_GRAY) {
fputs( "gray\n", fp );
}
else {
fputs( "color model ", fp );
switch( sm_palette.cmodel ) {
case C_MODEL_RGB: fputs( "RGB ", fp ); break;
case C_MODEL_HSV: fputs( "HSV ", fp ); break;
case C_MODEL_CMY: fputs( "CMY ", fp ); break;
case C_MODEL_YIQ: fputs( "YIQ ", fp ); break;
case C_MODEL_XYZ: fputs( "XYZ ", fp ); break;
default:
fprintf( stderr, "%s:%d ooops: Unknown color model '%c'.\n",
__FILE__, __LINE__, (char)(sm_palette.cmodel) );
}
fputs( "\nset palette ", fp );
switch( sm_palette.colorMode ) {
case SMPAL_COLOR_MODE_RGB:
fprintf( fp, "rgbformulae %d, %d, %d\n", sm_palette.formulaR,
sm_palette.formulaG, sm_palette.formulaB );
break;
case SMPAL_COLOR_MODE_GRADIENT: {
int i=0;
fprintf( fp, "defined (" );
for( i=0; i<sm_palette.gradient_num; ++i ) {
fprintf( fp, " %.4g %.4g %.4g %.4g", sm_palette.gradient[i].pos,
sm_palette.gradient[i].col.r, sm_palette.gradient[i].col.g,
sm_palette.gradient[i].col.b );
if (i<sm_palette.gradient_num-1) {
fputs( ",", fp);
if (i==2 || i%4==2) fputs( "\\\n ", fp );
}
}
fputs( " )\n", fp );
break;
}
case SMPAL_COLOR_MODE_FUNCTIONS:
fprintf( fp, "functions %s, %s, %s\n", sm_palette.Afunc.definition,
sm_palette.Bfunc.definition, sm_palette.Cfunc.definition );
break;
case SMPAL_COLOR_MODE_CUBEHELIX:
fprintf( fp, "cubehelix start %.2g cycles %.2g saturation %.2g\n",
sm_palette.cubehelix_start, sm_palette.cubehelix_cycles,
sm_palette.cubehelix_saturation);
break;
default:
fprintf( stderr, "%s:%d ooops: Unknown color mode '%c'.\n",
__FILE__, __LINE__, (char)(sm_palette.colorMode) );
}
}
/*
* Save colorbox info
*/
if (color_box.where != SMCOLOR_BOX_NO)
fprintf(fp,"set colorbox %s\n", color_box.where==SMCOLOR_BOX_DEFAULT ? "default" : "user");
fprintf(fp, "set colorbox %sal origin ", color_box.rotation == 'v' ? "vertic" : "horizont");
save_position(fp, &color_box.origin, FALSE);
fputs(" size ", fp);
save_position(fp, &color_box.size, FALSE);
fprintf(fp, " %s ", color_box.layer == LAYER_FRONT ? "front" : "back");
if (color_box.border == 0) fputs("noborder", fp);
else if (color_box.border_lt_tag < 0) fputs("bdefault", fp);
else fprintf(fp, "border %d", color_box.border_lt_tag);
if (color_box.where == SMCOLOR_BOX_NO) fputs("\nunset colorbox\n", fp);
else fputs("\n", fp);
fprintf(fp, "set style boxplot %s %s %5.2f %soutliers pt %d separation %g labels %s %ssorted\n",
boxplot_opts.plotstyle == FINANCEBARS ? "financebars" : "candles",
boxplot_opts.limit_type == 1 ? "fraction" : "range",
boxplot_opts.limit_value,
boxplot_opts.outliers ? "" : "no",
boxplot_opts.pointtype+1,
boxplot_opts.separation,
(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_X) ? "x" :
(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_X2) ? "x2" :
(boxplot_opts.labels == BOXPLOT_FACTOR_LABELS_AUTO) ? "auto" :"off",
boxplot_opts.sort_factors ? "" : "un");
fputs("set loadpath ", fp);
{
char *s;
while ((s = save_loadpath()) != NULL)
fprintf(fp, "\"%s\" ", s);
fputc('\n', fp);
}
fputs("set fontpath ", fp);
{
char *s;
while ((s = save_fontpath()) != NULL)
fprintf(fp, "\"%s\" ", s);
fputc('\n', fp);
}
if (PS_psdir)
fprintf(fp, "set psdir \"%s\"\n", PS_psdir);
else
fprintf(fp, "set psdir\n");
fprintf(fp, "set fit");
if (fitlogfile)
fprintf(fp, " logfile \'%s\'", fitlogfile);
fprintf(fp, " %serrorvariables",
fit_errorvariables ? "" : "no");
fprintf(fp, " %sprescale", fit_prescale ? "" : "no");
fputc('\n', fp);
}
int save_char_objs(Character *ch)
{
char buf[400];
sql_stmt *stmt;
int len;
Object *obj;
for (obj = ch->carrying; obj; obj = obj->next_content)
{
len =
sprintf(buf,
"select objectId from char_objects where carriedById=%"
PRId64 " and objectId=%" PRId64, ch->id, obj->id);
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare statement");
return 0;
}
bool update = sql_step(stmt) != SQL_DONE;
if (sql_finalize(stmt) != SQL_OK)
{
log_data("unable to finalize sql statement");
return 0;
}
if (!update)
{
obj->id = 0;
}
if (!save_object(obj)) {
return 0;
}
}
// try and cleanup old objects
len =
sprintf(buf,
"select * from char_objects where carriedById=%" PRId64,
ch->id);
if (sql_query(buf, len, &stmt) != SQL_OK)
{
log_data("could not prepare statement");
return 0;
}
while (sql_step(stmt) != SQL_DONE)
{
obj = ch->carrying;
identifier_t id = sql_column_int64(stmt, 0);
while (obj)
{
if (obj->id == id) {
break;
}
obj = obj->next;
}
if (!obj)
{
sprintf(buf,
"delete from object where carriedById=%" PRId64
" and objectId=%" PRId64, ch->id, id);
if (sql_exec(buf) != SQL_OK)
{
log_data("could not delete character object %"
PRId64, id);
return 0;
}
}
}
if (sql_finalize(stmt) != SQL_OK)
{
log_data("could not finalize statement");
return 0;
}
return 1;
}
int save_me() {
save_object("/wiz/b/bart/save/notepad");
return 1;
}
