BEGIN_DUKE_NS //--------------------------------------------------------------------------- // // global exports // //--------------------------------------------------------------------------- player_struct* duke_getviewplayer() { return &ps[screenpeek]; } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, getviewplayer, duke_getviewplayer) { PARAM_PROLOGUE; ACTION_RETURN_POINTER(duke_getviewplayer()); } DEFINE_ACTION_FUNCTION(_Duke, MaxAmmoAmount) { PARAM_PROLOGUE; PARAM_INT(weap); int max = weap < 0 || weap >= MAX_WEAPONS ? 0 : gs.max_ammo_amount[weap]; ACTION_RETURN_INT(max); } void S_PlaySpecialMusic(unsigned int m); DEFINE_ACTION_FUNCTION_NATIVE(_Duke, PlaySpecialMusic, S_PlaySpecialMusic) { PARAM_PROLOGUE; PARAM_INT(song); S_PlaySpecialMusic(song); return 0; } static int PlaySound(int num, int chan, int flags, double vol) { return S_PlaySound(num, chan, EChanFlags::FromInt(flags), float(vol)); } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, PlaySound, PlaySound) { PARAM_PROLOGUE; PARAM_INT(snd); PARAM_INT(chan); PARAM_INT(flags); PARAM_FLOAT(vol); ACTION_RETURN_INT(PlaySound(snd, chan, flags, vol)); } static void StopSound(int num) { S_StopSound(num); } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, StopSound, StopSound) { PARAM_PROLOGUE; PARAM_INT(snd); StopSound(snd); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, CheckSoundPlaying, S_CheckSoundPlaying) { PARAM_PROLOGUE; PARAM_INT(snd); ACTION_RETURN_INT(S_CheckSoundPlaying(snd)); } player_struct* duke_checkcursectnums(sectortype* sector) { if (!sector) return nullptr; int pp = checkcursectnums(sector); return pp >= 0 ? &ps[pp] : nullptr; } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, checkcursectnums, duke_checkcursectnums) { PARAM_PROLOGUE; PARAM_POINTER(sect, sectortype); ACTION_RETURN_POINTER(duke_checkcursectnums(sect)); } int duke_global_random() { return global_random; } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, global_random, duke_global_random) { PARAM_PROLOGUE; ACTION_RETURN_INT(global_random); } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, GetSoundFlags, S_GetUserFlags) { PARAM_PROLOGUE; PARAM_INT(snd); ACTION_RETURN_INT(S_GetUserFlags(snd)); } DEFINE_ACTION_FUNCTION_NATIVE(_Duke, badguyID, badguypic) { PARAM_PROLOGUE; PARAM_INT(p); ACTION_RETURN_INT(badguypic(p)); } DEFINE_GLOBAL_UNSIZED(dlevel) DEFINE_GLOBAL(camsprite) //--------------------------------------------------------------------------- // // DukeActor // //--------------------------------------------------------------------------- DEFINE_FIELD(DDukeActor, ownerActor) DEFINE_FIELD(DDukeActor, hitOwnerActor) DEFINE_FIELD(DDukeActor, cgg) DEFINE_FIELD(DDukeActor, spriteextra) DEFINE_FIELD(DDukeActor, hitang) DEFINE_FIELD(DDukeActor, hitextra) DEFINE_FIELD(DDukeActor, movflag) DEFINE_FIELD(DDukeActor, tempval) DEFINE_FIELD(DDukeActor, timetosleep) DEFINE_FIELD(DDukeActor, floorz) DEFINE_FIELD(DDukeActor, ceilingz) DEFINE_FIELD(DDukeActor, saved_ammo) DEFINE_FIELD(DDukeActor, palvals) DEFINE_FIELD(DDukeActor, temp_data) DEFINE_FIELD(DDukeActor, temp_actor) DEFINE_FIELD(DDukeActor, seek_actor) DEFINE_FIELD(DDukeActor, flags1) DEFINE_FIELD(DDukeActor, flags2) DEFINE_FIELD(DDukeActor, spritesetindex) DEFINE_FIELD(DDukeActor, temp_walls) DEFINE_FIELD(DDukeActor, temp_sect) DEFINE_FIELD(DDukeActor, actorstayput) DEFINE_FIELD(DDukeActor, temp_pos) DEFINE_FIELD(DDukeActor, temp_pos2) DEFINE_FIELD(DDukeActor, temp_angle) static void setSpritesetImage(DDukeActor* self, unsigned int index) { auto& spriteset = static_cast(self->GetClass())->ActorInfo()->SpriteSet; if (index >= spriteset.Size()) { ThrowAbortException(X_ARRAY_OUT_OF_BOUNDS, "Bad sprite set index %d (max. allowed is %d", index, spriteset.Size() - 1); } self->spritesetindex = index; self->spr.picnum = spriteset[index]; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, SetSpritesetImage, setSpritesetImage) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_UINT(index); setSpritesetImage(self, index); return 0; } static int getSpritesetSize(DDukeActor* self) { auto& spriteset = static_cast(self->GetClass())->ActorInfo()->SpriteSet; return spriteset.Size(); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, GetSpritesetSize, getSpritesetSize) { PARAM_SELF_PROLOGUE(DDukeActor); ACTION_RETURN_INT(getSpritesetSize(self)); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, getglobalz, getglobalz) { PARAM_SELF_PROLOGUE(DDukeActor); getglobalz(self); return 0; } player_struct* DukeActor_findplayer(DDukeActor* self, double* dist) { double a; return &ps[findplayer(self, dist? dist : &a)]; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, findplayer, DukeActor_findplayer) { PARAM_SELF_PROLOGUE(DDukeActor); double d; auto p = DukeActor_findplayer(self, &d); if (numret > 0) ret[0].SetPointer(p); if (numret > 1) ret[1].SetFloat(d); return min(numret, 2); } int DukeActor_ifhitbyweapon(DDukeActor* self) { return fi.ifhitbyweapon(self); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ifhitbyweapon, DukeActor_ifhitbyweapon) { PARAM_SELF_PROLOGUE(DDukeActor); ACTION_RETURN_INT(DukeActor_ifhitbyweapon(self)); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, domove, ssp) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(clipmask); ACTION_RETURN_INT(ssp(self, clipmask)); } int DukeActor_PlayActorSound(DDukeActor* self, int snd, int chan, int flags) { return S_PlayActorSound(snd, self, chan, EChanFlags::FromInt(flags)); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, PlayActorSound, DukeActor_PlayActorSound) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(snd); PARAM_INT(chan); PARAM_INT(flags); ACTION_RETURN_INT(DukeActor_PlayActorSound(self, snd, chan, flags)); } void DukeActor_StopSound(DDukeActor* self, int snd, int flags) { S_StopSound(snd, self, flags); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, StopSound, DukeActor_StopSound) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(snd); PARAM_INT(chan); DukeActor_StopSound(self, snd, chan); return 0; } DDukeActor* DukeActor_Spawn(DDukeActor* origin, int intname) { int picnum = -1; // this is still a hack so it can spawn actors which haven't been scriptified yet. This will go away later. if (FName(ENamedName(intname)) == FName("DukeToiletWater")) { picnum = TileFiles.tileForName("TOILETWATER"); } else if (FName(ENamedName(intname)) == FName("DukeBurning")) { picnum = TileFiles.tileForName("BURNIMG"); } else if (FName(ENamedName(intname)) == FName("DukeBloodPool")) { picnum = TileFiles.tileForName("BLOODPOOL"); } else if (FName(ENamedName(intname)) == FName("DukeExplosion2")) { picnum = TileFiles.tileForName("EXPLOSION2"); } else if (FName(ENamedName(intname)) == FName("DukeTransporterStar")) { picnum = TileFiles.tileForName("TRANSPORTERSTAR"); } else if (FName(ENamedName(intname)) == FName("RedneckRabbit")) { picnum = TileFiles.tileForName("RABBIT"); } if (picnum == -1) { auto cls = PClass::FindActor(FName(ENamedName(intname))); if (cls) return spawn(origin, cls); } else { return spawn(origin, picnum); } return nullptr; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, spawn, DukeActor_Spawn) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(type); ACTION_RETURN_POINTER(DukeActor_Spawn(self, type)); } DDukeActor* DukeActor_Spawnsprite(DDukeActor* origin, int picnum) { if (picnum >= 0 && picnum < MAXTILES) { return spawn(origin, picnum); } return nullptr; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, spawnsprite, DukeActor_Spawnsprite) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(type); ACTION_RETURN_POINTER(DukeActor_Spawnsprite(self, type)); } DDukeActor* DukeActor_spawnweaponorammo(DDukeActor* origin, unsigned intname) { if (intname > 14) return nullptr; return spawn(origin, gs.weaponsandammosprites[intname]); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, spawnweaponorammo, DukeActor_spawnweaponorammo) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(type); ACTION_RETURN_POINTER(DukeActor_spawnweaponorammo(self, type)); } void DukeActor_Lotsofglass(DDukeActor* origin, int count) { lotsofglass(origin, nullptr, count); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, lotsofglass, DukeActor_Lotsofglass) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(count); DukeActor_Lotsofglass(self, count); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, makeitfall, makeitfall) { PARAM_SELF_PROLOGUE(DDukeActor); makeitfall(self); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, RandomScrap, RANDOMSCRAP) { PARAM_SELF_PROLOGUE(DDukeActor); RANDOMSCRAP(self); return 0; } void DukeActor_hitradius(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int hp4) { fi.hitradius(actor, r, hp1, hp2, hp3, hp4); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, hitradius, DukeActor_hitradius) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(r); PARAM_INT(h1); PARAM_INT(h2); PARAM_INT(h3); PARAM_INT(h4); DukeActor_hitradius(self, r, h1, h2, h3, h4); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, hitasprite, hitasprite) { PARAM_SELF_PROLOGUE(DDukeActor); DDukeActor* p; double d = hitasprite(self, &p); if (numret > 0) ret[0].SetFloat(d); if (numret > 1) ret[1].SetPointer(p); return min(numret, 2); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ChangeSector, ChangeActorSect) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_POINTER(sec, sectortype); PARAM_INT(tail); ChangeActorSect(self, sec, tail); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, ChangeStat, ChangeActorStat) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(stat); PARAM_INT(tail); ChangeActorStat(self, stat, tail); return 0; } void DukeActor_detonate(DDukeActor* origin, int intname) { // all callers use "EXPLOSION2", so ignore the parameter for now int picnum = TileFiles.tileForName("EXPLOSION2"); detonate(origin, picnum); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, detonate, DukeActor_detonate) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(type); DukeActor_detonate(self, type); return 0; } void DukeActor_checkhitdefault(DDukeActor* origin, DDukeActor* proj) { fi.checkhitdefault(origin, proj); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, checkhitdefault, DukeActor_checkhitdefault) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_OBJECT(proj, DDukeActor); DukeActor_checkhitdefault(self, proj); return 0; } void DukeActor_operatesectors(DDukeActor* origin, sectortype* sector) { operatesectors(sector, origin); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, operatesectors, DukeActor_operatesectors) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_POINTER(sec, sectortype); operatesectors(sec, self); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, badguy, badguy) { PARAM_SELF_PROLOGUE(DDukeActor); ACTION_RETURN_INT(badguy(self)); } int duke_isplayer(DDukeActor* act) { return act->isPlayer(); } DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, isplayer, duke_isplayer) { PARAM_SELF_PROLOGUE(DDukeActor); ACTION_RETURN_INT(duke_isplayer(self)); } // temporary helpers to hide the fact that these flags are not part of the actor yet. DEFINE_ACTION_FUNCTION(DDukeActor, actorflag1) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(mask); ACTION_RETURN_BOOL(!!actorflag(self, EDukeFlags1::FromInt(mask))); } DEFINE_ACTION_FUNCTION(DDukeActor, actorflag2) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(mask); ACTION_RETURN_BOOL(!!actorflag(self, EDukeFlags2::FromInt(mask))); } DEFINE_ACTION_FUNCTION(DDukeActor, attackerflag1) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(mask); ACTION_RETURN_BOOL(!!attackerflag(self, EDukeFlags1::FromInt(mask))); } DEFINE_ACTION_FUNCTION(DDukeActor, attackerflag2) { PARAM_SELF_PROLOGUE(DDukeActor); PARAM_INT(mask); ACTION_RETURN_BOOL(!!attackerflag(self, EDukeFlags2::FromInt(mask))); } //--------------------------------------------------------------------------- // // DukePlayer // //--------------------------------------------------------------------------- DEFINE_FIELD_X(DukePlayer, player_struct, gotweapon) DEFINE_FIELD_X(DukePlayer, player_struct, pals) DEFINE_FIELD_X(DukePlayer, player_struct, weapon_sway) DEFINE_FIELD_X(DukePlayer, player_struct, oweapon_sway) DEFINE_FIELD_X(DukePlayer, player_struct, weapon_pos) DEFINE_FIELD_X(DukePlayer, player_struct, kickback_pic) DEFINE_FIELD_X(DukePlayer, player_struct, random_club_frame) DEFINE_FIELD_X(DukePlayer, player_struct, oweapon_pos) DEFINE_FIELD_X(DukePlayer, player_struct, okickback_pic) DEFINE_FIELD_X(DukePlayer, player_struct, orandom_club_frame) DEFINE_FIELD_X(DukePlayer, player_struct, hard_landing) DEFINE_FIELD_X(DukePlayer, player_struct, ohard_landing) DEFINE_FIELD_X(DukePlayer, player_struct, psectlotag) //DEFINE_FIELD_X(DukePlayer, player_struct, exitx) //DEFINE_FIELD_X(DukePlayer, player_struct, exity) //DEFINE_FIELD_X(DukePlayer, player_struct, loogiex) //DEFINE_FIELD_X(DukePlayer, player_struct, loogiey) DEFINE_FIELD_X(DukePlayer, player_struct, numloogs) DEFINE_FIELD_X(DukePlayer, player_struct, loogcnt) DEFINE_FIELD_X(DukePlayer, player_struct, invdisptime) //DEFINE_FIELD_X(DukePlayer, player_struct, bobposx) //DEFINE_FIELD_X(DukePlayer, player_struct, bobposy) DEFINE_FIELD_X(DukePlayer, player_struct, pyoff) DEFINE_FIELD_X(DukePlayer, player_struct, opyoff) //DEFINE_FIELD_X(DukePlayer, player_struct, posxv) //DEFINE_FIELD_X(DukePlayer, player_struct, posyv) //DEFINE_FIELD_X(DukePlayer, player_struct, poszv) DEFINE_FIELD_X(DukePlayer, player_struct, last_pissed_time) DEFINE_FIELD_X(DukePlayer, player_struct, truefz) DEFINE_FIELD_X(DukePlayer, player_struct, truecz) DEFINE_FIELD_X(DukePlayer, player_struct, player_par) DEFINE_FIELD_X(DukePlayer, player_struct, visibility) DEFINE_FIELD_X(DukePlayer, player_struct, bobcounter) DEFINE_FIELD_X(DukePlayer, player_struct, randomflamex) DEFINE_FIELD_X(DukePlayer, player_struct, crack_time) DEFINE_FIELD_X(DukePlayer, player_struct, aim_mode) DEFINE_FIELD_X(DukePlayer, player_struct, ftt) DEFINE_FIELD_X(DukePlayer, player_struct, cursector) DEFINE_FIELD_X(DukePlayer, player_struct, last_extra) DEFINE_FIELD_X(DukePlayer, player_struct, subweapon) DEFINE_FIELD_X(DukePlayer, player_struct, ammo_amount) DEFINE_FIELD_X(DukePlayer, player_struct, frag) DEFINE_FIELD_X(DukePlayer, player_struct, fraggedself) DEFINE_FIELD_X(DukePlayer, player_struct, curr_weapon) DEFINE_FIELD_X(DukePlayer, player_struct, last_weapon) DEFINE_FIELD_X(DukePlayer, player_struct, tipincs) DEFINE_FIELD_X(DukePlayer, player_struct, wantweaponfire) DEFINE_FIELD_X(DukePlayer, player_struct, holoduke_amount) DEFINE_FIELD_X(DukePlayer, player_struct, hurt_delay) DEFINE_FIELD_X(DukePlayer, player_struct, hbomb_hold_delay) DEFINE_FIELD_X(DukePlayer, player_struct, jumping_counter) DEFINE_FIELD_X(DukePlayer, player_struct, airleft) DEFINE_FIELD_X(DukePlayer, player_struct, knee_incs) DEFINE_FIELD_X(DukePlayer, player_struct, access_incs) DEFINE_FIELD_X(DukePlayer, player_struct, ftq) DEFINE_FIELD_X(DukePlayer, player_struct, access_wall) DEFINE_FIELD_X(DukePlayer, player_struct, got_access) DEFINE_FIELD_X(DukePlayer, player_struct, weapon_ang) DEFINE_FIELD_X(DukePlayer, player_struct, firstaid_amount) DEFINE_FIELD_X(DukePlayer, player_struct, actor) DEFINE_FIELD_X(DukePlayer, player_struct, one_parallax_sectnum) DEFINE_FIELD_X(DukePlayer, player_struct, over_shoulder_on) DEFINE_FIELD_X(DukePlayer, player_struct, fist_incs) DEFINE_FIELD_X(DukePlayer, player_struct, cheat_phase) DEFINE_FIELD_X(DukePlayer, player_struct, extra_extra8) DEFINE_FIELD_X(DukePlayer, player_struct, quick_kick) DEFINE_FIELD_X(DukePlayer, player_struct, last_quick_kick) DEFINE_FIELD_X(DukePlayer, player_struct, heat_amount) DEFINE_FIELD_X(DukePlayer, player_struct, timebeforeexit) DEFINE_FIELD_X(DukePlayer, player_struct, customexitsound) DEFINE_FIELD_X(DukePlayer, player_struct, weaprecs) DEFINE_FIELD_X(DukePlayer, player_struct, weapreccnt) DEFINE_FIELD_X(DukePlayer, player_struct, interface_toggle_flag) DEFINE_FIELD_X(DukePlayer, player_struct, dead_flag) DEFINE_FIELD_X(DukePlayer, player_struct, show_empty_weapon) DEFINE_FIELD_X(DukePlayer, player_struct, scuba_amount) DEFINE_FIELD_X(DukePlayer, player_struct, jetpack_amount) DEFINE_FIELD_X(DukePlayer, player_struct, steroids_amount) DEFINE_FIELD_X(DukePlayer, player_struct, shield_amount) DEFINE_FIELD_X(DukePlayer, player_struct, pycount) DEFINE_FIELD_X(DukePlayer, player_struct, frag_ps) DEFINE_FIELD_X(DukePlayer, player_struct, transporter_hold) DEFINE_FIELD_X(DukePlayer, player_struct, last_full_weapon) DEFINE_FIELD_X(DukePlayer, player_struct, footprintshade) DEFINE_FIELD_X(DukePlayer, player_struct, boot_amount) DEFINE_FIELD_X(DukePlayer, player_struct, on_warping_sector) DEFINE_FIELD_X(DukePlayer, player_struct, footprintcount) DEFINE_FIELD_X(DukePlayer, player_struct, hbomb_on) DEFINE_FIELD_X(DukePlayer, player_struct, jumping_toggle) DEFINE_FIELD_X(DukePlayer, player_struct, rapid_fire_hold) DEFINE_FIELD_X(DukePlayer, player_struct, on_ground) DEFINE_FIELD_X(DukePlayer, player_struct, inven_icon) DEFINE_FIELD_X(DukePlayer, player_struct, buttonpalette) DEFINE_FIELD_X(DukePlayer, player_struct, jetpack_on) DEFINE_FIELD_X(DukePlayer, player_struct, spritebridge) DEFINE_FIELD_X(DukePlayer, player_struct, lastrandomspot) DEFINE_FIELD_X(DukePlayer, player_struct, scuba_on) DEFINE_FIELD_X(DukePlayer, player_struct, footprintpal) DEFINE_FIELD_X(DukePlayer, player_struct, heat_on) DEFINE_FIELD_X(DukePlayer, player_struct, holster_weapon) DEFINE_FIELD_X(DukePlayer, player_struct, falling_counter) DEFINE_FIELD_X(DukePlayer, player_struct, refresh_inventory) DEFINE_FIELD_X(DukePlayer, player_struct, toggle_key_flag) DEFINE_FIELD_X(DukePlayer, player_struct, knuckle_incs) DEFINE_FIELD_X(DukePlayer, player_struct, walking_snd_toggle) DEFINE_FIELD_X(DukePlayer, player_struct, palookup) DEFINE_FIELD_X(DukePlayer, player_struct, quick_kick_msg) DEFINE_FIELD_X(DukePlayer, player_struct, max_secret_rooms) DEFINE_FIELD_X(DukePlayer, player_struct, secret_rooms) DEFINE_FIELD_X(DukePlayer, player_struct, max_actors_killed) DEFINE_FIELD_X(DukePlayer, player_struct, actors_killed) DEFINE_FIELD_X(DukePlayer, player_struct, resurrected) DEFINE_FIELD_X(DukePlayer, player_struct, stairs) DEFINE_FIELD_X(DukePlayer, player_struct, detonate_count) //DEFINE_FIELD_X(DukePlayer, player_struct, noise.X) //DEFINE_FIELD_X(DukePlayer, player_struct, noise.Y) DEFINE_FIELD_X(DukePlayer, player_struct, noise_radius) DEFINE_FIELD_X(DukePlayer, player_struct, drink_timer) DEFINE_FIELD_X(DukePlayer, player_struct, eat_timer) DEFINE_FIELD_X(DukePlayer, player_struct, SlotWin) DEFINE_FIELD_X(DukePlayer, player_struct, recoil) DEFINE_FIELD_X(DukePlayer, player_struct, detonate_time) DEFINE_FIELD_X(DukePlayer, player_struct, yehaa_timer) DEFINE_FIELD_X(DukePlayer, player_struct, drink_amt) DEFINE_FIELD_X(DukePlayer, player_struct, eat) DEFINE_FIELD_X(DukePlayer, player_struct, drunkang) DEFINE_FIELD_X(DukePlayer, player_struct, eatang) DEFINE_FIELD_X(DukePlayer, player_struct, shotgun_state) DEFINE_FIELD_X(DukePlayer, player_struct, donoise) DEFINE_FIELD_X(DukePlayer, player_struct, keys) DEFINE_FIELD_X(DukePlayer, player_struct, drug_aspect) DEFINE_FIELD_X(DukePlayer, player_struct, drug_timer) DEFINE_FIELD_X(DukePlayer, player_struct, SeaSick) DEFINE_FIELD_X(DukePlayer, player_struct, MamaEnd) DEFINE_FIELD_X(DukePlayer, player_struct, moto_drink) DEFINE_FIELD_X(DukePlayer, player_struct, TiltStatus) DEFINE_FIELD_X(DukePlayer, player_struct, oTiltStatus) DEFINE_FIELD_X(DukePlayer, player_struct, VBumpNow) DEFINE_FIELD_X(DukePlayer, player_struct, VBumpTarget) DEFINE_FIELD_X(DukePlayer, player_struct, TurbCount) DEFINE_FIELD_X(DukePlayer, player_struct, drug_stat) DEFINE_FIELD_X(DukePlayer, player_struct, DrugMode) DEFINE_FIELD_X(DukePlayer, player_struct, lotag800kill) DEFINE_FIELD_X(DukePlayer, player_struct, sea_sick_stat) DEFINE_FIELD_X(DukePlayer, player_struct, hurt_delay2) DEFINE_FIELD_X(DukePlayer, player_struct, nocheat) DEFINE_FIELD_X(DukePlayer, player_struct, OnMotorcycle) DEFINE_FIELD_X(DukePlayer, player_struct, OnBoat) DEFINE_FIELD_X(DukePlayer, player_struct, moto_underwater) DEFINE_FIELD_X(DukePlayer, player_struct, NotOnWater) DEFINE_FIELD_X(DukePlayer, player_struct, MotoOnGround) DEFINE_FIELD_X(DukePlayer, player_struct, moto_do_bump) DEFINE_FIELD_X(DukePlayer, player_struct, moto_bump_fast) DEFINE_FIELD_X(DukePlayer, player_struct, moto_on_oil) DEFINE_FIELD_X(DukePlayer, player_struct, moto_on_mud) DEFINE_FIELD_X(DukePlayer, player_struct, vehForwardScale) DEFINE_FIELD_X(DukePlayer, player_struct, vehReverseScale) DEFINE_FIELD_X(DukePlayer, player_struct, MotoSpeed) DEFINE_FIELD_X(DukePlayer, player_struct, vehTurnLeft) DEFINE_FIELD_X(DukePlayer, player_struct, vehTurnRight) DEFINE_FIELD_X(DukePlayer, player_struct, vehBraking) DEFINE_FIELD_X(DukePlayer, player_struct, holoduke_on) DEFINE_FIELD_X(DukePlayer, player_struct, actorsqu) DEFINE_FIELD_X(DukePlayer, player_struct, wackedbyactor) DEFINE_FIELD_X(DukePlayer, player_struct, on_crane) DEFINE_FIELD_X(DukePlayer, player_struct, somethingonplayer) DEFINE_FIELD_X(DukePlayer, player_struct, access_spritenum) DEFINE_FIELD_X(DukePlayer, player_struct, dummyplayersprite) DEFINE_FIELD_X(DukePlayer, player_struct, newOwner) DEFINE_FIELD_X(DukePlayer, player_struct, fric) DEFINE_ACTION_FUNCTION(_DukePlayer, IsFrozen) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); ACTION_RETURN_BOOL(self->GetActor()->spr.pal == 1 && self->last_extra < 2); } DEFINE_ACTION_FUNCTION(_DukePlayer, GetGameVar) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); PARAM_STRING(name); PARAM_INT(def); ACTION_RETURN_INT(GetGameVar(name, def, self->GetActor(), self->GetPlayerNum()).safeValue()); } void dukeplayer_backuppos(player_struct* self) { self->backuppos(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, backuppos, dukeplayer_backuppos) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); dukeplayer_backuppos(self); return 0; } void dukeplayer_backupxyz(player_struct* self) { self->GetActor()->backuppos(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, backupxyz, dukeplayer_backupxyz) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); dukeplayer_backupxyz(self); return 0; } void dukeplayer_setpos(player_struct* self, double x, double y, double z) { self->GetActor()->spr.pos = { x, y, z + self->GetActor()->viewzoffset }; } DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, setpos, dukeplayer_setpos) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); dukeplayer_setpos(self, x, y, z); return 0; } void dukeplayer_addpos(player_struct* self, double x, double y, double z) { self->GetActor()->spr.pos += { x, y, z }; } DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, addpos, dukeplayer_addpos) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); dukeplayer_addpos(self, x, y, z); return 0; } void dukeplayer_settargetangle(player_struct* self, double a, int backup) { self->angle.settarget(DAngle::fromDeg(a), backup); } DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, settargetangle, dukeplayer_settargetangle) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); PARAM_FLOAT(a); PARAM_BOOL(bak); dukeplayer_settargetangle(self, a, bak); return 0; } double dukeplayer_angle(player_struct* self) { return self->angle.ang.Degrees(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, angle, dukeplayer_angle) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); ACTION_RETURN_FLOAT(dukeplayer_angle(self)); } DEFINE_ACTION_FUNCTION_NATIVE(_DukePlayer, clearcameras, clearcameras) { PARAM_SELF_STRUCT_PROLOGUE(player_struct); clearcameras(self); return 0; } static DDukeActor* duke_firstStat(DukeStatIterator* it, int statnum) { it->Reset(statnum); return it->Next(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeStatIterator, First, duke_firstStat) { PARAM_SELF_STRUCT_PROLOGUE(DukeStatIterator); PARAM_INT(Sect); ACTION_RETURN_POINTER(duke_firstStat(self, Sect)); } static DDukeActor* duke_nextStat(DukeStatIterator* it) { return it->Next(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeStatIterator, Next, duke_nextStat) { PARAM_SELF_STRUCT_PROLOGUE(DukeStatIterator); ACTION_RETURN_POINTER(duke_nextStat(self)); } static DDukeActor* duke_firstSect(DukeSectIterator* it, sectortype* sect) { if (sect == nullptr) return nullptr; it->Reset(sect); return it->Next(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeSectIterator, First, duke_firstSect) { PARAM_SELF_STRUCT_PROLOGUE(DukeSectIterator); PARAM_POINTER(sect, sectortype); ACTION_RETURN_POINTER(duke_firstSect(self, sect)); } static DDukeActor* duke_nextSect(DukeSectIterator* it) { return it->Next(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeSectIterator, Next, duke_nextSect) { PARAM_SELF_STRUCT_PROLOGUE(DukeSectIterator); ACTION_RETURN_POINTER(duke_nextSect(self)); } static DDukeActor* duke_firstSprite(DukeSpriteIterator* it) { it->Reset(); return it->Next(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeSpriteIterator, First, duke_firstSprite) { PARAM_SELF_STRUCT_PROLOGUE(DukeSpriteIterator); ACTION_RETURN_POINTER(duke_firstSprite(self)); } static DDukeActor* duke_nextSprite(DukeSpriteIterator* it) { return it->Next(); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeSpriteIterator, Next, duke_nextSprite) { PARAM_SELF_STRUCT_PROLOGUE(DukeSpriteIterator); ACTION_RETURN_POINTER(duke_nextSprite(self)); } DDukeActor* DukeLevel_SpawnActor(DukeLevel* self, sectortype* sect, double x, double y, double z, PClassActor* type, int shade, double scalex, double scaley, double angle, double vel, double zvel, DDukeActor* owner, int stat) { return SpawnActor(sect, DVector3(x, y, z), type, shade, DVector2(scalex, scaley), DAngle::fromDeg(angle), vel, zvel, owner, stat); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, SpawnActor, DukeLevel_SpawnActor) { PARAM_SELF_STRUCT_PROLOGUE(DukeLevel); PARAM_POINTER(sect, sectortype); PARAM_FLOAT(x); PARAM_FLOAT(y); PARAM_FLOAT(z); PARAM_CLASS(type, DDukeActor); PARAM_INT(shade); PARAM_FLOAT(scalex); PARAM_FLOAT(scaley); PARAM_FLOAT(angle); PARAM_FLOAT(vel); PARAM_FLOAT(zvel); PARAM_OBJECT(owner, DDukeActor); PARAM_INT(stat); ACTION_RETURN_POINTER(DukeLevel_SpawnActor(self, sect, x, y, z, static_cast(type), shade, scalex, scaley, angle, vel, zvel, owner, stat)); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, check_activator_motion, check_activator_motion) { PARAM_PROLOGUE; PARAM_INT(lotag); ACTION_RETURN_INT(check_activator_motion(lotag)); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, operatemasterswitches, operatemasterswitches) { PARAM_PROLOGUE; PARAM_INT(lotag); operatemasterswitches(lotag); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, operateactivators, operateactivators) { PARAM_PROLOGUE; PARAM_INT(lotag); PARAM_POINTER(p, player_struct); operateactivators(lotag, p); return 0; } int duke_floorflags(sectortype* sector) { return gs.tileinfo[sector->floorpicnum].flags; } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, floorflags, duke_floorflags) { PARAM_PROLOGUE; PARAM_POINTER(sect, sectortype); ACTION_RETURN_INT(duke_floorflags(sect)); } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, addcycler, addcycler) { PARAM_PROLOGUE; PARAM_POINTER(sect, sectortype); PARAM_INT(lotag); PARAM_INT(shade); PARAM_INT(shade2); PARAM_INT(hitag); PARAM_INT(state); addcycler(sect, lotag, shade, shade2, hitag, state); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, addtorch, addtorch) { PARAM_PROLOGUE; PARAM_POINTER(sect, sectortype); PARAM_INT(shade); PARAM_INT(lotag); addtorch(sect, shade, lotag); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, addlightning, addlightning) { PARAM_PROLOGUE; PARAM_POINTER(sect, sectortype); PARAM_INT(shade); addlightning(sect, shade); return 0; } DEFINE_ACTION_FUNCTION_NATIVE(_DukeLevel, addambient, addambient) { PARAM_PROLOGUE; PARAM_INT(hitag); PARAM_INT(lotag); ACTION_RETURN_INT(addambient(hitag, lotag)); return 0; } DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, playerfriction); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, gravity); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, respawnactortime); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, bouncemineblastradius); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, respawnitemtime); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, morterblastradius); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, numfreezebounces); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, pipebombblastradius); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, rpgblastradius); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, seenineblastradius); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, shrinkerblastradius); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, tripbombblastradius); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, camerashitable); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, max_player_health); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, max_armour_amount); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, lasermode); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, freezerhurtowner); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, impact_damage); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, playerheight); DEFINE_FIELD_X(DukeGameInfo, DukeGameInfo, displayflags); DEFINE_GLOBAL_UNSIZED(gs) DEFINE_FIELD_X(DukeUserDefs, user_defs, god); DEFINE_FIELD_X(DukeUserDefs, user_defs, cashman); DEFINE_FIELD_X(DukeUserDefs, user_defs, eog); DEFINE_FIELD_X(DukeUserDefs, user_defs, clipping); DEFINE_FIELD_X(DukeUserDefs, user_defs, user_pals); DEFINE_FIELD_X(DukeUserDefs, user_defs, from_bonus); DEFINE_FIELD_X(DukeUserDefs, user_defs, last_level); DEFINE_FIELD_X(DukeUserDefs, user_defs, secretlevel); DEFINE_FIELD_X(DukeUserDefs, user_defs, const_visibility); DEFINE_FIELD_X(DukeUserDefs, user_defs, coop); DEFINE_FIELD_X(DukeUserDefs, user_defs, respawn_monsters); DEFINE_FIELD_X(DukeUserDefs, user_defs, respawn_items); DEFINE_FIELD_X(DukeUserDefs, user_defs, respawn_inventory); DEFINE_FIELD_X(DukeUserDefs, user_defs, recstat); DEFINE_FIELD_X(DukeUserDefs, user_defs, monsters_off); DEFINE_FIELD_X(DukeUserDefs, user_defs, brightness); DEFINE_FIELD_X(DukeUserDefs, user_defs, ffire); DEFINE_FIELD_X(DukeUserDefs, user_defs, multimode); DEFINE_FIELD_X(DukeUserDefs, user_defs, player_skill); DEFINE_FIELD_X(DukeUserDefs, user_defs, marker); DEFINE_FIELD_X(DukeUserDefs, user_defs, bomb_tag); DEFINE_FIELD_X(DukeUserDefs, user_defs, cameraactor); DEFINE_GLOBAL_UNSIZED(ud) // this is only a temporary helper until weaponsandammosprites can be migrated to real class types. We absolutely do not want any access to tile numbers in the scripts - even now. void tspritetype_setWeaponOrAmmoSprite(tspritetype* targ, unsigned z) { if (z < 15) { targ->picnum = gs.weaponsandammosprites[z]; } } DEFINE_ACTION_FUNCTION_NATIVE(_tspritetype, setWeaponOrAmmoSprite, tspritetype_setWeaponOrAmmoSprite) { PARAM_SELF_STRUCT_PROLOGUE(tspritetype); PARAM_INT(z); tspritetype_setWeaponOrAmmoSprite(self, z); return 0; } END_DUKE_NS