teambeef/raze
0
0
Fork 0
mirror of https://github.com/DrBeef/Raze.git synced 2024-11-15 00:41:55 +00:00
Code Issues Projects Releases Packages Wiki Activity

- scriptified the jibs

Browse source
This commit is contained in:
Christoph Oelckers 2022-11-22 21:22:26 +01:00
parent 1b3f551216
commit 3ac8bd02f5
19 changed files with 616 additions and 350 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
source/core/thingdef_properties.cpp
View file

@ -305,13 +305,17 @@ static bool PointerCheck(PType *symtype, PType *checktype)
//==========================================================================
//
// Unlike 'spriteset' this only replaces the first image so that it
// can reuse the previously defined set, except for the base image.
//
//==========================================================================
DEFINE_PROPERTY(pic, S, CoreActor)
{
PROP_STRING_PARM(str, 0);
info->ActorInfo()->SpriteSetNames.Clear();
info->ActorInfo()->SpriteSetNames.Push(str);
if (info->ActorInfo()->SpriteSetNames.Size() == 0)
info->ActorInfo()->SpriteSetNames.Push(str);
else
info->ActorInfo()->SpriteSetNames[0] = str;
bag.Info->ActorInfo()->DefaultFlags |= DEFF_PICNUM;
}

19
source/core/vmexports.cpp
View file

@ -379,6 +379,25 @@ DEFINE_ACTION_FUNCTION_NATIVE(_sectortype, ceilingslope, sector_ceilingslope)
ACTION_RETURN_INT(self->getceilingslope());
}
double sector_getslopes(sectortype* sect, double x, double y, double *pf)
{
if (!sect) ThrowAbortException(X_READ_NIL, nullptr);
double pc;
calcSlope(sect, x, y, &pc, pf);
return pc;
}
DEFINE_ACTION_FUNCTION_NATIVE(_sectortype, getslopes, sector_getslopes)
{
PARAM_SELF_STRUCT_PROLOGUE(sectortype);
PARAM_FLOAT(x);
PARAM_FLOAT(y);
double c, f;
calcSlope(self, x, y, &c, &f);
if (numret > 0) ret[0].SetFloat(c);
if (numret > 1) ret[1].SetFloat(f);
return min(numret, 2);
}
//=============================================================================

128
source/games/duke/src/actors.cpp
View file

