コード例 #1
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_aimcamera_t(aimcamera_t* cam) {
    saveg_write_mobjindex(cam->viewmobj);
    saveg_write32(cam->activator ? cam->activator - players + 1 : 0);
}
コード例 #2
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_mobjfade_t(mobjfade_t* fade) {
    saveg_write_mobjindex(fade->mobj);
    saveg_write32(fade->amount);
    saveg_write32(fade->destAlpha);
    saveg_write32(fade->flagReserve);
}
コード例 #3
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_combine_t(combine_t* combine) {
    saveg_write32(combine->sector - sectors);
}
コード例 #4
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_delay_t(delay_t* delay) {
    saveg_write32(delay->tics);
    saveg_write32(delay->finishfunc ? 1 : 0);
}
コード例 #5
0
ファイル: p_saveg.c プロジェクト: GhostlyDeath/chocolate-doom
static void saveg_write_mobj_t(mobj_t *str)
{
    // thinker_t thinker;
    saveg_write_thinker_t(&str->thinker);

    // fixed_t x;
    saveg_write32(str->x);

    // fixed_t y;
    saveg_write32(str->y);

    // fixed_t z;
    saveg_write32(str->z);

    // struct mobj_s* snext;
    saveg_writep(str->snext);

    // struct mobj_s* sprev;
    saveg_writep(str->sprev);

    // angle_t angle;
    saveg_write32(str->angle);

    // spritenum_t sprite;
    saveg_write_enum(str->sprite);

    // int frame;
    saveg_write32(str->frame);

    // struct mobj_s* bnext;
    saveg_writep(str->bnext);

    // struct mobj_s* bprev;
    saveg_writep(str->bprev);

    // struct subsector_s* subsector;
    saveg_writep(str->subsector);

    // fixed_t floorz;
    saveg_write32(str->floorz);

    // fixed_t ceilingz;
    saveg_write32(str->ceilingz);

    // fixed_t radius;
    saveg_write32(str->radius);

    // fixed_t height;
    saveg_write32(str->height);

    // fixed_t momx;
    saveg_write32(str->momx);

    // fixed_t momy;
    saveg_write32(str->momy);

    // fixed_t momz;
    saveg_write32(str->momz);

    // int validcount;
    saveg_write32(str->validcount);

    // mobjtype_t type;
    saveg_write_enum(str->type);

    // mobjinfo_t* info;
    saveg_writep(str->info);

    // int tics;
    saveg_write32(str->tics);

    // state_t* state;
    saveg_write32(str->state - states);

    // int flags;
    saveg_write32(str->flags);

    // int health;
    saveg_write32(str->health);

    // int movedir;
    saveg_write32(str->movedir);

    // int movecount;
    saveg_write32(str->movecount);

    // struct mobj_s* target;
    saveg_writep(str->target);

    // int reactiontime;
    saveg_write32(str->reactiontime);

    // int threshold;
    saveg_write32(str->threshold);

    // struct player_s* player;
    if (str->player)
    {
        saveg_write32(str->player - players + 1);
    }
    else
    {
        saveg_write32(0);
    }

    // int lastlook;
    saveg_write32(str->lastlook);

    // mapthing_t spawnpoint;
    saveg_write_mapthing_t(&str->spawnpoint);

    // struct mobj_s* tracer;
    saveg_writep(str->tracer);
}
コード例 #6
0
ファイル: p_saveg.c プロジェクト: Azarien/chocolate-doom
static void saveg_write_player_t(player_t *str)
{
    int i;

    // mobj_t* mo;
    saveg_writep(str->mo);

    // playerstate_t playerstate;
    saveg_write_enum(str->playerstate);

    // ticcmd_t cmd;
    saveg_write_ticcmd_t(&str->cmd);

    // fixed_t viewz;
    saveg_write32(str->viewz);

    // fixed_t viewheight;
    saveg_write32(str->viewheight);

    // fixed_t deltaviewheight;
    saveg_write32(str->deltaviewheight);

    // fixed_t bob;
    saveg_write32(str->bob);

    // int health;
    saveg_write32(str->health);

    // int armorpoints;
    saveg_write16(str->armorpoints); // [STRIFE] 32 -> 16

    // int armortype;
    saveg_write16(str->armortype); // [STRIFE] 32 -> 16

    // int powers[NUMPOWERS];
    for (i=0; i<NUMPOWERS; ++i)
    {
        saveg_write32(str->powers[i]);
    }

    // int sigiltype;
    saveg_write32(str->sigiltype); // [STRIFE]

    // int nukagecount;
    saveg_write32(str->nukagecount); // [STRIFE]

    // int questflags;
    saveg_write32(str->questflags); // [STRIFE]

    // int pitch;
    saveg_write32(str->pitch); // [STRIFE]

    // int centerview;
    saveg_write32(str->centerview); // [STRIFE]

    // inventory_t inventory[NUMINVENTORY];
    for(i = 0; i < NUMINVENTORY; ++i) // [STRIFE]
    {
        saveg_write_inventory_t(&str->inventory[i]);
    }

    // int st_update;
    saveg_write32(str->st_update); // [STRIFE]

    // short numinventory;
    saveg_write16(str->numinventory); // [STRIFE]

    // short inventorycursor;
    saveg_write16(str->inventorycursor); // [STRIFE]

    // short accuracy;
    saveg_write16(str->accuracy); // [STRIFE]

    // short stamina;
    saveg_write16(str->stamina); // [STRIFE]

    // boolean cards[NUMCARDS];
    for (i=0; i<NUMCARDS; ++i)
    {
        saveg_write32(str->cards[i]);
    }

    // boolean backpack;
    saveg_write32(str->backpack);

    // int attackdown;
    saveg_write32(str->attackdown);

    // int usedown;
    saveg_write32(str->usedown);

    // int inventorydown;
    saveg_write32(str->inventorydown); // [STRIFE]

    // int frags[MAXPLAYERS];
    for (i=0; i<MAXPLAYERS; ++i)
    {
        saveg_write32(str->frags[i]);
    }

    // weapontype_t readyweapon;
    saveg_write_enum(str->readyweapon);

    // weapontype_t pendingweapon;
    saveg_write_enum(str->pendingweapon);

    // boolean weaponowned[NUMWEAPONS];
    for (i=0; i<NUMWEAPONS; ++i)
    {
        saveg_write32(str->weaponowned[i]);
    }

    // int ammo[NUMAMMO];
    for (i=0; i<NUMAMMO; ++i)
    {
        saveg_write32(str->ammo[i]);
    }

    // int maxammo[NUMAMMO];
    for (i=0; i<NUMAMMO; ++i)
    {
        saveg_write32(str->maxammo[i]);
    }


    // int cheats;
    saveg_write32(str->cheats);

    // int refire;
    saveg_write32(str->refire);

    // short killcount;
    saveg_write16(str->killcount); // [STRIFE] 32 -> 16

    // haleyjd 08/30/10 [STRIFE] No itemcount
    // int itemcount;
    //saveg_write32(str->itemcount);

    // haleyjd 08/30/10 [STRIFE] No secretcount
    // int secretcount;
    //saveg_write32(str->secretcount);

    // char* message;
    saveg_writep(str->message);

    // int damagecount;
    saveg_write32(str->damagecount);

    // int bonuscount;
    saveg_write32(str->bonuscount);

    // mobj_t* attacker;
    saveg_writep(str->attacker);

    // int extralight;
    saveg_write32(str->extralight);

    // int fixedcolormap;
    saveg_write32(str->fixedcolormap);

    // int colormap; [STRIFE] no such field
    //saveg_write32(str->colormap);

    // short allegiance;
    saveg_write16(str->allegiance); // [STRIFE]

    // pspdef_t psprites[NUMPSPRITES];
    for (i=0; i<NUMPSPRITES; ++i)
    {
        saveg_write_pspdef_t(&str->psprites[i]);
    }

    // int mapstate[40];
    for(i = 0; i < 40; ++i) // [STRIFE]
    {
        saveg_write32(str->mapstate[i]);
    }

    // haleyjd 08/30/10: [STRIFE] No intermission, no secret.
    // boolean didsecret;
    //saveg_write32(str->didsecret);
}
コード例 #7
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_ceiling_t(ceiling_t* ceiling) {
    saveg_write32(ceiling->type);
    saveg_write32(ceiling->sector - sectors);
    saveg_write32(ceiling->bottomheight);
    saveg_write32(ceiling->topheight);
    saveg_write32(ceiling->speed);
    saveg_write32(ceiling->crush);
    saveg_write32(ceiling->direction);
    saveg_write32(ceiling->tag);
    saveg_write32(ceiling->olddirection);
    saveg_write32(ceiling->instant);
    saveg_write32(ceiling->thinker.function.acp1 != NULL ? 1 : 0);
}
コード例 #8
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_laserthinker_t(laserthinker_t* laserthinker) {
    laser_t* l;

    saveg_write_mobjindex(laserthinker->dest);

    for(l = laserthinker->laser; l != NULL; l = l->next) {
        saveg_write32(l->x1);
        saveg_write32(l->y1);
        saveg_write32(l->z1);
        saveg_write32(l->x2);
        saveg_write32(l->y2);
        saveg_write32(l->z2);
        saveg_write32(l->slopex);
        saveg_write32(l->slopey);
        saveg_write32(l->slopez);
        saveg_write32(l->dist);
        saveg_write32(l->distmax);
        saveg_write_mobjindex(l->marker);
        saveg_write32(l->angle);
        saveg_write32(l->next ? 1 : 0);
    }
}
コード例 #9
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_mobj_t(mobj_t* mo) {
    saveg_write32(mo->x);
    saveg_write32(mo->y);
    saveg_write32(mo->z);
    saveg_write32(mo->tid);
    saveg_write_mobjindex(mo->snext);
    saveg_write_mobjindex(mo->sprev);
    saveg_write32(mo->angle);
    saveg_write32(mo->pitch);
    saveg_write32(mo->sprite);
    saveg_write32(mo->frame);
    saveg_write_mobjindex(mo->bnext);
    saveg_write_mobjindex(mo->bprev);
    saveg_write32(mo->subsector - subsectors);
    saveg_write32(mo->floorz);
    saveg_write32(mo->ceilingz);
    saveg_write32(mo->radius);
    saveg_write32(mo->height);
    saveg_write32(mo->momx);
    saveg_write32(mo->momy);
    saveg_write32(mo->momz);
    saveg_write32(mo->validcount);
    saveg_write32(mo->state - states);
    saveg_write32(mo->type);
    saveg_write32(mo->tics);
    saveg_write32(mo->flags);
    saveg_write32(mo->health);
    saveg_write32(mo->alpha);
    saveg_write32(mo->blockflag);
    saveg_write32(mo->movedir);
    saveg_write32(mo->movecount);
    saveg_write_mobjindex(mo->target);
    saveg_write32(mo->reactiontime);
    saveg_write32(mo->threshold);
    saveg_write32(mo->player ? mo->player - players + 1 : 0);
    saveg_write_mapthing_t(&mo->spawnpoint);
    saveg_write_mobjindex(mo->tracer);
    saveg_write32(mo->frame_x);
    saveg_write32(mo->frame_y);
    saveg_write32(mo->frame_z);
    saveg_write32(mo->mobjfunc == P_RespawnSpecials ? 1 : 0);
}
コード例 #10
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_player_t(player_t* p) {
    int i;

    saveg_write_mobjindex(p->mo);
    saveg_write32(p->playerstate);
    saveg_write_ticcmd_t(&p->cmd);
    saveg_write32(p->viewz);
    saveg_write32(p->viewheight);
    saveg_write32(p->deltaviewheight);
    saveg_write32(p->bob);
    saveg_write32(p->recoilpitch);
    saveg_write32(p->health);
    saveg_write32(p->armorpoints);
    saveg_write32(p->armortype);

    for(i = 0; i < NUMPOWERS; i++) {
        saveg_write32(p->powers[i]);
    }

    for(i = 0; i < NUMCARDS; i++) {
        saveg_write32(p->cards[i]);
        saveg_write32(p->tryopen[i]);
    }

    saveg_write32(p->artifacts);
    saveg_write32(p->backpack);

    for(i = 0; i < MAXPLAYERS; i++) {
        saveg_write32(p->frags[i]);
    }

    saveg_write32(p->readyweapon);
    saveg_write32(p->pendingweapon);

    for(i = 0; i < NUMWEAPONS; i++) {
        saveg_write32(p->weaponowned[i]);
    }

    for(i = 0; i < NUMAMMO; i++) {
        saveg_write32(p->ammo[i]);
        saveg_write32(p->maxammo[i]);
    }

    saveg_write32(p->attackdown);
    saveg_write32(p->usedown);
    saveg_write32(p->jumpdown);
    saveg_write32(p->cheats);
    saveg_write32(p->refire);
    saveg_write32(p->killcount);
    saveg_write32(p->itemcount);
    saveg_write32(p->secretcount);
    saveg_write32(p->damagecount);
    saveg_write32(p->bonuscount);
    saveg_write32(p->bfgcount);
    saveg_write_mobjindex(p->attacker);
    saveg_write_mobjindex(p->cameratarget);

    for(i = 0; i < NUMPSPRITES; i++) {
        saveg_write_pspdef_t(&p->psprites[i]);
    }

    saveg_write32(p->palette);
    saveg_write32(p->onground);
    saveg_write32(p->autoaim);
}
コード例 #11
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
//
// P_ArchiveWorld
//
void P_ArchiveWorld(void) {
    int         i;
    int         j;
    sector_t    *sec;
    line_t      *li;
    side_t      *si;
    light_t     *light;

    // do sectors
    for(i = 0, sec = sectors; i < numsectors; i++, sec++) {
        saveg_write16(F2INT(sec->floorheight));
        saveg_write16(F2INT(sec->ceilingheight));
        saveg_write16(sec->floorpic);
        saveg_write16(sec->ceilingpic);
        saveg_write16(sec->special);
        saveg_write16(sec->tag);
        saveg_write16(sec->flags);
        saveg_write16(sec->lightlevel);
        saveg_write32(sec->xoffset);
        saveg_write32(sec->yoffset);
        saveg_write_mobjindex(sec->soundtarget);

        for(j = 0; j < 5; j++) {
            saveg_write16(sec->colors[j]);
        }
    }


    // do lines
    for(i = 0, li = lines; i < numlines; i++, li++) {
        saveg_write16((li->flags >> 16));
        saveg_write16((li->flags & 0xFFFF));
        saveg_write16(li->special);
        saveg_write16(li->tag);

        for(j = 0; j < 2; j++) {
            if(li->sidenum[j] == NO_SIDE_INDEX) {
                continue;
            }

            si = &sides[li->sidenum[j]];

            saveg_write16(F2INT(si->textureoffset));
            saveg_write16(F2INT(si->rowoffset));
            saveg_write16(si->toptexture);
            saveg_write16(si->bottomtexture);
            saveg_write16(si->midtexture);
        }
    }

    // do lights
    for(i = 0, light = lights; i < numlights; i++, light++) {
        saveg_write8(light->base_r);
        saveg_write8(light->base_g);
        saveg_write8(light->base_b);
        saveg_write8(light->active_r);
        saveg_write8(light->active_g);
        saveg_write8(light->active_b);
        saveg_write8(light->r);
        saveg_write8(light->g);
        saveg_write8(light->b);
        saveg_write_pad();
        saveg_write16(light->tag);
    }
}
コード例 #12
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_marker(int marker) {
    saveg_write_pad();
    saveg_write32(marker);
}
コード例 #13
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_header(char *description) {
    int i;
    int size;
    char date[32];
    byte* tbn;

    for(i = 0; description[i] != '\0'; i++) {
        saveg_write8(description[i]);
    }

    for(; i < SAVESTRINGSIZE; i++) {
        saveg_write8(0);
    }

    sprintf(date, "%s", saveg_gettime());
    size = dstrlen(date);

    for(i = 0; i < size; i++) {
        saveg_write8(date[i]);
    }

    for(; i < 32; i++) {
        saveg_write8(0);
    }

    size = M_CacheThumbNail(&tbn);

    saveg_write32(size);

    for(i = 0; i < size; i++) {
        saveg_write8(tbn[i]);
    }

    Z_Free(tbn);

    for(i = 0; i < 16; i++) {
        saveg_write8(passwordData[i]);
    }

    saveg_write8(gameskill);
    saveg_write8(gamemap);
    saveg_write8(nextmap);
    saveg_write_pad();
    saveg_write16(globalint);

    //
    // [kex] 12/26/11 - write total stat info
    //
    saveg_write_pad();
    saveg_write32(totalkills);
    saveg_write32(totalitems);
    saveg_write32(totalsecret);

    for(i = 0; i < MAXPLAYERS; i++) {
        saveg_write8(playeringame[i]);
    }

    saveg_write8((leveltime >> 16) & 0xff);
    saveg_write8((leveltime >> 8) & 0xff);
    saveg_write8(leveltime & 0xff);
    saveg_write_pad();
}
コード例 #14
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_mobjexp_t(mobjexp_t* exp) {
    saveg_write32(exp->delay);
    saveg_write32(exp->lifetime);
    saveg_write32(exp->delaymax);
    saveg_write_mobjindex(exp->mobj);
}
コード例 #15
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_plat_t(plat_t* plat) {
    saveg_write32(plat->sector - sectors);
    saveg_write32(plat->speed);
    saveg_write32(plat->low);
    saveg_write32(plat->high);
    saveg_write32(plat->wait);
    saveg_write32(plat->count);
    saveg_write32(plat->status);
    saveg_write32(plat->oldstatus);
    saveg_write32(plat->crush);
    saveg_write32(plat->tag);
    saveg_write32(plat->type);
    saveg_write32(plat->thinker.function.acp1 != NULL ? 1 : 0);
}
コード例 #16
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_quake_t(quake_t* quake) {
    saveg_write32(quake->tics);
}
コード例 #17
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_lightflash_t(lightflash_t* lf) {
    saveg_write32(lf->sector - sectors);
    saveg_write32(lf->count);
    saveg_write32(lf->special);
}
コード例 #18
0
ファイル: p_saveg.c プロジェクト: GhostlyDeath/chocolate-doom
static void saveg_writep(void *p)
{
    saveg_write32((intptr_t) p);
}
コード例 #19
0
ファイル: p_saveg.c プロジェクト: directhex/doom64
static void saveg_write_fireflicker_t(fireflicker_t* ff) {
    saveg_write32(ff->sector - sectors);
    saveg_write32(ff->count);
    saveg_write32(ff->special);
}
コード例 #20
0
ファイル: p_saveg.c プロジェクト: GhostlyDeath/chocolate-doom
static void saveg_write_player_t(player_t *str)
{
    int i;

    // mobj_t* mo;
    saveg_writep(str->mo);

    // playerstate_t playerstate;
    saveg_write_enum(str->playerstate);

    // ticcmd_t cmd;
    saveg_write_ticcmd_t(&str->cmd);

    // fixed_t viewz;
    saveg_write32(str->viewz);

    // fixed_t viewheight;
    saveg_write32(str->viewheight);

    // fixed_t deltaviewheight;
    saveg_write32(str->deltaviewheight);

    // fixed_t bob;
    saveg_write32(str->bob);

    // int health;
    saveg_write32(str->health);

    // int armorpoints;
    saveg_write32(str->armorpoints);

    // int armortype;
    saveg_write32(str->armortype);

    // int powers[NUMPOWERS];
    for (i=0; i<NUMPOWERS; ++i)
    {
        saveg_write32(str->powers[i]);
    }

    // boolean cards[NUMCARDS];
    for (i=0; i<NUMCARDS; ++i)
    {
        saveg_write32(str->cards[i]);
    }

    // boolean backpack;
    saveg_write32(str->backpack);

    // int frags[MAXPLAYERS];
    for (i=0; i<MAXPLAYERS; ++i)
    {
        saveg_write32(str->frags[i]);
    }

    // weapontype_t readyweapon;
    saveg_write_enum(str->readyweapon);

    // weapontype_t pendingweapon;
    saveg_write_enum(str->pendingweapon);

    // boolean weaponowned[NUMWEAPONS];
    for (i=0; i<NUMWEAPONS; ++i)
    {
        saveg_write32(str->weaponowned[i]);
    }

    // int ammo[NUMAMMO];
    for (i=0; i<NUMAMMO; ++i)
    {
        saveg_write32(str->ammo[i]);
    }

    // int maxammo[NUMAMMO];
    for (i=0; i<NUMAMMO; ++i)
    {
        saveg_write32(str->maxammo[i]);
    }

    // int attackdown;
    saveg_write32(str->attackdown);

    // int usedown;
    saveg_write32(str->usedown);

    // int cheats;
    saveg_write32(str->cheats);

    // int refire;
    saveg_write32(str->refire);

    // int killcount;
    saveg_write32(str->killcount);

    // int itemcount;
    saveg_write32(str->itemcount);

    // int secretcount;
    saveg_write32(str->secretcount);

    // char* message;
    saveg_writep(str->message);

    // int damagecount;
    saveg_write32(str->damagecount);

    // int bonuscount;
    saveg_write32(str->bonuscount);

    // mobj_t* attacker;
    saveg_writep(str->attacker);

    // int extralight;
    saveg_write32(str->extralight);

    // int fixedcolormap;
    saveg_write32(str->fixedcolormap);

    // int colormap;
    saveg_write32(str->colormap);

    // pspdef_t psprites[NUMPSPRITES];
    for (i=0; i<NUMPSPRITES; ++i)
    {
        saveg_write_pspdef_t(&str->psprites[i]);
    }

    // boolean didsecret;
    saveg_write32(str->didsecret);
}
コード例 #21
0
ファイル: p_saveg.c プロジェクト: Azarien/chocolate-doom
static void saveg_write_inventory_t(inventory_t *str)
{
    saveg_write32(str->sprite);
    saveg_write32(str->type);
    saveg_write32(str->amount);
}