diff --git a/port/pdextract/ext_setups.c b/port/pdextract/ext_setups.c new file mode 100644 index 000000000..ea8745e72 --- /dev/null +++ b/port/pdextract/ext_setups.c @@ -0,0 +1,1284 @@ +#include +#include +#include + +#include "common.h" +#include "system.h" +#include "assert.h" +#include "setups_decl.h" + +#include "types.h" + +static inline f32 convF32(f32 *dst, f32 src) { *(u32*)dst = srctoh32(*(u32*)&src); } +static inline u32 convU32(u32 *dst, u32 src) { *dst = srctoh32(src); } +static inline s32 convS32(s32 *dst, s32 src) { *dst = srctoh32(src); } +static inline u16 convU16(u16 *dst, u32 src) { *dst = srctoh16(src); } +static inline s16 convS16(s16 *dst, s32 src) { *dst = srctoh16(src); } +static inline u8 cpyByte(u8 *dst, u8 src) { *dst = src; } +static inline void* convPtr(void** dst, u32 src) { *dst = srctoh32(src); } +static inline struct coord convCoord(struct coord* dst, struct n64_coord src) { convF32(&dst->x, src.x); convF32(&dst->y, src.y); convF32(&dst->z, src.z); } +static u32 convUnk(void* x, u32 y) { __debugbreak(); } + +#define PD_CONV_VAL(dst, src) _Generic((dst), \ + f32: convF32, \ + u32: convU32, \ + s32: convS32, \ + u16: convU16, \ + s16: convS16, \ + u8: cpyByte, \ + s8: cpyByte, \ + struct coord: convCoord, \ + default: convUnk \ +)(&dst, src) + +#define PD_CONV_ARRAY(dst, src) { for (int i = 0; i < ARRAYCOUNT(dst); i++) PD_CONV_VAL(dst[i], src[i]); } +#define PD_CONV_ARRAY2D(dst, src) { \ + for (int i = 0; i < ARRAYCOUNT(dst); i++) \ + for (int j = 0; j < ARRAYCOUNT(dst); j++) PD_CONV_VAL(dst[i][j], src[i][j]); \ +} + +#define PD_CONV_PTR(dst, src) dst = srctoh32(src) + +u32 obj_size(struct n64_defaultobj *obj) +{ + switch (obj->type) { + case OBJTYPE_CHR: return sizeof(struct n64_packedchr) / sizeof(u32); + case OBJTYPE_DOOR: return sizeof(struct n64_doorobj) / sizeof(u32); + case OBJTYPE_DOORSCALE: return sizeof(struct n64_doorscaleobj) / sizeof(u32); + case OBJTYPE_BASIC: return sizeof(struct n64_defaultobj) / sizeof(u32); + case OBJTYPE_DEBRIS: return sizeof(struct n64_debrisobj) / sizeof(u32); + case OBJTYPE_GLASS: return sizeof(struct n64_glassobj) / sizeof(u32); + case OBJTYPE_TINTEDGLASS: return sizeof(struct n64_tintedglassobj) / sizeof(u32); + case OBJTYPE_SAFE: return sizeof(struct n64_safeobj) / sizeof(u32); + case OBJTYPE_GASBOTTLE: return sizeof(struct gasbottleobj) / sizeof(u32); + case OBJTYPE_KEY: return sizeof(struct n64_keyobj) / sizeof(u32); + case OBJTYPE_ALARM: return sizeof(struct n64_alarmobj) / sizeof(u32); + case OBJTYPE_CCTV: return sizeof(struct n64_cctvobj) / sizeof(u32); + case OBJTYPE_AMMOCRATE: return sizeof(struct n64_ammocrateobj) / sizeof(u32); + case OBJTYPE_WEAPON: return sizeof(struct n64_weaponobj) / sizeof(u32); + case OBJTYPE_SINGLEMONITOR: return sizeof(struct n64_singlemonitorobj) / sizeof(u32); + case OBJTYPE_MULTIMONITOR: return sizeof(struct n64_multimonitorobj) / sizeof(u32); + case OBJTYPE_HANGINGMONITORS: return sizeof(struct n64_hangingmonitorsobj) / sizeof(u32); + case OBJTYPE_AUTOGUN: return sizeof(struct n64_autogunobj) / sizeof(u32); + case OBJTYPE_LINKGUNS: return sizeof(struct linkgunsobj) / sizeof(u32); + case OBJTYPE_HAT: return sizeof(struct n64_hatobj) / sizeof(u32); + case OBJTYPE_GRENADEPROB: return sizeof(struct grenadeprobobj) / sizeof(u32); + case OBJTYPE_LINKLIFTDOOR: return sizeof(struct n64_linkliftdoorobj) / sizeof(u32); + case OBJTYPE_SAFEITEM: return sizeof(struct n64_safeitemobj) / sizeof(u32); + case OBJTYPE_MULTIAMMOCRATE: return sizeof(struct n64_multiammocrateobj) / sizeof(u32); + case OBJTYPE_SHIELD: return sizeof(struct n64_shieldobj) / sizeof(u32); + case OBJTYPE_TAG: return sizeof(struct n64_tag) / sizeof(u32); + case OBJTYPE_RENAMEOBJ: return sizeof(struct n64_textoverride) / sizeof(u32); + case OBJTYPE_BEGINOBJECTIVE: return sizeof(struct n64_objective) / sizeof(u32); + case OBJTYPE_ENDOBJECTIVE: return 1; + case OBJECTIVETYPE_DESTROYOBJ: return 2; + case OBJECTIVETYPE_COMPFLAGS: return 2; + case OBJECTIVETYPE_FAILFLAGS: return 2; + case OBJECTIVETYPE_COLLECTOBJ: return 2; + case OBJECTIVETYPE_THROWOBJ: return 2; + case OBJECTIVETYPE_HOLOGRAPH: return sizeof(struct n64_criteria_holograph) / sizeof(u32); + case OBJECTIVETYPE_1F: return 1; + case OBJECTIVETYPE_ENTERROOM: return sizeof(struct n64_criteria_roomentered) / sizeof(u32); + case OBJECTIVETYPE_THROWINROOM: return sizeof(struct n64_criteria_throwinroom) / sizeof(u32); + case OBJTYPE_22: return 1; + case OBJTYPE_BRIEFING: return sizeof(struct n64_briefingobj) / sizeof(u32); + case OBJTYPE_PADLOCKEDDOOR: return sizeof(struct n64_padlockeddoorobj) / sizeof(u32); + case OBJTYPE_TRUCK: return sizeof(struct n64_truckobj) / sizeof(u32); + case OBJTYPE_HELI: return sizeof(struct n64_heliobj) / sizeof(u32); + case OBJTYPE_TANK: return 32; + case OBJTYPE_CAMERAPOS: return sizeof(struct n64_cameraposobj) / sizeof(u32); + case OBJTYPE_LIFT: return sizeof(struct n64_liftobj) / sizeof(u32); + case OBJTYPE_CONDITIONALSCENERY: return sizeof(struct n64_linksceneryobj) / sizeof(u32); + case OBJTYPE_BLOCKEDPATH: return sizeof(struct n64_blockedpathobj) / sizeof(u32); + case OBJTYPE_HOVERBIKE: return sizeof(struct n64_hoverbikeobj) / sizeof(u32); + case OBJTYPE_HOVERPROP: return sizeof(struct n64_hoverpropobj) / sizeof(u32); + case OBJTYPE_FAN: return sizeof(struct n64_fanobj) / sizeof(u32); + case OBJTYPE_HOVERCAR: return sizeof(struct n64_hovercarobj) / sizeof(u32); + case OBJTYPE_CHOPPER: return sizeof(struct n64_chopperobj) / sizeof(u32); + case OBJTYPE_PADEFFECT: return sizeof(struct padeffectobj) / sizeof(u32); + case OBJTYPE_MINE: return sizeof(struct n64_weaponobj) / sizeof(u32); + case OBJTYPE_ESCASTEP: return sizeof(struct n64_escalatorobj) / sizeof(u32); + } + + return 1; +} + + +void conv_tvscreen(struct tvscreen* dstobj, struct n64_tvscreen* srcobj) +{ + PD_CONV_PTR(dstobj->cmdlist, srcobj->ptr_cmdlist); + PD_CONV_VAL(dstobj->offset, srcobj->offset); + PD_CONV_VAL(dstobj->pause60, srcobj->pause60); + PD_CONV_PTR(dstobj->tconfig, srcobj->ptr_tconfig); + PD_CONV_VAL(dstobj->rot, srcobj->rot); + PD_CONV_VAL(dstobj->xscale, srcobj->xscale); + PD_CONV_VAL(dstobj->xscalefrac, srcobj->xscalefrac); + PD_CONV_VAL(dstobj->xscaleinc, srcobj->xscaleinc); + PD_CONV_VAL(dstobj->xscaleold, srcobj->xscaleold); + PD_CONV_VAL(dstobj->xscalenew, srcobj->xscalenew); + PD_CONV_VAL(dstobj->yscale, srcobj->yscale); + PD_CONV_VAL(dstobj->yscalefrac, srcobj->yscalefrac); + PD_CONV_VAL(dstobj->yscaleinc, srcobj->yscaleinc); + PD_CONV_VAL(dstobj->yscaleold, srcobj->yscaleold); + PD_CONV_VAL(dstobj->yscalenew, srcobj->yscalenew); + PD_CONV_VAL(dstobj->xmid, srcobj->xmid); + PD_CONV_VAL(dstobj->xmidfrac, srcobj->xmidfrac); + PD_CONV_VAL(dstobj->xmidinc, srcobj->xmidinc); + PD_CONV_VAL(dstobj->xmidold, srcobj->xmidold); + PD_CONV_VAL(dstobj->xmidnew, srcobj->xmidnew); + PD_CONV_VAL(dstobj->ymid, srcobj->ymid); + PD_CONV_VAL(dstobj->ymidfrac, srcobj->ymidfrac); + PD_CONV_VAL(dstobj->ymidinc, srcobj->ymidinc); + PD_CONV_VAL(dstobj->ymidold, srcobj->ymidold); + PD_CONV_VAL(dstobj->ymidnew, srcobj->ymidnew); + PD_CONV_VAL(dstobj->red, srcobj->red); + PD_CONV_VAL(dstobj->redold, srcobj->redold); + PD_CONV_VAL(dstobj->rednew, srcobj->rednew); + PD_CONV_VAL(dstobj->green, srcobj->green); + PD_CONV_VAL(dstobj->greenold, srcobj->greenold); + PD_CONV_VAL(dstobj->greennew, srcobj->greennew); + PD_CONV_VAL(dstobj->blue, srcobj->blue); + PD_CONV_VAL(dstobj->blueold, srcobj->blueold); + PD_CONV_VAL(dstobj->bluenew, srcobj->bluenew); + PD_CONV_VAL(dstobj->alpha, srcobj->alpha); + PD_CONV_VAL(dstobj->alphaold, srcobj->alphaold); + PD_CONV_VAL(dstobj->alphanew, srcobj->alphanew); + PD_CONV_VAL(dstobj->colfrac, srcobj->colfrac); + PD_CONV_VAL(dstobj->colinc, srcobj->colinc); +} + +void conv_default_obj_hdr(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +{ + PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); + + /* 'header' is like this inside a u32: + u16 unk00_1, + u8 unk00_2, + u8 type, + */ + u16 *dst_unk00_1 = (u16*)&dstobj->extrascale; + u8 *dst_unk00_2 = (u8*)(dst_unk00_1 + 1); + + u16 *src_unk00_1 = (u16*)&srcobj->extrascale; + u8 *src_unk00_2 = (u8*)(src_unk00_1 + 1); + + *dst_unk00_1 = srctoh16(*src_unk00_1); + dst_unk00_2[0] = src_unk00_2[0]; + dst_unk00_2[1] = src_unk00_2[1]; +} + +void conv_default_obj(struct defaultobj* dstobj, struct n64_defaultobj* srcobj) +{ + PD_CONV_VAL(dstobj->extrascale, srcobj->extrascale); + PD_CONV_VAL(dstobj->hidden2, srcobj->hidden2); + PD_CONV_VAL(dstobj->type, srcobj->type); + PD_CONV_VAL(dstobj->modelnum, srcobj->modelnum); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->flags2, srcobj->flags2); + PD_CONV_VAL(dstobj->flags3, srcobj->flags3); + PD_CONV_PTR(dstobj->prop, srcobj->ptr_prop); + PD_CONV_PTR(dstobj->model, srcobj->ptr_model); + PD_CONV_ARRAY2D(dstobj->realrot, srcobj->realrot); + PD_CONV_VAL(dstobj->hidden, srcobj->hidden); + PD_CONV_PTR(dstobj->unkgeo, srcobj->ptr_unkgeo); + PD_CONV_PTR(dstobj->embedment, srcobj->ptr_embedment); + PD_CONV_VAL(dstobj->damage, srcobj->damage); + PD_CONV_VAL(dstobj->maxdamage, srcobj->maxdamage); + PD_CONV_ARRAY(dstobj->shadecol, srcobj->shadecol); + PD_CONV_ARRAY(dstobj->nextcol, srcobj->nextcol); + PD_CONV_VAL(dstobj->floorcol, srcobj->floorcol); + PD_CONV_VAL(dstobj->geocount, srcobj->geocount); +} + +u32 convert_props(u8* dst, u8* src) +{ + u8* start = dst; + struct n64_defaultobj* cmd = (struct n64_defaultobj*)src; + + int i = 0; + u8 type = cmd->type; + + while (type != OBJTYPE_END) { + //sysLogPrintf(LOG_NOTE, "#%03d obj 0x%02x (%s)", ++i, type, objName(cmd)); + switch (type) { + case OBJTYPE_DOOR: + { + struct n64_doorobj* srcobj = (struct n64_doorobj*)cmd; + struct doorobj* dstobj = (struct doorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->maxfrac, srcobj->maxfrac); + PD_CONV_VAL(dstobj->perimfrac, srcobj->perimfrac); + PD_CONV_VAL(dstobj->accel, srcobj->accel); + PD_CONV_VAL(dstobj->decel, srcobj->decel); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->doorflags, srcobj->doorflags); + PD_CONV_VAL(dstobj->doortype, srcobj->doortype); + PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); + PD_CONV_VAL(dstobj->autoclosetime, srcobj->autoclosetime); + PD_CONV_VAL(dstobj->frac, srcobj->frac); + PD_CONV_VAL(dstobj->fracspeed, srcobj->fracspeed); + PD_CONV_VAL(dstobj->mode, srcobj->mode); + PD_CONV_VAL(dstobj->glasshits, srcobj->glasshits); + PD_CONV_VAL(dstobj->fadealpha, srcobj->fadealpha); + PD_CONV_VAL(dstobj->xludist, srcobj->xludist); + PD_CONV_VAL(dstobj->opadist, srcobj->opadist); + PD_CONV_VAL(dstobj->startpos, srcobj->startpos); + PD_CONV_ARRAY2D(dstobj->mtx98, srcobj->mtx98); + PD_CONV_PTR(dstobj->sibling, srcobj->ptr_sibling); + PD_CONV_VAL(dstobj->lastopen60, srcobj->lastopen60); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); + PD_CONV_VAL(dstobj->fadetime60, srcobj->fadetime60); + PD_CONV_VAL(dstobj->lastcalc60, srcobj->lastcalc60); + PD_CONV_VAL(dstobj->laserfade, srcobj->laserfade); + PD_CONV_ARRAY(dstobj->unusedmaybe, srcobj->unusedmaybe); + PD_CONV_ARRAY(dstobj->shadeinfo1, srcobj->shadeinfo1); + PD_CONV_ARRAY(dstobj->shadeinfo2, srcobj->shadeinfo2); + + PD_CONV_VAL(dstobj->actual1, srcobj->actual1); + PD_CONV_VAL(dstobj->actual2, srcobj->actual2); + PD_CONV_VAL(dstobj->extra1, srcobj->extra1); + PD_CONV_VAL(dstobj->extra2, srcobj->extra2); + + dst += sizeof(struct doorobj); + break; + } + case OBJTYPE_DOORSCALE: + { + struct n64_doorscaleobj* srcobj = (struct n64_doorscaleobj*)cmd; + struct doorscaleobj* dstobj = (struct doorscaleobj*)dst; + + dstobj->unk00 = htobe32(srcobj->unk00); + PD_CONV_VAL(dstobj->scale, srcobj->scale); + + dst += sizeof(struct doorscaleobj); + break; + } + case OBJTYPE_BASIC: + case OBJTYPE_HANGINGMONITORS: + case OBJTYPE_DEBRIS: + case OBJTYPE_HAT: + case OBJTYPE_ALARM: + { + struct n64_defaultobj* srcobj = (struct n64_defaultobj*)cmd; + struct defaultobj* dstobj = (struct defaultobj*)dst; + + conv_default_obj(dstobj, cmd); + + dst += sizeof(struct defaultobj); + break; + } + case OBJTYPE_KEY: + { + struct n64_keyobj* srcobj = (struct n64_keyobj*)cmd; + struct keyobj* dstobj = (struct keyobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->keyflags, srcobj->keyflags); + + dst += sizeof(struct keyobj); + src += sizeof(struct n64_keyobj); + break; + } + case OBJTYPE_CCTV: + { + struct n64_cctvobj* srcobj = (struct n64_cctvobj*)cmd; + struct cctvobj* dstobj = (struct cctvobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->lookatpadnum, srcobj->lookatpadnum); + PD_CONV_VAL(dstobj->toleft, srcobj->toleft); + PD_CONV_VAL(dstobj->yzero, srcobj->yzero); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yleft, srcobj->yleft); + PD_CONV_VAL(dstobj->yright, srcobj->yright); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); + PD_CONV_VAL(dstobj->seebondtime60, srcobj->seebondtime60); + PD_CONV_VAL(dstobj->maxdist, srcobj->maxdist); + PD_CONV_VAL(dstobj->xzero, srcobj->xzero); + + dst += sizeof(struct cctvobj); + break; + } + case OBJTYPE_AMMOCRATE: + { + struct n64_ammocrateobj* srcobj = (struct n64_ammocrateobj*)cmd; + struct ammocrateobj* dstobj = (struct ammocrateobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->ammotype, srcobj->ammotype); + + dst += sizeof(struct ammocrateobj); + break; + } + case OBJTYPE_WEAPON: + case OBJTYPE_MINE: + { + struct n64_weaponobj* srcobj = (struct n64_weaponobj*)cmd; + struct weaponobj* dstobj = (struct weaponobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->weaponnum, srcobj->weaponnum); + PD_CONV_VAL(dstobj->unk5d, srcobj->unk5d); + PD_CONV_VAL(dstobj->unk5e, srcobj->unk5e); + PD_CONV_VAL(dstobj->gunfunc, srcobj->gunfunc); + + PD_CONV_VAL(dstobj->fadeouttimer60, srcobj->fadeouttimer60); + PD_CONV_VAL(dstobj->dualweaponnum, srcobj->dualweaponnum); + + PD_CONV_VAL(dstobj->team, srcobj->team); + + PD_CONV_PTR(dstobj->dualweapon, srcobj->ptr_dualweapon); + + dst += sizeof(struct weaponobj); + break; + } + case OBJTYPE_CHR: + { + struct n64_packedchr* srcobj = (struct n64_packedchr*)cmd; + struct packedchr* dstobj = (struct packedchr*)dst; + + PD_CONV_VAL(dstobj->chrindex, srcobj->chrindex); + PD_CONV_VAL(dstobj->unk02, srcobj->unk02); + PD_CONV_VAL(dstobj->typenum, srcobj->typenum); + PD_CONV_VAL(dstobj->spawnflags, srcobj->spawnflags); + PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); + PD_CONV_VAL(dstobj->padnum, srcobj->padnum); + PD_CONV_VAL(dstobj->bodynum, srcobj->bodynum); + PD_CONV_VAL(dstobj->headnum, srcobj->headnum); + PD_CONV_VAL(dstobj->ailistnum, srcobj->ailistnum); + PD_CONV_VAL(dstobj->padpreset, srcobj->padpreset); + PD_CONV_VAL(dstobj->chrpreset, srcobj->chrpreset); + PD_CONV_VAL(dstobj->hearscale, srcobj->hearscale); + PD_CONV_VAL(dstobj->viewdist, srcobj->viewdist); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->flags2, srcobj->flags2); + PD_CONV_VAL(dstobj->team, srcobj->team); + PD_CONV_VAL(dstobj->squadron, srcobj->squadron); + PD_CONV_VAL(dstobj->chair, srcobj->chair); + PD_CONV_VAL(dstobj->convtalk, srcobj->convtalk); + PD_CONV_VAL(dstobj->tude, srcobj->tude); + PD_CONV_VAL(dstobj->naturalanim, srcobj->naturalanim); + PD_CONV_VAL(dstobj->yvisang, srcobj->yvisang); + PD_CONV_VAL(dstobj->teamscandist, srcobj->teamscandist); + + dst += sizeof(struct packedchr); + break; + } + case OBJTYPE_SINGLEMONITOR: + { + struct n64_singlemonitorobj* srcobj = (struct n64_singlemonitorobj*)cmd; + struct singlemonitorobj* dstobj = (struct singlemonitorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + conv_tvscreen(&dstobj->screen, &srcobj->screen); + + PD_CONV_VAL(dstobj->owneroffset, srcobj->owneroffset); + PD_CONV_VAL(dstobj->ownerpart, srcobj->ownerpart); + PD_CONV_VAL(dstobj->imagenum, srcobj->imagenum); + + dst += sizeof(struct singlemonitorobj); + break; + } + case OBJTYPE_MULTIMONITOR: + { + struct n64_multimonitorobj* srcobj = (struct n64_multimonitorobj*)cmd; + struct multimonitorobj* dstobj = (struct multimonitorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + for (size_t i = 0; i < 4; i++) + conv_tvscreen(&dstobj->screens[i], &srcobj->screens[i]); + + PD_CONV_ARRAY(dstobj->imagenums, srcobj->imagenums); + dst += sizeof(struct multimonitorobj); + break; + } + case OBJTYPE_AUTOGUN: + { + struct n64_autogunobj* srcobj = (struct n64_autogunobj*)cmd; + struct autogunobj* dstobj = (struct autogunobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->targetpad, srcobj->targetpad); + PD_CONV_VAL(dstobj->firing, srcobj->firing); + PD_CONV_VAL(dstobj->firecount, srcobj->firecount); + PD_CONV_VAL(dstobj->yzero, srcobj->yzero); + PD_CONV_VAL(dstobj->ymaxleft, srcobj->ymaxleft); + PD_CONV_VAL(dstobj->ymaxright, srcobj->ymaxright); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->xzero, srcobj->xzero); + PD_CONV_VAL(dstobj->xrot, srcobj->xrot); + PD_CONV_VAL(dstobj->xspeed, srcobj->xspeed); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->aimdist, srcobj->aimdist); + PD_CONV_VAL(dstobj->barrelspeed, srcobj->barrelspeed); + PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); + PD_CONV_VAL(dstobj->lastseebond60, srcobj->lastseebond60); + PD_CONV_VAL(dstobj->lastaimbond60, srcobj->lastaimbond60); + PD_CONV_VAL(dstobj->allowsoundframe, srcobj->allowsoundframe); + PD_CONV_PTR(dstobj->beam, srcobj->ptr_beam); + PD_CONV_VAL(dstobj->shotbondsum, srcobj->shotbondsum); + PD_CONV_PTR(dstobj->target, srcobj->ptr_target); + PD_CONV_VAL(dstobj->targetteam, srcobj->targetteam); + PD_CONV_VAL(dstobj->ammoquantity, srcobj->ammoquantity); + PD_CONV_VAL(dstobj->nextchrtest, srcobj->nextchrtest); + + dst += sizeof(struct autogunobj); + break; + } + case OBJTYPE_LINKGUNS: + { + struct n64_linkgunsobj* srcobj = (struct n64_linkgunsobj*)cmd; + struct linkgunsobj* dstobj = (struct linkgunsobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->offset1, srcobj->offset1); + PD_CONV_VAL(dstobj->offset2, srcobj->offset2); + + dst += sizeof(struct linkgunsobj); + break; + } + case OBJTYPE_GRENADEPROB: + { + struct n64_grenadeprobobj* srcobj = (struct n64_grenadeprobobj*)cmd; + struct grenadeprobobj* dstobj = (struct grenadeprobobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->chrnum, srcobj->chrnum); + PD_CONV_VAL(dstobj->probability, srcobj->probability); + + dst += sizeof(struct grenadeprobobj); + break; + } + case OBJTYPE_LINKLIFTDOOR: + { + struct n64_linkliftdoorobj* srcobj = (struct n64_linkliftdoorobj*)cmd; + struct linkliftdoorobj* dstobj = (struct linkliftdoorobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->lift, srcobj->ptr_lift); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_VAL(dstobj->stopnum, srcobj->stopnum); + + dst += sizeof(struct linkliftdoorobj); + break; + } + case OBJTYPE_MULTIAMMOCRATE: + { + struct n64_multiammocrateobj* srcobj = (struct n64_multiammocrateobj*)cmd; + struct multiammocrateobj* dstobj = (struct multiammocrateobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + for (size_t i = 0; i < 19; i++) { + PD_CONV_VAL(dstobj->slots[i].modelnum, srcobj->slots[i].modelnum); + PD_CONV_VAL(dstobj->slots[i].quantity, srcobj->slots[i].quantity); + } + + dst += sizeof(struct multiammocrateobj); + break; + } + case OBJTYPE_SHIELD: + { + struct n64_shieldobj* srcobj = (struct n64_shieldobj*)cmd; + struct shieldobj* dstobj = (struct shieldobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->initialamount, srcobj->initialamount); + PD_CONV_VAL(dstobj->amount, srcobj->amount); + PD_CONV_VAL(dstobj->unk64, srcobj->unk64); + + dst += sizeof(struct shieldobj); + break; + } + case OBJTYPE_TAG: + { + struct n64_tag* srcobj = (struct n64_tag*)cmd; + struct tag* dstobj = (struct tag*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->tagnum, srcobj->tagnum); + PD_CONV_VAL(dstobj->cmdoffset, srcobj->cmdoffset); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + + dst += sizeof(struct tag); + break; + } + case OBJTYPE_BEGINOBJECTIVE: + { + struct n64_objective* srcobj = (struct n64_objective*)cmd; + struct objective* dstobj = (struct objective*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->index, srcobj->index); + PD_CONV_VAL(dstobj->text, srcobj->text); + PD_CONV_VAL(dstobj->unk0c, srcobj->unk0c); + PD_CONV_VAL(dstobj->flags, srcobj->flags); + PD_CONV_VAL(dstobj->difficulties, srcobj->difficulties); + + dst += sizeof(struct objective); + break; + } + case OBJTYPE_ENDOBJECTIVE: + case OBJECTIVETYPE_1F: + case OBJTYPE_22: + case OBJTYPE_GASBOTTLE: + case OBJTYPE_29: + case OBJTYPE_SAFE: + { + struct n64_stdobjective* srcobj = (struct n64_stdobjective*)cmd; + struct n64_stdobjective* dstobj = (struct n64_stdobjective*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + + dst += sizeof(struct n64_stdobjective); + break; + } + case OBJECTIVETYPE_DESTROYOBJ: + case OBJECTIVETYPE_COMPFLAGS: + case OBJECTIVETYPE_FAILFLAGS: + case OBJECTIVETYPE_COLLECTOBJ: + case OBJECTIVETYPE_THROWOBJ: + { + struct n64_objectivecmd* srcobj = (struct n64_objectivecmd*)cmd; + struct n64_objectivecmd* dstobj = (struct n64_objectivecmd*)dst; + + PD_CONV_ARRAY(dstobj->cmd0, srcobj->cmd0); + PD_CONV_VAL(dstobj->cmd1, srcobj->cmd1); + + dst += sizeof(struct n64_objectivecmd); + break; + } + case OBJECTIVETYPE_HOLOGRAPH: + { + struct n64_criteria_holograph* srcobj = (struct n64_criteria_holograph*)cmd; + struct criteria_holograph* dstobj = (struct criteria_holograph*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->obj, srcobj->obj); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_holograph); + break; + } + case OBJECTIVETYPE_ENTERROOM: + { + struct n64_criteria_roomentered* srcobj = (struct n64_criteria_roomentered*)cmd; + struct criteria_roomentered* dstobj = (struct criteria_roomentered*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_roomentered); + break; + } + case OBJECTIVETYPE_THROWINROOM: + { + struct n64_criteria_throwinroom* srcobj = (struct n64_criteria_throwinroom*)cmd; + struct criteria_throwinroom* dstobj = (struct criteria_throwinroom*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct criteria_throwinroom); + break; + } + case OBJTYPE_BRIEFING: + { + struct n64_briefingobj* srcobj = (struct n64_briefingobj*)cmd; + struct briefingobj* dstobj = (struct briefingobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->type, srcobj->type); + PD_CONV_VAL(dstobj->text, srcobj->text); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct briefingobj); + break; + } + case OBJTYPE_RENAMEOBJ: + { + struct n64_textoverride* srcobj = (struct n64_textoverride*)cmd; + struct textoverride* dstobj = (struct textoverride*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->objoffset, srcobj->objoffset); + PD_CONV_VAL(dstobj->weapon, srcobj->weapon); + PD_CONV_VAL(dstobj->obtaintext, srcobj->obtaintext); + PD_CONV_VAL(dstobj->ownertext, srcobj->ownertext); + PD_CONV_VAL(dstobj->inventorytext, srcobj->inventorytext); + PD_CONV_VAL(dstobj->inventory2text, srcobj->inventory2text); + PD_CONV_VAL(dstobj->pickuptext, srcobj->pickuptext); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + PD_CONV_PTR(dstobj->obj, srcobj->ptr_obj); + + dst += sizeof(struct textoverride); + break; + } + case OBJTYPE_PADLOCKEDDOOR: + { + struct n64_padlockeddoorobj* srcobj = (struct n64_padlockeddoorobj*)cmd; + struct padlockeddoorobj* dstobj = (struct padlockeddoorobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->lock, srcobj->ptr_lock); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct padlockeddoorobj); + break; + } + case OBJTYPE_TRUCK: + { + struct n64_truckobj* srcobj = (struct n64_truckobj*)cmd; + struct truckobj* dstobj = (struct truckobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->wheelxrot, srcobj->wheelxrot); + PD_CONV_VAL(dstobj->wheelyrot, srcobj->wheelyrot); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + + dst += sizeof(struct truckobj); + break; + } + case OBJTYPE_HELI: + { + struct n64_heliobj* srcobj = (struct n64_heliobj*)cmd; + struct heliobj* dstobj = (struct heliobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->rotoryrot, srcobj->rotoryrot); + PD_CONV_VAL(dstobj->rotoryspeed, srcobj->rotoryspeed); + PD_CONV_VAL(dstobj->rotoryspeedaim, srcobj->rotoryspeedaim); + PD_CONV_VAL(dstobj->rotoryspeedtime, srcobj->rotoryspeedtime); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + + dst += sizeof(struct heliobj); + break; + } + case OBJTYPE_GLASS: + { + struct n64_glassobj* srcobj = (struct n64_glassobj*)cmd; + struct glassobj* dstobj = (struct glassobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + + dst += sizeof(struct glassobj); + break; + } + case OBJTYPE_SAFEITEM: + { + struct n64_safeitemobj* srcobj = (struct n64_safeitemobj*)cmd; + struct safeitemobj* dstobj = (struct safeitemobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->item, srcobj->ptr_item); + PD_CONV_PTR(dstobj->safe, srcobj->ptr_safe); + PD_CONV_PTR(dstobj->door, srcobj->ptr_door); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct safeitemobj); + break; + } + case OBJTYPE_TANK: + { + dst += sizeof(struct n64_tankobj); + break; + } + case OBJTYPE_CAMERAPOS: + { + struct n64_cameraposobj* srcobj = (struct n64_cameraposobj*)cmd; + struct cameraposobj* dstobj = (struct cameraposobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->x, srcobj->x); + PD_CONV_VAL(dstobj->y, srcobj->y); + PD_CONV_VAL(dstobj->z, srcobj->z); + PD_CONV_VAL(dstobj->theta, srcobj->theta); + PD_CONV_VAL(dstobj->verta, srcobj->verta); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + + dst += sizeof(struct cameraposobj); + break; + } + case OBJTYPE_TINTEDGLASS: + { + struct n64_tintedglassobj* srcobj = (struct n64_tintedglassobj*)cmd; + struct tintedglassobj* dstobj = (struct tintedglassobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->xludist, srcobj->xludist); + PD_CONV_VAL(dstobj->opadist, srcobj->opadist); + PD_CONV_VAL(dstobj->opacity, srcobj->opacity); + PD_CONV_VAL(dstobj->portalnum, srcobj->portalnum); + PD_CONV_VAL(dstobj->unk64, srcobj->unk64); + + dst += sizeof(struct tintedglassobj); + break; + } + case OBJTYPE_LIFT: + { + struct n64_liftobj* srcobj = (struct n64_liftobj*)cmd; + struct liftobj* dstobj = (struct liftobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_ARRAY(dstobj->pads, srcobj->pads); + for (int k = 0; k < 4; k++) + PD_CONV_PTR(dstobj->doors[k], srcobj->ptr_doors[k]); + PD_CONV_VAL(dstobj->dist, srcobj->dist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->accel, srcobj->accel); + PD_CONV_VAL(dstobj->maxspeed, srcobj->maxspeed); + PD_CONV_VAL(dstobj->soundtype, srcobj->soundtype); + PD_CONV_VAL(dstobj->levelcur, srcobj->levelcur); + PD_CONV_VAL(dstobj->levelaim, srcobj->levelaim); + PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); + + dst += sizeof(struct liftobj); + break; + } + case OBJTYPE_CONDITIONALSCENERY: + { + struct n64_linksceneryobj* srcobj = (struct n64_linksceneryobj*)cmd; + struct linksceneryobj* dstobj = (struct linksceneryobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->trigger, srcobj->ptr_trigger); + PD_CONV_PTR(dstobj->unexp, srcobj->ptr_unexp); + PD_CONV_PTR(dstobj->exp, srcobj->ptr_exp); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct linksceneryobj); + break; + } + case OBJTYPE_BLOCKEDPATH: + { + struct n64_blockedpathobj* srcobj = (struct n64_blockedpathobj*)cmd; + struct blockedpathobj* dstobj = (struct blockedpathobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_PTR(dstobj->blocker, srcobj->ptr_blocker); + PD_CONV_VAL(dstobj->waypoint1, srcobj->waypoint1); + PD_CONV_VAL(dstobj->waypoint2, srcobj->waypoint2); + PD_CONV_PTR(dstobj->next, srcobj->ptr_next); + + dst += sizeof(struct blockedpathobj); + break; + } + case OBJTYPE_HOVERBIKE: { + struct n64_hoverbikeobj* srcobj = (struct n64_hoverbikeobj*)cmd; + struct hoverbikeobj* dstobj = (struct hoverbikeobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); + PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); + PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); + PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); + PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); + PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); + PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); + PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); + PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); + PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); + PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); + PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); + PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); + PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); + PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); + PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); + PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); + + PD_CONV_ARRAY(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->exreal, srcobj->exreal); + PD_CONV_VAL(dstobj->ezreal, srcobj->ezreal); + PD_CONV_VAL(dstobj->ezreal2, srcobj->ezreal2); + PD_CONV_VAL(dstobj->leanspeed, srcobj->leanspeed); + PD_CONV_VAL(dstobj->leandiff, srcobj->leandiff); + PD_CONV_VAL(dstobj->maxspeedtime240, srcobj->maxspeedtime240); + PD_CONV_ARRAY(dstobj->prevpos, srcobj->prevpos); + PD_CONV_ARRAY(dstobj->rels, srcobj->rels); + PD_CONV_ARRAY(dstobj->speedabs, srcobj->speedabs); + PD_CONV_ARRAY(dstobj->speedrel, srcobj->speedrel); + + dst += sizeof(struct hoverbikeobj); + break; + } + case OBJTYPE_HOVERPROP: + { + struct n64_hoverpropobj* srcobj = (struct n64_hoverpropobj*)cmd; + struct hoverpropobj* dstobj = (struct hoverpropobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->hov.type, srcobj->hov.type); + PD_CONV_VAL(dstobj->hov.flags, srcobj->hov.flags); + PD_CONV_VAL(dstobj->hov.bobycur, srcobj->hov.bobycur); + PD_CONV_VAL(dstobj->hov.bobytarget, srcobj->hov.bobytarget); + PD_CONV_VAL(dstobj->hov.bobyspeed, srcobj->hov.bobyspeed); + PD_CONV_VAL(dstobj->hov.yrot, srcobj->hov.yrot); + PD_CONV_VAL(dstobj->hov.bobpitchcur, srcobj->hov.bobpitchcur); + PD_CONV_VAL(dstobj->hov.bobpitchtarget, srcobj->hov.bobpitchtarget); + PD_CONV_VAL(dstobj->hov.bobpitchspeed, srcobj->hov.bobpitchspeed); + PD_CONV_VAL(dstobj->hov.bobrollcur, srcobj->hov.bobrollcur); + PD_CONV_VAL(dstobj->hov.bobrolltarget, srcobj->hov.bobrolltarget); + PD_CONV_VAL(dstobj->hov.bobrollspeed, srcobj->hov.bobrollspeed); + PD_CONV_VAL(dstobj->hov.groundpitch, srcobj->hov.groundpitch); + PD_CONV_VAL(dstobj->hov.y, srcobj->hov.y); + PD_CONV_VAL(dstobj->hov.ground, srcobj->hov.ground); + PD_CONV_VAL(dstobj->hov.prevframe60, srcobj->hov.prevframe60); + PD_CONV_VAL(dstobj->hov.prevgroundframe60, srcobj->hov.prevgroundframe60); + + dst += sizeof(struct hoverpropobj); + break; + } + case OBJTYPE_FAN: + { + struct n64_fanobj* srcobj = (struct n64_fanobj*)cmd; + struct fanobj* dstobj = (struct fanobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->yrot, srcobj->yrot); + PD_CONV_VAL(dstobj->yrotprev, srcobj->yrotprev); + PD_CONV_VAL(dstobj->ymaxspeed, srcobj->ymaxspeed); + PD_CONV_VAL(dstobj->yspeed, srcobj->yspeed); + PD_CONV_VAL(dstobj->yaccel, srcobj->yaccel); + PD_CONV_VAL(dstobj->on, srcobj->on); + + dst += sizeof(struct fanobj); + break; + } + case OBJTYPE_HOVERCAR: + { + struct n64_hovercarobj* srcobj = (struct n64_hovercarobj*)cmd; + struct hovercarobj* dstobj = (struct hovercarobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); + PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_VAL(dstobj->rotx, srcobj->rotx); + PD_CONV_VAL(dstobj->rotz, srcobj->rotz); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + PD_CONV_VAL(dstobj->status, srcobj->status); + PD_CONV_VAL(dstobj->dead, srcobj->dead); + PD_CONV_VAL(dstobj->deadtimer60, srcobj->deadtimer60); + PD_CONV_VAL(dstobj->sparkstimer60, srcobj->sparkstimer60); + + dst += sizeof(struct hovercarobj); + break; + } + case OBJTYPE_PADEFFECT: + { + struct padeffectobj* srcobj = (struct padeffectobj*)cmd; + struct padeffectobj* dstobj = (struct padeffectobj*)dst; + + conv_default_obj_hdr((struct defaultobj*)dstobj, cmd); + PD_CONV_VAL(dstobj->effect, srcobj->effect); + PD_CONV_VAL(dstobj->pad, srcobj->pad); + + dst += sizeof(struct padeffectobj); + break; + } + case OBJTYPE_CHOPPER: + { + struct n64_chopperobj* srcobj = (struct n64_chopperobj*)cmd; + struct chopperobj* dstobj = (struct chopperobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + dstobj->ailist = (u8*)srcobj->ptr_ailist; + PD_CONV_VAL(dstobj->aioffset, srcobj->aioffset); + PD_CONV_VAL(dstobj->aireturnlist, srcobj->aireturnlist); + PD_CONV_VAL(dstobj->speed, srcobj->speed); + PD_CONV_VAL(dstobj->speedaim, srcobj->speedaim); + PD_CONV_VAL(dstobj->speedtime60, srcobj->speedtime60); + PD_CONV_VAL(dstobj->turnyspeed60, srcobj->turnyspeed60); + PD_CONV_VAL(dstobj->turnxspeed60, srcobj->turnxspeed60); + PD_CONV_VAL(dstobj->turnrot60, srcobj->turnrot60); + PD_CONV_VAL(dstobj->roty, srcobj->roty); + PD_CONV_VAL(dstobj->rotx, srcobj->rotx); + PD_CONV_VAL(dstobj->rotz, srcobj->rotz); + PD_CONV_PTR(dstobj->path, srcobj->ptr_path); + PD_CONV_VAL(dstobj->nextstep, srcobj->nextstep); + PD_CONV_VAL(dstobj->weaponsarmed, srcobj->weaponsarmed); + PD_CONV_VAL(dstobj->ontarget, srcobj->ontarget); + PD_CONV_VAL(dstobj->target, srcobj->target); + PD_CONV_VAL(dstobj->attackmode, srcobj->attackmode); + PD_CONV_VAL(dstobj->cw, srcobj->cw); + PD_CONV_VAL(dstobj->vx, srcobj->vx); + PD_CONV_VAL(dstobj->vy, srcobj->vy); + PD_CONV_VAL(dstobj->vz, srcobj->vz); + PD_CONV_VAL(dstobj->power, srcobj->power); + PD_CONV_VAL(dstobj->otx, srcobj->otx); + PD_CONV_VAL(dstobj->oty, srcobj->oty); + PD_CONV_VAL(dstobj->otz, srcobj->otz); + PD_CONV_VAL(dstobj->bob, srcobj->bob); + PD_CONV_VAL(dstobj->bobstrength, srcobj->bobstrength); + PD_CONV_VAL(dstobj->targetvisible, srcobj->targetvisible); + PD_CONV_VAL(dstobj->timer60, srcobj->timer60); + PD_CONV_VAL(dstobj->patroltimer60, srcobj->patroltimer60); + PD_CONV_VAL(dstobj->gunturnyspeed60, srcobj->gunturnyspeed60); + PD_CONV_VAL(dstobj->gunturnxspeed60, srcobj->gunturnxspeed60); + PD_CONV_VAL(dstobj->gunroty, srcobj->gunroty); + PD_CONV_VAL(dstobj->gunrotx, srcobj->gunrotx); + PD_CONV_VAL(dstobj->barrelrotspeed, srcobj->barrelrotspeed); + PD_CONV_VAL(dstobj->barrelrot, srcobj->barrelrot); + PD_CONV_PTR(dstobj->fireslotthing, srcobj->ptr_fireslotthing); + PD_CONV_VAL(dstobj->dead, srcobj->dead); + + dst += sizeof(struct chopperobj); + break; + } + case OBJTYPE_ESCASTEP: + { + struct n64_escalatorobj* srcobj = (struct n64_escalatorobj*)cmd; + struct escalatorobj* dstobj = (struct escalatorobj*)dst; + + conv_default_obj(&dstobj->base, cmd); + + PD_CONV_VAL(dstobj->frame, srcobj->frame); + PD_CONV_VAL(dstobj->prevpos, srcobj->prevpos); + + dst += sizeof(struct escalatorobj); + break; + } + } + + cmd = (struct n64_defaultobj*)((u32*)cmd + obj_size(cmd)); + type = cmd->type; + } + + *(u32*)(dst) = htobe32(OBJTYPE_END); + dst += sizeof(int); + + return (u32)(dst - start); +} + +static uintptr_t convert_intro(u8 *dst, u8 *src) +{ + u8* start = dst; + u8 cmd_size[] = { + 3, // INTROCMD_SPAWN + 4, // INTROCMD_WEAPON + 4, // INTROCMD_AMMO + 8, // INTROCMD_3 + 2, // INTROCMD_4 + 2, // INTROCMD_OUTFIT + 10, // INTROCMD_6 + 3, // INTROCMD_WATCHTIME + 2, // INTROCMD_CREDITOFFSET + 3, // INTROCMD_CASE + 3, // INTROCMD_CASERESPAWN + 2, // INTROCMD_HILL + 1, // INTROCMD_END + }; + + s32* dstintro = (s32*)dst; + s32* srcintro = (s32*)src; + + while (true) { + s32 cmd = dstintro[0] = srctodst32(srcintro[0]); + u8 size = cmd_size[*dstintro]; + for (int i = 1; i < size; i++) { + dstintro[i] = srctodst32(srcintro[i]); + } + + dstintro += size; + srcintro += size; + + if (cmd == INTROCMD_END) break; + } + + return (u32)((u8*)dstintro - start); +} + +static uintptr_t convert_paths(u8 *dst, u8 *src) +{ + u8* start = dst; + + struct n64_path* srcpath = (struct n64_path*)src; + struct path* dstpath = (struct path*)dst; + + while (true) { + PD_CONV_PTR(dstpath->pads, srcpath->ptr_pads); + PD_CONV_VAL(dstpath->id, srcpath->id); + PD_CONV_VAL(dstpath->flags, srcpath->flags); + PD_CONV_VAL(dstpath->len, srcpath->len); + + dstpath++; + + if (srcpath->ptr_pads == 0) break; + + srcpath ++; + } + + return (u32)((u8*)dstpath - start); +} + +static int convert_pads(struct path *dstpaths, u8 *dst, u8 *src, uintptr_t dstpos) +{ + uintptr_t start = dstpos; + s32* dstpads = (s32*)&dst[dstpos]; + s32 i = 0; + while (dstpaths->pads) { + s32 *pads = (s32*)&src[(uintptr_t)dstpaths->pads]; + dstpaths->pads = (s32*)dstpos; + + while (*pads) { + s32 p = srctoh32(*pads++); + *dstpads++ = p; + dstpos += sizeof(s32); + if (p == -1) break; + } + + dstpaths++; + } + + dstpaths->pads = 0; + return dstpos - start; +} + +static uintptr_t convert_ailists(u8* dst, u8* src) +{ + u8* start = dst; + + struct n64_ailist* srcailist = (struct n64_ailist*)src; + struct ailist* dstailist = (struct path*)dst; + + while (true) { + // at this point these fields are already converted, so we just assign + dstailist->list = srcailist->ptr_list; + dstailist->id = srcailist->id; + + dstailist++; + + if (srcailist->ptr_list == 0) break; + + srcailist++; + } + + return (u32)((u8*)dstailist - start); +} + +static int convert_lists(uintptr_t ofs_ailists, u8 *dst, u8 *src, uintptr_t dstpos) +{ + struct n64_ailist* ailists = (struct n64_ailist*)&src[ofs_ailists]; + + // count the lists and pre-convert the fields + int nlists = 0; + for (struct n64_ailist* tmp = ailists; tmp->ptr_list; tmp++, nlists++) { + tmp->ptr_list = srctodst32(tmp->ptr_list); + tmp->id = srctodst32(tmp->id); + } + + // sort ailists by the list addr + for (int i = 0; i < nlists; i++) { + uintptr_t minidx = i; + + for (int j = i + 1; j < nlists; j++) + if (ailists[j].ptr_list < ailists[minidx].ptr_list) minidx = j; + + struct n64_ailist tmp = ailists[i]; + ailists[i] = ailists[minidx]; + ailists[minidx] = tmp; + } + + for (int i = 0; i < nlists; i++) { + u8* start = (u8*)&src[(uintptr_t)ailists[i].ptr_list]; + u8* end = (i == nlists - 1) ? &src[ofs_ailists] : &src[(uintptr_t)ailists[i + 1].ptr_list]; + + size_t size = end - start; + + // update the src list pointers as we go + ailists[i].ptr_list = (u8*)dstpos; + + if (size > 0) + memcpy(dst + dstpos, start, size); + + dstpos += size; + + } + return dstpos; +} + +static int convert_setup(u8 *dst, u8 *src, u32 srclen) +{ + struct n64_stagesetup *src_header = (struct n64_stagesetup*)src; + struct stagesetup *dst_header = (struct stagesetup*)dst; + + src_header->ptr_props = srctodst32(src_header->ptr_props); + src_header->ptr_intro = srctodst32(src_header->ptr_intro); + src_header->ptr_ailists = srctodst32(src_header->ptr_ailists); + src_header->ptr_paths = srctodst32(src_header->ptr_paths); + + u32 srcpos = sizeof(*src_header); + u32 dstpos = sizeof(*dst_header); + + srcpos = src_header->ptr_props; + dst_header->props = (u32*) dstpos; + dstpos += convert_props(&dst[dstpos], &src[srcpos]); + + srcpos = src_header->ptr_intro; + dst_header->intro = (u32*) dstpos; + dstpos += convert_intro(&dst[dstpos], &src[srcpos]); + + srcpos = src_header->ptr_paths; + dst_header->paths = (struct path*) dstpos; + dstpos += convert_paths(&dst[dstpos], &src[srcpos]); + + // write the lists bytecodes before the ailists entries + dstpos += convert_lists(src_header->ptr_ailists, dst, src, dstpos); + + srcpos = src_header->ptr_ailists; + dst_header->ailists = (struct ailist*) dstpos; + dstpos += convert_ailists(&dst[dstpos], &src[srcpos]); + + dstpos += convert_pads(&dst[(uintptr_t)dst_header->paths], dst, src, dstpos); + + return dstpos; +} + + +void test_conv_functions() +{ + f32 dst0; + f32 src0 = 3.141592; + PD_CONV_VAL(dst0, src0); + + u32 dst1; + u32 src1 = 0xaabbccdd; + PD_CONV_VAL(dst1, src1); + + s32 dst2; + s32 src2 = 0xaabbccdd; + PD_CONV_VAL(dst2, src2); + + u16 dst3; + u16 src3 = 0xaabb; + PD_CONV_VAL(dst3, src3); + + s16 dst4; + s16 src4 = 0xaabb; + PD_CONV_VAL(dst4, src4); + + struct coord dst5; + struct n64_coord src5 = { 1.0f, 2.0f, 3.0f }; + PD_CONV_VAL(dst5, src5); + + s32* dst6; + s32* src6 = (s32*)0xcafebaca; + PD_CONV_PTR(dst6, src6); + + s32 dst7[3]; + s32 src7[3] = { 0xaabbccdd, 0x11223344, 0xddbbccaa }; + PD_CONV_ARRAY(dst7, src7); + + s32 dst8[2][2]; + s32 src8[2][2] = { + { 0xaabbccdd, 0x11223344 }, + { 0xffeeddcc, 0x55667788 } + }; + PD_CONV_ARRAY2D(dst8, src8); +} + +void extract_file_setups(char* filename, u32 romoffset, size_t len) +{ + // Unzip it + size_t infsize = rzip_get_infsize(&g_Rom[romoffset]); + u8* src = malloc(infsize); + + int ret = rzip_inflate(src, infsize, &g_Rom[romoffset], len); + + if (ret < 0) { + sysLogPrintf(LOG_ERROR, "%s: Unable to inflate file: %d", filename, ret); + exit(EXIT_FAILURE); + } + + // Convert it + u8* dst = calloc(1, infsize * 4); + + int* mark = strstr(filename, "mp_setupdam"); + u32 dstpos = convert_setup(dst, src, infsize); + + if (dstpos > infsize * 4) { + sysLogPrintf(LOG_ERROR, "%s: overflow", filename); + exit(EXIT_FAILURE); + } + + sysLogPrintf(LOG_NOTE, "%s %d %d %.3f", filename, infsize, dstpos, (f32)dstpos / infsize); + + // Zip it + u8* zipped = calloc(1, dstpos); + size_t ziplen = dstpos; + + ret = rzip_deflate(zipped, &ziplen, dst, dstpos); + + if (ret < 0) { + sysLogPrintf(LOG_ERROR, "%s: Unable to compress file: %d", filename, ret); + exit(EXIT_FAILURE); + } + + ziplen = ALIGN16(ziplen); + + // Write it + char outfilename[1024]; + sprintf(outfilename, "%s/files/%s", g_OutPath, filename); + + FILE* fp = openfile(outfilename); + fwrite(zipped, ziplen, 1, fp); + fclose(fp); + + free(zipped); + free(dst); + free(src); +} \ No newline at end of file diff --git a/port/pdextract/setups_decl.h b/port/pdextract/setups_decl.h new file mode 100644 index 000000000..ab650168b --- /dev/null +++ b/port/pdextract/setups_decl.h @@ -0,0 +1,644 @@ +#ifndef _IN_SETUP_DECL +#define _IN_SETUP_DECL + + +#include +#include "common.h" + + +struct n64_stagesetup { + u32 ptr_waypoints; + u32 ptr_waygroups; + u32 ptr_cover; + u32 ptr_intro; + u32 ptr_props; + u32 ptr_paths; + u32 ptr_ailists; + u32 ptr_padfiledata; +}; + + +struct n64_coord { + f32 x; + f32 y; + f32 z; +}; + +struct n64_defaultobj { + u16 extrascale; + u8 hidden2; + u8 type; + s16 modelnum; + s16 pad; + u32 flags; + u32 flags2; + u32 flags3; + u32 ptr_prop; + u32 ptr_model; + f32 realrot[3][3]; + u32 hidden; + union { + u32 ptr_geotilef; + u32 ptr_geoblock; + u32 ptr_geocyl; + u32 ptr_unkgeo; + }; + union { + u32 ptr_projectile; + u32 ptr_embedment; + }; + s16 damage; + s16 maxdamage; + u8 shadecol[4]; + u8 nextcol[4]; + u16 floorcol; + s8 geocount; + s8 _pad_; +}; + +struct n64_doorobj { + struct n64_defaultobj base; + f32 maxfrac; + f32 perimfrac; + f32 accel; + f32 decel; + f32 maxspeed; + u16 doorflags; + u16 doortype; + u32 keyflags; + s32 autoclosetime; + f32 frac; + f32 fracspeed; + s8 mode; + s8 glasshits; + s16 fadealpha; + s16 xludist; + s16 opadist; + struct n64_coord startpos; + f32 mtx98[3][3]; + u32 ptr_sibling; + s32 lastopen60; + s16 portalnum; + s8 soundtype; + s8 fadetime60; + s32 lastcalc60; + u8 laserfade; + u8 unusedmaybe[3]; + u8 shadeinfo1[4]; + u8 shadeinfo2[4]; + u8 actual1; + u8 actual2; + u8 extra1; + u8 extra2; +}; + +struct n64_doorscaleobj { + u32 unk00; + s32 scale; +}; + +struct n64_keyobj { + struct n64_defaultobj base; + u32 keyflags; +}; + +struct n64_alarmobj { + struct n64_defaultobj base; +}; + +struct n64_cctvobj { + struct n64_defaultobj base; + + s16 lookatpadnum; + s16 toleft; + //Mtxf camrotm; + f32 m[4][4]; + f32 yzero; + f32 yrot; + f32 yleft; + f32 yright; + f32 yspeed; + f32 ymaxspeed; + s32 seebondtime60; + f32 maxdist; + f32 xzero; +}; + +struct n64_ammocrateobj { + struct n64_defaultobj base; + s32 ammotype; +}; + +struct n64_gset { + u8 weaponnum; + u8 unk0639; + u8 unk063a; + u8 weaponfunc; +}; + +struct n64_weaponobj { + struct n64_defaultobj base; + + union { + struct n64_gset gset; + struct { + u8 weaponnum; + s8 unk5d; + s8 unk5e; + u8 gunfunc; + }; + }; + + s8 fadeouttimer60; + s8 dualweaponnum; + + union { + s16 timer240; + s16 team; + }; + + u32 ptr_dualweapon; +}; + +struct n64_packedchr { + s16 chrindex; + s8 unk02; + s8 typenum; + u32 spawnflags; + s16 chrnum; + u16 padnum; + u8 bodynum; + s8 headnum; + u16 ailistnum; + u16 padpreset; + u16 chrpreset; + u16 hearscale; + u16 viewdist; + u32 flags; + u32 flags2; + u8 team; + u8 squadron; + s16 chair; + u32 convtalk; + u8 tude; + u8 naturalanim; + u8 yvisang; + u8 teamscandist; +}; + +struct n64_tvscreen { + u32 ptr_cmdlist; + u16 offset; + s16 pause60; + u32 ptr_tconfig; + f32 rot; + f32 xscale; + f32 xscalefrac; + f32 xscaleinc; + f32 xscaleold; + f32 xscalenew; + f32 yscale; + f32 yscalefrac; + f32 yscaleinc; + f32 yscaleold; + f32 yscalenew; + f32 xmid; + f32 xmidfrac; + f32 xmidinc; + f32 xmidold; + f32 xmidnew; + f32 ymid; + f32 ymidfrac; + f32 ymidinc; + f32 ymidold; + f32 ymidnew; + u8 red; + u8 redold; + u8 rednew; + u8 green; + u8 greenold; + u8 greennew; + u8 blue; + u8 blueold; + u8 bluenew; + u8 alpha; + u8 alphaold; + u8 alphanew; + f32 colfrac; + f32 colinc; +}; + +struct n64_singlemonitorobj { + struct n64_defaultobj base; + struct n64_tvscreen screen; + s16 owneroffset; + s8 ownerpart; + u8 imagenum; +}; + +struct n64_multimonitorobj { + struct n64_defaultobj base; + struct n64_tvscreen screens[4]; + u8 imagenums[4]; +}; + +struct n64_hangingmonitorsobj { + struct n64_defaultobj base; +}; + +struct n64_autogunobj { + struct n64_defaultobj base; + s16 targetpad; + s8 firing; + u8 firecount; + f32 yzero; + f32 ymaxleft; + f32 ymaxright; + f32 yrot; + f32 yspeed; + f32 xzero; + f32 xrot; + f32 xspeed; + f32 maxspeed; + f32 aimdist; + f32 barrelspeed; + f32 barrelrot; + s32 lastseebond60; + s32 lastaimbond60; + s32 allowsoundframe; + u32 ptr_beam; + f32 shotbondsum; + u32 ptr_target; + u8 targetteam; + u8 ammoquantity; + s16 nextchrtest; +}; + +struct n64_linkgunsobj { + u32 unk00; + s16 offset1; + s16 offset2; +}; + +struct n64_debrisobj { + struct n64_defaultobj base; +}; + +struct n64_hatobj { + struct n64_defaultobj base; +}; + +struct n64_grenadeprobobj { // objtype 0x12 + u32 unk00; + s16 chrnum; + u16 probability; +}; + +struct n64_linkliftdoorobj { + u32 unk00; + u32 ptr_door; + u32 ptr_lift; + u32 ptr_next; + s32 stopnum; +}; + +struct n64_multiammocrateslot { + u16 modelnum; + u16 quantity; +}; + +struct n64_multiammocrateobj { + struct n64_defaultobj base; + struct n64_multiammocrateslot slots[19]; +}; + +struct n64_shieldobj { + struct n64_defaultobj base; + f32 initialamount; + f32 amount; + u32 unk64; +}; + +struct n64_tag { + u32 identifier; + u16 tagnum; + s16 cmdoffset; + u32 ptr_next; + u32 ptr_obj; +}; + +struct n64_objective { + u32 unk00; + s32 index; + u32 text; + u16 unk0c; + u8 flags; + s8 difficulties; +}; + +struct n64_stdobjective { + u32 cmd; +}; + +struct n64_objectivecmd { + u8 cmd0[4]; + u32 cmd1; +}; + +struct n64_briefingobj { + u32 unk00; + u32 type; + u32 text; + u32 ptr_next; +}; + +struct n64_padlockeddoorobj { + u32 unk00; + u32 ptr_door; + u32 ptr_lock; + u32 ptr_next; +}; + +struct n64_truckobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 speed; + f32 wheelxrot; + f32 wheelyrot; + f32 speedaim; + f32 speedtime60; + f32 turnrot60; + f32 roty; + u32 ptr_path; + s32 nextstep; +}; + +struct n64_tankobj { + u8 _pad_[128]; +}; + +struct n64_heliobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 rotoryrot; + f32 rotoryspeed; + f32 rotoryspeedaim; + f32 rotoryspeedtime; + f32 speed; + f32 speedaim; + f32 speedtime60; + f32 yrot; + u32 ptr_path; + s32 nextstep; +}; + +struct n64_glassobj { + struct n64_defaultobj base; + s16 portalnum; + s16 _pad_; +}; + +struct n64_safeobj { + struct n64_defaultobj base; +}; + +struct n64_safeitemobj { + u32 unk00; + u32 ptr_item; + u32 ptr_safe; + u32 ptr_door; + u32 ptr_next; +}; + +struct n64_cameraposobj { + s32 type; + f32 x; + f32 y; + f32 z; + f32 theta; + f32 verta; + s32 pad; +}; + +struct n64_tintedglassobj { + struct n64_defaultobj base; + s16 xludist; + s16 opadist; + s16 opacity; + s16 portalnum; + f32 unk64; +}; + +struct n64_liftobj { + struct n64_defaultobj base; + s16 pads[4]; + u32 ptr_doors[4]; + f32 dist; + f32 speed; + f32 accel; + f32 maxspeed; + s8 soundtype; + s8 levelcur; + s8 levelaim; + s8 _pad_; + struct n64_coord prevpos; +}; + +struct n64_linksceneryobj { + u32 unk00; + u32 ptr_trigger; + u32 ptr_unexp; + u32 ptr_exp; + u32 ptr_next; +}; + +struct n64_blockedpathobj { + u32 unk00; + u32 ptr_blocker; + s16 waypoint1; + s16 waypoint2; + u32 ptr_next; +}; + +struct n64_hov { + u8 type; + u8 flags; + s16 _pad_; + f32 bobycur; + f32 bobytarget; + f32 bobyspeed; + f32 yrot; + f32 bobpitchcur; + f32 bobpitchtarget; + f32 bobpitchspeed; + f32 bobrollcur; + f32 bobrolltarget; + f32 bobrollspeed; + f32 groundpitch; + f32 y; + f32 ground; + s32 prevframe60; + s32 prevgroundframe60; +}; + +struct n64_hoverbikeobj { + struct n64_defaultobj base; + struct n64_hov hov; + f32 speed[2]; + f32 prevpos[2]; + f32 w; + f32 rels[2]; + f32 exreal; + f32 ezreal; + f32 ezreal2; + f32 leanspeed; + f32 leandiff; + s32 maxspeedtime240; + f32 speedabs[2]; + f32 speedrel[2]; +}; + +struct n64_hoverpropobj { + struct n64_defaultobj base; + struct n64_hov hov; +}; + +struct n64_fanobj { + struct n64_defaultobj base; + f32 yrot; + f32 yrotprev; + f32 ymaxspeed; + f32 yspeed; + f32 yaccel; + s8 on; + u8 _pad_[3]; +}; + +struct n64_hovercarobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + f32 speed; + f32 speedaim; + f32 speedtime60; + f32 turnyspeed60; + f32 turnxspeed60; + f32 turnrot60; + f32 roty; + f32 rotx; + f32 rotz; + u32 ptr_path; + s32 nextstep; + s16 status; + s16 dead; + s16 deadtimer60; + s16 sparkstimer60; +}; + +struct n64_chopperobj { + struct n64_defaultobj base; + u32 ptr_ailist; + u16 aioffset; + s16 aireturnlist; + union { + struct { + f32 speed; + f32 speedaim; + f32 speedtime60; + }; + struct n64_coord fall; + }; + f32 turnyspeed60; + f32 turnxspeed60; + f32 turnrot60; + f32 roty; + f32 rotx; + f32 rotz; + u32 ptr_path; + s32 nextstep;// + s16 weaponsarmed; + s16 ontarget; + s16 target; + u8 attackmode; + u8 cw; + f32 vx; + f32 vy; + f32 vz; + f32 power; + f32 otx; + f32 oty; + f32 otz; + f32 bob; + f32 bobstrength; + s32 targetvisible; + s32 timer60; + s32 patroltimer60; + f32 gunturnyspeed60; + f32 gunturnxspeed60; + f32 gunroty; + f32 gunrotx; + f32 barrelrotspeed; + f32 barrelrot; + u32 ptr_fireslotthing; + s32 dead; +}; + +struct n64_escalatorobj { + struct n64_defaultobj base; + s32 frame; + struct n64_coord prevpos; +}; + +struct n64_textoverride { + u32 unk00; + s32 objoffset; + s32 weapon; + u32 obtaintext; + u32 ownertext; + u32 inventorytext; + u32 inventory2text; + u32 pickuptext; + u32 ptr_next; + u32 ptr_obj; +}; + +struct n64_criteria_roomentered { + u32 unk00; + u32 pad; + u32 status; + u32 ptr_next; +}; + +struct n64_criteria_throwinroom { + u32 unk00; + u32 unk04; + u32 pad; + u32 status; + u32 ptr_next; +}; + +struct n64_criteria_holograph { + u32 unk00; + u32 obj; + u32 status; + u32 ptr_next; +}; + +struct n64_ailist { + u32 ptr_list; + s32 id; +}; + +struct n64_path { + u32 ptr_pads; + u8 id; + u8 flags; + u16 len; +}; + +#endif \ No newline at end of file