void save_artifacts(struct memfile *mf)
{
/* artiexist and artidisco are arrays of bytes, so writing them in one
* go is safe and portable */
mwrite(mf, artiexist, sizeof artiexist);
mwrite(mf, artidisco, sizeof artidisco);
}
/**
* save_regions :
*/
void
save_regions(struct memfile *mf, struct level *lev)
{
int i, j;
unsigned len1, len2;
struct region *r;
mfmagic_set(mf, REGION_MAGIC);
mtag(mf, ledger_no(&lev->z), MTAG_REGION);
mwrite32(mf, save_encode_32(moves, moves, moves)); /* timestamp */
mwrite32(mf, lev->n_regions);
/* Note: level regions don't have ID numbers, so we can't tag individual
regions; instead, diff efficiency depends on the fact that regions tend
to stay in the order and are typically inserted or deleted near the end
of the list */
for (i = 0; i < lev->n_regions; i++) {
r = lev->regions[i];
save_rect(mf, r->bounding_box);
mwrite32(mf, r->attach_2_m);
mwrite32(mf, r->effect_id);
mwrite32(mf, r->arg);
mwrite16(mf, r->nrects);
for (j = 0; j < r->nrects; j++)
save_rect(mf, r->rects[j]);
mwrite16(mf, r->ttl);
mwrite16(mf, r->expire_f);
mwrite16(mf, r->can_enter_f);
mwrite16(mf, r->enter_f);
mwrite16(mf, r->can_leave_f);
mwrite16(mf, r->leave_f);
mwrite16(mf, r->inside_f);
mwrite16(mf, r->n_monst);
mwrite8(mf, r->player_flags);
mwrite8(mf, r->attach_2_u);
mwrite8(mf, r->visible);
for (j = 0; j < r->n_monst; j++)
mwrite32(mf, r->monsters[j]);
len1 = r->enter_msg ? strlen(r->enter_msg) + 1 : 0;
mwrite16(mf, len1);
len2 = r->leave_msg ? strlen(r->leave_msg) + 1 : 0;
mwrite16(mf, len2);
if (len1 > 0)
mwrite(mf, r->enter_msg, len1);
if (len2 > 0)
mwrite(mf, r->leave_msg, len2);
}
}
void write_info(unsigned int addr, block_info towrite){
uint8_t n4 = block_info.next_addr % (1<<8);
block_info.next_addr = block_info.next_addr>>8;
uint8_t n3 = block_info.next_addr % (1<<8);
block_info.next_addr = block_info.next_addr >>8;
uint8_t n2 = block_info.next_addr % (1<<8);
block_info.next_addr = block_info.next_addr >>8;
uint8_t n1 = block_info.next_addr % (1<<8);
uint8_t e4 = block_info.addr_end % (1<<8);
block_info.addr_end = block_info.addr_end>>8;
uint8_t e3 = block_info.addr_end % (1<<8);
block_info.addr_end = block_info.addr_end >>8;
uint8_t e2 = block_info.addr_end % (1<<8);
block_info.addr_end = block_info.addr_end >>8;
uint8_t e1 = block_info.addr_end % (1<<8);
mwrite( addr , b1 );
mwrite( addr+1 , b2 );
mwrite( addr+2 , b3 );
mwrite( addr+3 , b4 );
mwrite( addr+4 , e1 );
mwrite( addr+5 , e2 );
mwrite( addr+6 , e3 );
mwrite( addr+7 , e4 );
}
void
mwrite64(struct memfile *mf, int64_t value)
{
int64_t le_value = host_to_le64(value);
mwrite(mf, &le_value, 8);
}
void
mwrite32(struct memfile *mf, int32_t value)
{
int32_t le_value = host_to_le32(value);
mwrite(mf, &le_value, 4);
}
void
mwrite16(struct memfile *mf, int16_t value)
{
int16_t le_value = host_to_le16(value);
mwrite(mf, &le_value, 2);
}
int main() {
mount("volume2.vfs");
ls();
touch("ppg");
ls();
int fd;
fd = mopen("ppg");
char *out = mread(fd);
printf(out);
mclose(fd);
fd = mopen("ppg");
mwrite(fd, "spider man!");
mclose(fd);
fd = mopen("ppg");
out = mread(fd);
printf(out);
mclose(fd);
ls();
touch("hello.c");
ls();
fd = mopen("hello.c");
out = mread(fd);
printf(out);
mclose(fd);
fd = mopen("hello.c");
mwrite(fd, "hello\nworld!\n");
mclose(fd);
fd = mopen("hello.c");
out = mread(fd);
mclose(fd);
fd = mopen("ppg");
out = mread(fd);
printf(out);
mclose(fd);
umount();
return 0;
}
static void savelevchn(struct memfile *mf)
{
s_level *tmplev;
int cnt = 0;
for (tmplev = sp_levchn; tmplev; tmplev = tmplev->next)
cnt++;
mwrite32(mf, cnt);
for (tmplev = sp_levchn; tmplev; tmplev = tmplev->next) {
save_d_flags(mf, tmplev->flags);
mwrite(mf, &tmplev->dlevel, sizeof(tmplev->dlevel));
mwrite(mf, tmplev->proto, sizeof(tmplev->proto));
mwrite8(mf, tmplev->boneid);
mwrite8(mf, tmplev->rndlevs);
}
}
/**
* Inicializacia pamate
*
* Zavola sa, v stave, ked sa zacina s prazdnou pamatou, ktora je inicializovana
* na 0.
*/
void my_init(void) {
//split 32-bit int 4 bytes
unsigned int total_size = msize();
uint8_t size_part_4 = total_size % (1<<8);
total_size = total_size>>8;
uint8_t size_part_3 = total_size % (1<<8);
total_size = total_size>>8;
uint8_t size_part_2 = total_size % (1<<8);
total_size = total_size>>8;
uint8_t size_part_1 = total_size % (1<<8);
// 0..3 bytes -> total memory
mwrite(0,size_part_1);
mwrite(1,size_part_2);
mwrite(2,size_part_3);
mwrite(3,size_part_4);
return;
}
static void save_flags(struct memfile *mf)
{
mwrite32(mf, flags.ident);
mwrite32(mf, flags.moonphase);
mwrite32(mf, flags.no_of_wizards);
mwrite32(mf, flags.init_role);
mwrite32(mf, flags.init_race);
mwrite32(mf, flags.init_gend);
mwrite32(mf, flags.init_align);
mwrite32(mf, flags.randomall);
mwrite32(mf, flags.pantheon);
mwrite32(mf, flags.run);
mwrite32(mf, flags.warntype);
mwrite32(mf, flags.warnlevel);
mwrite32(mf, flags.djinni_count);
mwrite32(mf, flags.ghost_count);
mwrite32(mf, flags.pickup_burden);
mwrite8(mf, flags.autodig);
mwrite8(mf, flags.autoquiver);
mwrite8(mf, flags.beginner);
mwrite8(mf, flags.confirm);
mwrite8(mf, flags.debug);
mwrite8(mf, flags.explore);
mwrite8(mf, flags.female);
mwrite8(mf, flags.forcefight);
mwrite8(mf, flags.friday13);
mwrite8(mf, flags.legacy);
mwrite8(mf, flags.lit_corridor);
mwrite8(mf, flags.made_amulet);
mwrite8(mf, flags.mon_moving);
mwrite8(mf, flags.move);
mwrite8(mf, flags.mv);
mwrite8(mf, flags.nopick);
mwrite8(mf, flags.null);
mwrite8(mf, flags.pickup);
mwrite8(mf, flags.pushweapon);
mwrite8(mf, flags.rest_on_space);
mwrite8(mf, flags.safe_dog);
mwrite8(mf, flags.silent);
mwrite8(mf, flags.sortpack);
mwrite8(mf, flags.soundok);
mwrite8(mf, flags.sparkle);
mwrite8(mf, flags.tombstone);
mwrite8(mf, flags.verbose);
mwrite8(mf, flags.prayconfirm);
mwrite8(mf, flags.travel);
mwrite8(mf, flags.end_disclose);
mwrite8(mf, flags.menu_style);
mwrite8(mf, flags.elbereth_enabled);
mwrite8(mf, flags.rogue_enabled);
mwrite8(mf, flags.seduce_enabled);
mwrite8(mf, flags.bones_enabled);
mwrite(mf, flags.inv_order, sizeof(flags.inv_order));
}
int fast_write(MFILE *mfp, char *buf, size_t buf_len)
{
int wr = mwrite(mfp, buf, buf_len);
if (wr != 1) {
mclose(mfp);
mfp = NULL;
return 0;
}
return wr;
}
void child(char n, int fd0,int fds) {
int i,j;
for (i=0; i< turns; i++) {
for (j=0; j<fds; j++) {
mwrite(n, fd0+(j*(n+1))%fds );
}
}
exit(0);
}
static void
savegamestate(struct memfile *mf)
{
unsigned book_id;
mtag(mf, 0, MTAG_GAMESTATE);
mfmagic_set(mf, STATE_MAGIC);
/* must come before migrating_objs and migrating_mons are freed */
save_timers(mf, level, RANGE_GLOBAL);
save_light_sources(mf, level, RANGE_GLOBAL);
saveobjchn(mf, invent);
savemonchn(mf, migrating_mons);
save_mvitals(mf);
save_quest_status(mf);
save_spellbook(mf);
save_artifacts(mf);
save_oracles(mf);
mwrite(mf, pl_character, sizeof pl_character);
mwrite(mf, pl_fruit, sizeof pl_fruit);
mwrite32(mf, current_fruit);
savefruitchn(mf);
savenames(mf);
save_waterlevel(mf);
mwrite32(mf, lastinvnr);
save_mt_state(mf);
save_track(mf);
save_food(mf);
save_steal(mf);
save_dig_status(mf);
book_id = book ? book->o_id : 0;
mwrite32(mf, book_id);
mwrite32(mf, stetho_last_used_move);
mwrite32(mf, stetho_last_used_movement);
mwrite32(mf, multi);
save_rndmonst_state(mf);
save_history(mf);
}
void save_obj(struct memfile *mf, struct obj *obj)
{
unsigned int oflags;
oflags = (obj->cursed << 31) | (obj->blessed << 30) | (obj->unpaid << 29) |
(obj->no_charge << 28) | (obj->known << 27) | (obj->dknown << 26) |
(obj->bknown << 25) | (obj->rknown << 24) | (obj->oeroded << 22) |
(obj->oeroded2 << 20) | (obj->oerodeproof << 19) | (obj->olocked << 18) |
(obj->obroken << 17) | (obj->otrapped << 16) | (obj->recharged << 13) |
(obj->lamplit << 12) | (obj->greased << 11) | (obj->oattached << 9) |
(obj->in_use << 8) | (obj->was_thrown << 7) | (obj->bypass << 6);
mfmagic_set(mf, OBJ_MAGIC);
mwrite32(mf, obj->onamelth);
mwrite32(mf, obj->o_id);
mwrite32(mf, obj->owt);
mwrite32(mf, obj->quan);
mwrite32(mf, obj->corpsenm);
mwrite32(mf, obj->oeaten);
mwrite32(mf, obj->age);
mwrite32(mf, obj->owornmask);
mwrite32(mf, oflags);
mwrite16(mf, obj->otyp);
mwrite8(mf, obj->ox);
mwrite8(mf, obj->oy);
mwrite8(mf, obj->spe);
mwrite8(mf, obj->oclass);
mwrite8(mf, obj->invlet);
mwrite8(mf, obj->oartifact);
mwrite8(mf, obj->where);
mwrite8(mf, obj->timed);
/* no need to save the value of the cobj pointer, but we will need to know
* if there is something in here that needs to be restored */
mwrite8(mf, obj->cobj ? 1 : 0);
if (obj->onamelth)
mwrite(mf, ONAME(obj), obj->onamelth);
if (obj->oattached == OATTACHED_MONST)
save_mon(mf, (struct monst*)obj->oextra);
else if (obj->oattached == OATTACHED_M_ID)
mwrite32(mf, *(unsigned int*)obj->oextra);
}
template <class T> bool
Write (const Matrix<T>& M, const std::string& uri = "") {
assert (m_file != NULL);
dtype dt = CODTraits<T>::dt;
size_t n, l;
// Dump type
if (!mwrite(&dt, 1, m_file, "data type"))
return false;
n = M.NDim();
if (!mwrite(&n, 1, m_file, "data dimensions"))
return false;
// Dump dimensions
if (!mwrite(M.Dim(), m_file, "dimensions"))
return false;
// Dump resolutions
if (!mwrite(M.Res(), m_file, "resolutions"))
return false;
// Size of name and name
n = uri.size();
if (!mwrite(&n, 1, m_file, "name length"))
return false;
// Dump name
if (!mwrite(uri.c_str(), n, m_file, "name"))
return false;
// Dump data
if (!mwrite(M.Container(), m_file, "data"))
return false;
if (!mwrite(delim.c_str(), delim.length(), m_file, "delimiter"))
return false;
return true;
}
void
save_history(struct memfile *mf)
{
int i, len;
mfmagic_set(mf, HISTORY_MAGIC);
mtag(mf, 0, MTAG_HISTORY);
mwrite32(mf, histcount);
/* don't need tags for individual history events, because they're always
added at the end of the list */
for (i = 0; i < histcount; i++) {
mwrite32(mf, histevents[i].when);
mwrite32(mf, histevents[i].hidden);
len = strlen(histevents[i].what) + 1;
mwrite32(mf, len);
mwrite(mf, histevents[i].what, len);
}
}
/* save all the fruit names and ID's; this is used only in saving whole games
* (not levels) and in saving bones levels. When saving a bones level,
* we only want to save the fruits which exist on the bones level; the bones
* level routine marks nonexistent fruits by making the fid negative.
*/
void savefruitchn(struct memfile *mf)
{
struct fruit *f1;
unsigned int count = 0;
mfmagic_set(mf, FRUITCHAIN_MAGIC);
for (f1 = ffruit; f1; f1 = f1->nextf)
if (f1->fid >= 0)
count++;
mwrite32(mf, count);
for (f1 = ffruit; f1; f1 = f1->nextf) {
if (f1->fid >= 0) {
mwrite(mf, f1->fname, sizeof(f1->fname));
mwrite32(mf, f1->fid);
}
}
}
/*
* save_worm()
*
* Save the worm information for later use. The count is the number
* of segments, including the dummy. Called from save.c.
*/
void save_worm(struct memfile *mf, struct level *lev)
{
int i, count;
struct wseg *curr;
for (i = 1; i < MAX_NUM_WORMS; i++) {
for (count = 0, curr = lev->wtails[i]; curr; curr = curr->nseg) count++;
/* Save number of segments */
mwrite(mf, &count, sizeof(int));
/* Save segment locations of the monster. */
if (count) {
for (curr = lev->wtails[i]; curr; curr = curr->nseg) {
mwrite8(mf, curr->wx);
mwrite8(mf, curr->wy);
}
mwrite32(mf, lev->wgrowtime[i]);
}
}
}
int main()
{
// Remote location
struct in_addr server_addr;
inet_aton(IP, &server_addr);
int server_port = htons(PORT);
fileloc_t location;
location.ipaddress = server_addr;
location.port = server_port;
location.pathname = FILENAME;
// Memory map remote file at offset 0
void *address = rmmap(location, 0);
if (address == (void*) -1)
{
printf("Something didn't go very well\n");
exit(-1);
}
// Write 1024 bytes to memory mapped region
ssize_t length = 1024;
char buff[length];
if (mwrite(address, 0, buff, length) != length)
{
printf("Something doesn't seem right\n");
rmunmap(address);
exit(-1);
}
// All done, clear memory mapping and exit
if (!rmunmap(address))
{
printf("Couldn't clear memory mapped region\n");
exit(-1);
}
return 1;
}
void
mwrite8(struct memfile *mf, int8_t value)
{
mwrite(mf, &value, 1);
}
void savelev(struct memfile *mf, xchar levnum)
{
int x, y;
unsigned int lflags;
struct level *lev = levels[levnum];
if (iflags.purge_monsters) {
/* purge any dead monsters (necessary if we're starting
* a panic save rather than a normal one, or sometimes
* when changing levels without taking time -- e.g.
* create statue trap then immediately level teleport) */
dmonsfree(lev);
}
mfmagic_set(mf, LEVEL_MAGIC);
mwrite8(mf, lev->z.dnum);
mwrite8(mf, lev->z.dlevel);
mwrite(mf, lev->levname, sizeof(lev->levname));
for (x = 0; x < COLNO; x++)
for (y = 0; y < ROWNO; y++)
save_location(mf, &lev->locations[x][y]);
mwrite32(mf, lev->lastmoves);
mwrite(mf, &lev->upstair, sizeof(stairway));
mwrite(mf, &lev->dnstair, sizeof(stairway));
mwrite(mf, &lev->upladder, sizeof(stairway));
mwrite(mf, &lev->dnladder, sizeof(stairway));
mwrite(mf, &lev->sstairs, sizeof(stairway));
mwrite(mf, &lev->updest, sizeof(dest_area));
mwrite(mf, &lev->dndest, sizeof(dest_area));
mwrite8(mf, lev->flags.nfountains);
mwrite8(mf, lev->flags.nsinks);
lflags = (lev->flags.has_shop << 31) | (lev->flags.has_vault << 30) |
(lev->flags.has_zoo << 29) | (lev->flags.has_court << 28) |
(lev->flags.has_morgue << 27) | (lev->flags.has_beehive << 26) |
(lev->flags.has_barracks << 25) | (lev->flags.has_temple << 24) |
(lev->flags.has_swamp << 23) | (lev->flags.noteleport << 22) |
(lev->flags.hardfloor << 21) | (lev->flags.nommap << 20) |
(lev->flags.hero_memory << 19) | (lev->flags.shortsighted << 18) |
(lev->flags.graveyard << 17) | (lev->flags.is_maze_lev << 16) |
(lev->flags.is_cavernous_lev << 15) | (lev->flags.arboreal << 14) |
(lev->flags.forgotten << 13);
mwrite32(mf, lflags);
mwrite(mf, lev->doors, sizeof(lev->doors));
save_rooms(mf, lev); /* no dynamic memory to reclaim */
/* must be saved before mons, objs, and buried objs */
save_timers(mf, lev, RANGE_LEVEL);
save_light_sources(mf, lev, RANGE_LEVEL);
savemonchn(mf, lev->monlist);
save_worm(mf, lev); /* save worm information */
savetrapchn(mf, lev->lev_traps);
saveobjchn(mf, lev->objlist);
saveobjchn(mf, lev->buriedobjlist);
saveobjchn(mf, lev->billobjs);
save_engravings(mf, lev);
savedamage(mf, lev);
save_regions(mf, lev);
}