@ -1406,134 +1406,6 @@ bool money(DDukeActor* actor, int BLOODPOOL)
//
//---------------------------------------------------------------------------
bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool floorcheck, bool zcheck1, bool zcheck2)
{
auto sectp = actor->sector();
if(actor->vel.X > 0) actor->vel.X -= 1/16.;
else actor->vel.X = 0;
if (timeout)
{
if (actor->temp_data[5] < 30 * 10)
actor->temp_data[5]++;
else
{
actor->Destroy();
return false;
}
}
if (actor->vel.Z > 4 && actor->vel.Z < 5)
{
SetActor(actor, actor->spr.pos);
sectp = actor->sector();
}
if (callsetsprite) SetActor(actor, actor->spr.pos);
// this was after the slope calls, but we should avoid calling that for invalid sectors.
if (!actor->insector())
{
actor->Destroy();
return false;
}
double fz = getflorzofslopeptr(sectp, actor->spr.pos);
double cz = getceilzofslopeptr(sectp, actor->spr.pos);
if (cz == fz)
{
actor->Destroy();
return false;
}
if (actor->spr.pos.Z < fz - 2)
{
if (actor->temp_data[1] < 2) actor->temp_data[1]++;
else if (sectp->lotag != 2)
{
actor->temp_data[1] = 0;
if (zcheck1)
{
if (actor->temp_data[0] > 6) actor->temp_data[0] = 0;
else actor->temp_data[0]++;
}
else
{
if (actor->temp_data[0] > 2)
actor->temp_data[0] = 0;
else actor->temp_data[0]++;
}
}
if (actor->vel.Z < 24)
{
if (sectp->lotag == 2)
{
if (actor->vel.Z < 4)
actor->vel.Z += 3 / 16.;
else actor->vel.Z = 4;
}
else actor->vel.Z += ( gs.gravity - 50/256.);
}
actor->spr.pos += actor->spr.Angles.Yaw.ToVector() * actor->vel.X;
actor->spr.pos.Z += actor->vel.Z;
if (floorcheck && actor->spr.pos.Z >= actor->sector()->floorz)
{
actor->Destroy();
return false;
}
}
else
{
if (zcheck2)
{
actor->Destroy();
return false;
}
if (actor->temp_data[2] == 0)
{
if (!actor->insector())
{
actor->Destroy();
return false;
}
if ((actor->sector()->floorstat & CSTAT_SECTOR_SLOPE))
{
actor->Destroy();
return false;
}
actor->temp_data[2]++;
}
double ll = getflorzofslopeptr(actor->sector(), actor->spr.pos);
actor->spr.pos.Z = ll - 2;
actor->vel.X = 0;
if (actor->spr.picnum == JIBS6)
{
actor->temp_data[1]++;
if ((actor->temp_data[1] & 3) == 0 && actor->temp_data[0] < 7)
actor->temp_data[0]++;
if (actor->temp_data[1] > 20)
{
actor->Destroy();
return false;
}
}
else { actor->spr.picnum = JIBS6; actor->temp_data[0] = 0; actor->temp_data[1] = 0; }
}
return true;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool bloodpool(DDukeActor* actor, bool puke)
{
auto sectp = actor->sector();

18
source/games/duke/src/actors_d.cpp
View file

@ -2576,24 +2576,6 @@ void moveexplosions_d(void) // STATNUM 5
money(act, BLOODPOOL);
break;
case JIBS1:
case JIBS2:
case JIBS3:
case JIBS4:
case JIBS5:
case JIBS6:
case HEADJIB1:
case ARMJIB1:
case LEGJIB1:
case LIZMANHEAD1:
case LIZMANARM1:
case LIZMANLEG1:
case DUKETORSO:
case DUKEGUN:
case DUKELEG:
jibs(act, JIBS6, true, false, false, act->spr.picnum == DUKELEG || act->spr.picnum == DUKETORSO || act->spr.picnum == DUKEGUN, false);
continue;
case BLOODPOOL:
case PUKE:
bloodpool(act, act->spr.picnum == PUKE);

52
source/games/duke/src/actors_r.cpp
View file

@ -2538,58 +2538,6 @@ void moveexplosions_r(void) // STATNUM 5
break;
case BIKEJIBA:
case BIKEJIBB:
case BIKEJIBC:
case BIKERJIBA:
case BIKERJIBB:
case BIKERJIBC:
case BIKERJIBD:
case CHEERJIBA:
case CHEERJIBB:
case CHEERJIBC:
case CHEERJIBD:
case FBOATJIBA:
case FBOATJIBB:
case RABBITJIBA:
case RABBITJIBB:
case RABBITJIBC:
case MAMAJIBA:
case MAMAJIBB:
if (!isRRRA()) break;
[[fallthrough]];
case BILLYJIBA:
case BILLYJIBB:
case HULKJIBA:
case HULKJIBB:
case HULKJIBC:
case MINJIBA:
case MINJIBB:
case MINJIBC:
case COOTJIBA:
case COOTJIBB:
case COOTJIBC:
case JIBS1:
case JIBS2:
case JIBS3:
case JIBS4:
case JIBS5:
case JIBS6:
case DUKETORSO:
case DUKEGUN:
case DUKELEG:
if (!jibs(act, JIBS6, false, true, true, act->spr.picnum == DUKELEG || act->spr.picnum == DUKETORSO || act->spr.picnum == DUKEGUN, false)) continue;
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - 8)
{
act->Destroy();
continue;
}
continue;
case BLOODPOOL:
if (!bloodpool(act, false)) continue;

18
source/games/duke/src/animatesprites_d.cpp
View file

@ -421,24 +421,6 @@ void animatesprites_d(tspriteArray& tsprites, const DVector2& viewVec, DAngle vi
break;
case JIBS1:
case JIBS2:
case JIBS3:
case JIBS4:
case JIBS5:
case JIBS6:
case HEADJIB1:
case LEGJIB1:
case ARMJIB1:
case LIZMANHEAD1:
case LIZMANARM1:
case LIZMANLEG1:
case DUKELEG:
case DUKEGUN:
case DUKETORSO:
if (t->pal == 6) t->shade = -120;
[[fallthrough]];
case WATERBUBBLE:
if (t->sectp->floorpicnum == FLOORSLIME)
{

51
source/games/duke/src/animatesprites_r.cpp
View file

@ -526,57 +526,6 @@ void animatesprites_r(tspriteArray& tsprites, const DVector2& viewVec, DAngle vi
break;
case BIKEJIBA:
case BIKEJIBB:
case BIKEJIBC:
case BIKERJIBA:
case BIKERJIBB:
case BIKERJIBC:
case BIKERJIBD:
case CHEERJIBA:
case CHEERJIBB:
case CHEERJIBC:
case CHEERJIBD:
case FBOATJIBA:
case FBOATJIBB:
case RABBITJIBA:
case RABBITJIBB:
case RABBITJIBC:
case MAMAJIBA:
case MAMAJIBB:
if (isRRRA()) goto stuff;
else goto default_case;
case MINJIBA:
case MINJIBB:
case MINJIBC:
if (isRRRA() && t->pal == 19)
t->shade = -127;
[[fallthrough]];
case JIBS1:
case JIBS2:
case JIBS3:
case JIBS4:
case JIBS5:
case JIBS6:
case DUKEGUN:
case DUKETORSO:
case DUKELEG:
case BILLYJIBA:
case BILLYJIBB:
case HULKJIBA:
case HULKJIBB:
case HULKJIBC:
case COOTJIBA:
case COOTJIBB:
case COOTJIBC:
stuff:
if (t->pal == 6) t->shade = -120;
if (h->sector()->shadedsector == 1)
t->shade = 16;
[[fallthrough]];
case WATERBUBBLE:
if (t->sectp->floorpicnum == FLOORSLIME)
{

1
source/games/duke/src/funct.h
View file

@ -52,7 +52,6 @@ void forcesphereexplode(DDukeActor* i);
void watersplash2(DDukeActor* i);
void frameeffect1(DDukeActor* i);
bool money(DDukeActor* i, int BLOODPOOL);
bool jibs(DDukeActor* i, int JIBS6, bool timeout, bool callsetsprite, bool floorcheck, bool zcheck1, bool zcheck2);
bool bloodpool(DDukeActor* i, bool puke);
void shell(DDukeActor* i, bool morecheck);
void glasspieces(DDukeActor* i);

24
source/games/duke/src/spawn_d.cpp
View file

@ -187,32 +187,8 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case NUKEBUTTON:
if (act->spr.picnum == DOMELITE)
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
[[fallthrough]];
case JIBS1:
case JIBS2:
case JIBS3:
case JIBS4:
case JIBS5:
case JIBS6:
case HEADJIB1:
case ARMJIB1:
case LEGJIB1:
case LIZMANHEAD1:
case LIZMANARM1:
case LIZMANLEG1:
case DUKETORSO:
case DUKEGUN:
case DUKELEG:
ChangeActorStat(act, STAT_MISC);
break;
case TONGUE:
if (actj)
act->spr.Angles.Yaw = actj->spr.Angles.Yaw;
act->spr.pos.Z -= gs.playerheight;
act->vel.Z = 1 - krandf(2);
act->vel.X = 4 - krandf(8);
ChangeActorStat(act, STAT_PROJECTILE);
break;
case NATURALLIGHTNING:
act->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;

18
source/games/duke/src/vmexports.cpp
View file

@ -395,24 +395,6 @@ DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, movesprite, DukeActor_movesprite)
ACTION_RETURN_INT(DukeActor_movesprite(self, velx, vely, velz, clipmask));
}
int DukeActor_jibs(DDukeActor* actor, int jib6mode, int timeout, int callsetsprite, int floorcheck, int zcheck1, int zcheck2)
{
return jibs(actor, -1 /* fixme*/, timeout, callsetsprite, floorcheck, zcheck1, zcheck2);
}
DEFINE_ACTION_FUNCTION_NATIVE(DDukeActor, jibs, DukeActor_jibs)
{
PARAM_SELF_PROLOGUE(DDukeActor);
PARAM_INT(jib6mode);
PARAM_INT(timeout);
PARAM_INT(callsetsprite);
PARAM_INT(floorcheck);
PARAM_INT(zcheck1);
PARAM_INT(zcheck2);
ACTION_RETURN_INT(DukeActor_jibs(self, jib6mode, timeout, callsetsprite, floorcheck, zcheck1, zcheck2));
}
DDukeActor* DukeActor_Spawnsprite(DDukeActor* origin, int picnum)
{
if (picnum >= 0 && picnum < MAXTILES)

15
wadsrc/static/filter/dukelike/engine/engine.def
View file

@ -61,6 +61,21 @@ spawnclasses
1647 = DukeTongue
1860 = DukeInnerJaw
1861 = DukeInnerJaw1
2245 = DukeJibs1
2250 = DukeJibs2
2255 = DukeJibs3
2260 = DukeJibs4
2265 = DukeJibs5
2286 = DukeJibs6
1768 = DukeHeadJib1
1772 = DukeArmJib1
1776 = DukeLegJib1
2201 = DukeLizmanHead
2205 = DukeLizmanArm
2209 = DukeLizmanLeg
1520 = DukePlayerTorso
1528 = DukePlayerGun
1536 = DukePlayerLeg
}

18
wadsrc/static/filter/redneck.ridesagain/engine/engine.def
View file

@ -12,6 +12,24 @@ spawnclasses
2460 = RedneckCactusDebris1
2465 = RedneckCactusDebris2
7424 = RedneckRabbitSpawner
5872 = RedneckBikeJibA
5877 = RedneckBikeJibB
5882 = RedneckBikeJibC
6112 = RedneckBikerJibA
6117 = RedneckBikerJibB
6121 = RedneckBikerJibC
6127 = RedneckBikerJibD
7000 = RedneckCheerJibA
7005 = RedneckCheerJibB
7010 = RedneckCheerJibC
7015 = RedneckCheerJibD
7020 = RedneckFBoatJibA
7025 = RedneckFBoatJibB
7387 = RedneckRabbitJibA
7392 = RedneckRabbitJibB
7397 = RedneckRabbitJibC
8890 = RedneckMamaJibA
8895 = RedneckMamaJibB
}
tileflag TFLAG_WALLSWITCH {

21
wadsrc/static/filter/redneck/engine/engine.def
View file

@ -69,7 +69,26 @@ spawnclasses
3132 = RedneckChickenHead
3410 = RedneckLumberBlade
295 = RedneckKegHolder
1463 = DukeJibs1
1468 = DukeJibs2
1473 = DukeJibs3
1478 = DukeJibs4
1483 = DukeJibs5
1515 = DukeJibs6
4041 = DukePlayerTorso
4046 = DukePlayerGun
4055 = DukePlayerLeg
4235 = RedneckBillyJibA
4244 = RedneckBillyJibB
4748 = RedneckHulkJibA
4753 = RedneckHulkJibB
4758 = RedneckHulkJibB
5290 = RedneckMinJibA
5295 = RedneckMinJibB
5300 = RedneckMinJibB
5602 = RedneckCootJibA
5607 = RedneckCootJibB
5616 = RedneckCootJibB
}
tileflag TFLAG_WALLSWITCH {

2
wadsrc/static/zscript.txt
View file

@ -56,6 +56,8 @@ version "4.10"
#include "zscript/games/duke/actors/touchplate.zs"
#include "zscript/games/duke/actors/soundcontroller.zs"
#include "zscript/games/duke/actors/respawncontroller.zs"
#include "zscript/games/duke/actors/jibs.zs"
#include "zscript/games/duke/actors/crane.zs"
#include "zscript/games/duke/actors/waterfountain.zs"
#include "zscript/games/duke/actors/flammables.zs"

526
wadsrc/static/zscript/games/duke/actors/jibs.zs Normal file
View file

@ -0,0 +1,526 @@
class DukeJibs1 : DukeActor
{
default
{
statnum STAT_MISC;
spriteset "JIBS1", "JIBS6";
}
override void Tick()
{
if(self.vel.X > 0) self.vel.X -= 1/16.;
else self.vel.X = 0;
if (!Raze.IsRR())
{
if (self.temp_data[5] < 30 * 10)
self.temp_data[5]++;
else
{
self.Destroy();
return;
}
}
let sectp = self.sector;
// this was after the slope calls, but we should avoid calling that for invalid sectors.
if (sectp == null)
{
self.Destroy();
return;
}
double fz, cz;
[cz, fz] = sectp.GetSlopes(self.pos.XY);
if (cz >= fz)
{
self.Destroy();
return;
}
if (self.pos.Z < fz - 2)
{
if (self.temp_data[1] < 2) self.temp_data[1]++;
else if (sectp.lotag != 2)
{
self.temp_data[1] = 0;
if (detail == 1)
{
if (self.temp_data[0] > 6) self.temp_data[0] = 0;
else self.temp_data[0]++;
}
else
{
if (self.temp_data[0] > 2)
self.temp_data[0] = 0;
else self.temp_data[0]++;
}
}
if (self.vel.Z < 24)
{
if (sectp.lotag == 2)
{
if (self.vel.Z < 4)
self.vel.Z += 3 / 16.;
else self.vel.Z = 4;
}
else self.vel.Z += ( gs.gravity - 50/256.);
}
self.pos += self.angle.ToVector() * self.vel.X;
self.pos.Z += self.vel.Z;
if (Raze.IsRR() && self.pos.Z >= self.sector.floorz)
{
self.Destroy();
return;
}
}
else
{
if (self.detail == 2) // cactus debris only
{
self.Destroy();
return;
}
if (self.temp_data[2] == 0)
{
if ((self.sector.floorstat & CSTAT_SECTOR_SLOPE))
{
self.Destroy();
return;
}
self.temp_data[2]++;
}
self.pos.Z = fz - 2;
self.vel.X = 0;
if (self.spritesetindex == 1)
{
self.temp_data[1]++;
if ((self.temp_data[1] & 3) == 0 && self.temp_data[0] < 7)
self.temp_data[0]++;
if (self.temp_data[1] > 20)
{
self.Destroy();
return;
}
}
else if (self.getspritesetsize() > 1)
{
self.setSpritesetImage(1);
self.temp_data[0] = 0;
self.temp_data[1] = 0;
}
else
{
self.Destroy();
return;
}
}
if (Raze.IsRR() && self.sector.lotag == 800 && self.pos.Z >= self.sector.floorz - 8)
{
self.Destroy();
return;
}
// always keep the sector up to date. The orignal code did not.
self.SetPosition(self.pos);
}
override bool animate(tspritetype tspr)
{
if (Raze.isRRRA() && tspr.pal == 19)
tspr.shade = -127;
if (tspr.pal == 6) tspr.shade = -120;
if (self.sector.shadedsector == 1)
tspr.shade = 16;
return true;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
class DukeJibs2 : DukeJibs1
{
default
{
pic "JIBS2";
}
}
class DukeJibs3 : DukeJibs1
{
default
{
pic "JIBS3";
}
}
class DukeJibs4 : DukeJibs1
{
default
{
pic "JIBS4";
}
}
class DukeJibs5 : DukeJibs1
{
default
{
pic "JIBS5";
}
}
class DukeJibs6 : DukeJibs1
{
default
{
spritesetindex 1;
}
}
class DukeHeadJib1 : DukeJibs1
{
default
{
pic "HEADJIB1";
}
}
class DukeArmJib1 : DukeJibs1
{
default
{
pic "ARMJIB1";
}
}
class DukeLegJib1 : DukeJibs1
{
default
{
pic "LEGJIB1";
}
}
class DukeLizmanHead : DukeJibs1
{
default
{
pic "LIZMANHEAD1";
}
}
class DukeLizmanArm : DukeJibs1
{
default
{
pic "LIZMANARM1";
}
}
class DukeLizmanLeg : DukeJibs1
{
default
{
pic "LIZMANLEG1";
}
}
class DukePlayerTorso : DukeJibs1
{
default
{
pic "DUKETORSO";
detail 1;
}
}
class DukePlayerGun : DukePlayerTorso
{
default
{
pic "DUKEGUN";
}
}
class DukePlayerLeg : DukePlayerTorso
{
default
{
pic "DUKELEG";
}
}
// --------------------------- RR Jibs
class RedneckBillyJibA : DukeJibs1
{
default
{
pic "BILLYJIBA";
}
}
class RedneckBillyJibB : DukeJibs1
{
default
{
pic "BILLYJIBB";
}
}
class RedneckHulkJibA : DukeJibs1
{
default
{
pic "HULKJIBA";
}
}
class RedneckHulkJibB : DukeJibs1
{
default
{
pic "HULKJIBB";
}
}
class RedneckHulkJibC : DukeJibs1
{
default
{
pic "HULKJIBC";
}
}
class RedneckMinJibA : DukeJibs1
{
default
{
pic "MINJIBA";
}
}
class RedneckMinJibB : DukeJibs1
{
default
{
pic "MINJIBB";
}
}
class RedneckMinJibC : DukeJibs1
{
default
{
pic "MINJIBC";
}
}
class RedneckCootJibA : DukeJibs1
{
default
{
pic "COOTJIBA";
}
}
class RedneckCootJibB : DukeJibs1
{
default
{
pic "COOTJIBB";
}
}
class RedneckCootJibC : DukeJibs1
{
default
{
pic "COOTJIBC";
}
}
// --------------------------- RRRA Jibs
class RedneckBikeJibA : DukeJibs1
{
default
{
pic "BIKEJIBA";
}
}
class RedneckBikeJibB : DukeJibs1
{
default
{
pic "BIKEJIBB";
}
}
class RedneckBikeJibC : DukeJibs1
{
default
{
pic "BIKEJIBC";
}
}
class RedneckBikerJibA : DukeJibs1
{
default
{
pic "BIKERJIBA";
}
}
class RedneckBikerJibB : DukeJibs1
{
default
{
pic "BIKERJIBB";
}
}
class RedneckBikerJibC : DukeJibs1
{
default
{
pic "BIKERJIBC";
}
}
class RedneckBikerJibD : DukeJibs1
{
default
{
pic "BIKERJIBd";
}
}
class RedneckCheerJibA : DukeJibs1
{
default
{
pic "CHEERJIBA";
}
}
class RedneckCheerJibB : DukeJibs1
{
default
{
pic "CHEERJIBB";
}
}
class RedneckCheerJibC : DukeJibs1
{
default
{
pic "CHEERJIBC";
}
}
class RedneckCheerJibD : DukeJibs1
{
default
{
pic "CHEERJIBd";
}
}
class RedneckFBoatJibA : DukeJibs1
{
default
{
pic "FBOATJIBA";
}
}
class RedneckFBoatJibB : DukeJibs1
{
default
{
pic "FBOATJIBB";
}
}
class RedneckMamaJibA : DukeJibs1
{
default
{
pic "MAMAJIBA";
}
}
class RedneckMamaJibB : DukeJibs1
{
default
{
pic "MAMAJIBB";
}
}
class RedneckRabbitJibA : DukeJibs1
{
default
{
pic "RABBITJIBA";
}
}
class RedneckRabbitJibB : DukeJibs1
{
default
{
pic "RABBITJIBB";
}
}
class RedneckRabbitJibC : DukeJibs1
{
default
{
pic "RABBITJIBC";
}
}
// ---------------------------------
class RedneckCactusDebris1 : DukeJibs1
{
default
{
pic "CACTUSDEBRIS1";
detail 2;
}
}
class RedneckCactusDebris2 : RedneckCactusDebris1
{
default
{
pic "CACTUSDEBRIS2";
}
}

35
wadsrc/static/zscript/games/duke/actors/rrcactus.zs
View file

@ -175,38 +175,3 @@ class RedneckCactusSmall : RedneckCactusDrug
}
}
// ---------------------------------
class RedneckCactusDebris1 : DukeActor
{
default
{
statnum STAT_MISC;
pic "CACTUSDEBRIS1";
}
override void Tick()
{
if (!self.jibs(false, false, true, true, false, true)) return; // very poor API... Change this when jibs can be scriptified.
if (self.sector.lotag == 800 && self.pos.Z >= self.sector.floorz - 8)
self.Destroy();
}
override bool animate(tspritetype tspr)
{
if (tspr.pal == 6) tspr.shade = -120;
if (self.sector.shadedsector == 1)
tspr.shade = 16;
return true;
}
}
class RedneckCactusDebris2 : RedneckCactusDebris1
{
default
{
pic "CACTUSDEBRIS2";
}
}

10
wadsrc/static/zscript/games/duke/actors/tongue.zs
View file

@ -6,7 +6,15 @@ class DukeTongue : DukeActor
statnum STAT_PROJECTILE;
pic "TONGUE";
}
override void Initialize()
{
self.angle = self.ownerActor.angle;
self.pos.Z -= gs.playerheight;
self.vel.Z = 1 - frandom(0, 2);
self.vel.X = 4 - frandom(0, 8);
}
override void Tick()
{
self.temp_data[0] = int(Raze.BobVal(self.temp_data[1]) * 32);

1
wadsrc/static/zscript/games/duke/dukeactor.zs
View file

@ -193,7 +193,6 @@ class DukeActor : CoreActor native
native void lotsofstuff(Name type, int count);
native void spawnguts(Name type, int count);
native int movesprite(Vector3 move, int clipmask);
native bool jibs(bool jib6mode, bool timeout, bool callsetsprite, bool floorcheck, bool zcheck1, bool zcheck2);
// temporary flag accessors - need to be eliminated once we can have true actor flags

1
wadsrc/static/zscript/maptypes.zs
View file

@ -215,6 +215,7 @@ struct sectortype native
native void setfloorslope(int heinum);
native int ceilingslope();
native int floorslope();
native double, double getslopes(Vector2 pos);
}
//=============================================================================