zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-11-11 07:11:54 +00:00
Code Issues Projects Releases Packages Wiki Activity
qzdoom/wadsrc/static/zscript/actor.txt

1164 lines
47 KiB
Text
Raw Normal View History

- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
struct FCheckPosition
{
// in
native Actor thing;
native Vector3 pos;
// out
- exported FCheckPosition to the VM and completed the parameter lists for Actor.CheckPosition and Actor.TryMove.
2017-01-11 23:26:16 +00:00
native Sector cursector;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
native double floorz;
native double ceilingz;
native double dropoffz;
- exported FCheckPosition to the VM and completed the parameter lists for Actor.CheckPosition and Actor.TryMove.
2017-01-11 23:26:16 +00:00
native TextureID floorpic;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
native int floorterrain;
- exported FCheckPosition to the VM and completed the parameter lists for Actor.CheckPosition and Actor.TryMove.
2017-01-11 23:26:16 +00:00
native Sector floorsector;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
native TextureID ceilingpic;
- exported FCheckPosition to the VM and completed the parameter lists for Actor.CheckPosition and Actor.TryMove.
2017-01-11 23:26:16 +00:00
native Sector ceilingsector;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
native bool touchmidtex;
native bool abovemidtex;
native bool floatok;
native bool FromPMove;
native line ceilingline;
- exported FCheckPosition to the VM and completed the parameter lists for Actor.CheckPosition and Actor.TryMove.
2017-01-11 23:26:16 +00:00
native Actor stepthing;
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
native bool DoRipping;
native bool portalstep;
native int PushTime;
native void ClearLastRipped();
}
- scriptified the moving camera.
2017-01-13 21:13:03 +00:00
struct LinkContext
{
voidptr sector_list; // really msecnode but that's not exported yet.
voidptr render_list;
}
- added the ability to attach a constructor or destructor to an internally defined struct. There are a few which require explicit native construction or destruction that need to be exported to the VM, e.g. FCheckPosition. The VM cannot handle this directly, it needs two special functions to be attached to handle such elements.
2017-01-11 22:46:03 +00:00
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
class Actor : Thinker native
{
const DEFAULT_HEALTH = 1000;
- scriptified a_hereticmisc.cpp.
2016-11-18 20:34:06 +00:00
const ONFLOORZ = -2147483648.0;
const ONCEILINGZ = 2147483647.0;
const FLOATRANDZ = ONCEILINGZ-1;
- scriptified A_PainShootSkull which was the last remaining bit in g_doom, so this directory is gone now.
2016-11-23 18:47:09 +00:00
const TELEFRAG_DAMAGE = 1000000;
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
const MinVel = 1./65536;
- scriptified Hexen's Frost shards. - scriptified all SpecialMissileHit methods.
2016-11-27 20:41:04 +00:00
const LARGE_MASS = 10000000; // not INT_MAX on purpose
- the last scriptified bits of P_PlayerThink.
2017-04-30 22:25:21 +00:00
const ORIG_FRICTION = (0xE800/65536.); // original value
const ORIG_FRICTION_FACTOR = (2048/65536.); // original value
- scriptified A_PainShootSkull which was the last remaining bit in g_doom, so this directory is gone now.
2016-11-23 18:47:09 +00:00
- scriptified a_hereticmisc.cpp.
2016-11-18 20:34:06 +00:00
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
// flags are not defined here, the native fields for those get synthesized from the internal tables.
// for some comments on these fields, see their native representations in actor.h.
- scriptified Hexen's flies. A few notes: * this accesses the lines array in sector_t which effectively is a pointer to an array of pointers - a type the parser can not represent. The compiler has no problems with it, so for now it is defined internally. * array sizes were limited to 65536 entries because the 'bound' instruction only existed as an immediate version with no provisions for larger values. For the static map arrays 65536 is not sufficient so now there are alternative instructions for these cases. * despite the above, at the moment there is no proper bounds checking for arrays that have no fixed size. To do this, a lot more work is needed. The type system as-is is not prepared for such a scenario.
2016-11-27 17:52:24 +00:00
native readonly Actor snext; // next in sector list.
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
native PlayerInfo Player;
native readonly vector3 Pos;
native vector3 Prev;
native double spriteAngle;
native double spriteRotation;
native double VisibleStartAngle;
native double VisibleStartPitch;
native double VisibleEndAngle;
native double VisibleEndPitch;
native double Angle;
native double Pitch;
native double Roll;
native vector3 Vel;
native double Speed;
native double FloatSpeed;
native SpriteID sprite;
native uint8 frame;
native vector2 Scale;
native TextureID picnum;
native double Alpha;
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native readonly color fillcolor; // must be set with SetShade to initialize correctly.
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
native Sector CurSector;
native double CeilingZ;
native double FloorZ;
native double DropoffZ;
native Sector floorsector;
native TextureID floorpic;
native int floorterrain;
native Sector ceilingsector;
native TextureID ceilingpic;
native double Height;
native readonly double Radius;
some groundwork for the implementation of dynamic arrays - created script exports for all relevant functions with all integral types. - created script side definitions for the underlying data types. - added a void pointer type so that the prototype for the pointer array can use a generic type every pointer can be assigned to.
2017-01-10 23:57:31 +00:00
native readonly double RenderRadius;
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
native double projectilepassheight;
native int tics;
native readonly State CurState;
native readonly int Damage;
native int projectilekickback;
native int special1;
native int special2;
native double specialf1;
native double specialf2;
native int weaponspecial;
native int Health;
native uint8 movedir;
native int8 visdir;
native int16 movecount;
native int16 strafecount;
native Actor Target;
native Actor Master;
native Actor Tracer;
native Actor LastHeard;
native Actor LastEnemy;
native Actor LastLookActor;
native int ReactionTime;
native int Threshold;
native readonly int DefThreshold;
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
native vector3 SpawnPoint;
native uint16 SpawnAngle;
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
native int StartHealth;
native uint8 WeaveIndexXY;
native uint8 WeaveIndexZ;
native int skillrespawncount;
native int Args[5];
native int Mass;
native int Special;
native readonly int TID;
native readonly int TIDtoHate;
native readonly int WaterLevel;
native int Score;
native int Accuracy;
native int Stamina;
native double MeleeRange;
native int PainThreshold;
native double Gravity;
native double FloorClip;
native name DamageType;
native name DamageTypeReceived;
native uint8 FloatBobPhase;
native int RipperLevel;
native int RipLevelMin;
native int RipLevelMax;
native name Species;
native Actor Alternative;
native Actor goal;
native uint8 MinMissileChance;
native int8 LastLookPlayerNumber;
native uint SpawnFlags;
native double meleethreshold;
native double maxtargetrange;
native double bouncefactor;
native double wallbouncefactor;
native int bouncecount;
native double friction;
native int FastChaseStrafeCount;
native double pushfactor;
native int lastpush;
native int activationtype;
native int lastbump;
native int DesignatedTeam;
native Actor BlockingMobj;
- scriptified FastProjectile.
2017-01-12 23:35:56 +00:00
native Line BlockingLine;
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
native int PoisonDamage;
native name PoisonDamageType;
native int PoisonDuration;
native int PoisonPeriod;
native int PoisonDamageReceived;
native name PoisonDamageTypeReceived;
native int PoisonDurationReceived;
native int PoisonPeriodReceived;
native Actor Poisoner;
native Inventory Inv;
native uint8 smokecounter;
native uint8 FriendPlayer;
native uint Translation;
native sound AttackSound;
native sound DeathSound;
native sound SeeSound;
native sound PainSound;
native sound ActiveSound;
native sound UseSound;
native sound BounceSound;
native sound WallBounceSound;
native sound CrushPainSound;
native double MaxDropoffHeight;
native double MaxStepHeight;
native int16 PainChance;
native name PainType;
native name DeathType;
native double DamageFactor;
native double DamageMultiply;
native Class<Actor> TelefogSourceType;
native Class<Actor> TelefogDestType;
native readonly State SpawnState;
native readonly State SeeState;
native State MeleeState;
native State MissileState;
some groundwork for the implementation of dynamic arrays - created script exports for all relevant functions with all integral types. - created script side definitions for the underlying data types. - added a void pointer type so that the prototype for the pointer array can use a generic type every pointer can be assigned to.
2017-01-10 23:57:31 +00:00
native voidptr /*DecalBase*/ DecalGenerator;
- scriptified the particle fountains.
2017-01-13 18:29:54 +00:00
native uint8 fountaincolor;
- scriptified Actor.GetBloodType as a virtual function to allow mods more flexibility here. - made CameraHeight a modifiable actor property - it was readonly before. - allow accessing the type constants from ZScript, this required quite a bit of explicit coding because the type system has no capabilities to search for basic types by name.
2017-02-28 11:11:25 +00:00
native double CameraHeight; // Height of camera when used as such
- refactored a few more native meta properties.
2017-02-28 11:47:44 +00:00
native double RadiusDamageFactor; // Radius damage factor
native double SelfDamageFactor;
native double StealthAlpha;
- made GetDeathHeight a virtual scripted function. - made GetGibHealth a virtual scripted function. - removed a few more native meta properties.
2017-02-28 12:40:46 +00:00
native int WoundHealth; // Health needed to enter wound state
- separated the blood translation index from the BloodColor variable to allow more than 255 blood translations and as a prerequisite for allowing to change the blood color.
2017-03-02 09:26:23 +00:00
native readonly color BloodColor;
native readonly int BloodTranslation;
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
- reworked the obituary system to use scripted virtual overrides. Let's hope this solves the problems with the original code, now that any actor needing special treatment can override it.
2017-02-28 13:30:14 +00:00
meta String Obituary; // Player was killed by this actor
meta String HitObituary; // Player was killed by this actor in melee
- made GetDeathHeight a virtual scripted function. - made GetGibHealth a virtual scripted function. - removed a few more native meta properties.
2017-02-28 12:40:46 +00:00
meta double DeathHeight; // Height on normal death
meta double BurnHeight; // Height on burning death
meta int GibHealth; // Negative health below which this monster dies an extreme death
meta Sound HowlSound; // Sound being played when electrocuted or poisoned
- scriptified Actor.GetBloodType as a virtual function to allow mods more flexibility here. - made CameraHeight a modifiable actor property - it was readonly before. - allow accessing the type constants from ZScript, this required quite a bit of explicit coding because the type system has no capabilities to search for basic types by name.
2017-02-28 11:11:25 +00:00
meta Name BloodType; // Blood replacement type
meta Name BloodType2; // Bloopsplatter replacement type
meta Name BloodType3; // AxeBlood replacement type
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
meta bool DontHurtShooter;
meta int ExplosionRadius;
meta int ExplosionDamage;
meta int MeleeDamage;
meta Sound MeleeSound;
meta double MissileHeight;
meta Name MissileName;
- refactored a few more native meta properties.
2017-02-28 11:47:44 +00:00
meta double FastSpeed; // speed in fast mode
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
Property prefix: none;
- reworked the obituary system to use scripted virtual overrides. Let's hope this solves the problems with the original code, now that any actor needing special treatment can override it.
2017-02-28 13:30:14 +00:00
Property Obituary: Obituary;
Property HitObituary: HitObituary;
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
Property MeleeDamage: MeleeDamage;
Property MeleeSound: MeleeSound;
Property MissileHeight: MissileHeight;
Property MissileType: MissileName;
Property DontHurtShooter: DontHurtShooter;
Property ExplosionRadius: ExplosionRadius;
Property ExplosionDamage: ExplosionDamage;
- fixed: 'Bloodtype' cannot use the generic property definition because it needs special handling for optional arguments. This reinstates the native handler.
2017-03-01 19:20:46 +00:00
//Property BloodType: BloodType, BloodType2, BloodType3;
- refactored a few more native meta properties.
2017-02-28 11:47:44 +00:00
Property FastSpeed: FastSpeed;
- made GetDeathHeight a virtual scripted function. - made GetGibHealth a virtual scripted function. - removed a few more native meta properties.
2017-02-28 12:40:46 +00:00
Property HowlSound: HowlSound;
Property GibHealth: GibHealth;
Property DeathHeight: DeathHeight;
Property BurnHeight: BurnHeight;
- moved all trivial actor properties into the scripts as 'property' declarations.
2017-03-19 10:30:28 +00:00
property Health: health;
property WoundHealth: WoundHealth;
property ReactionTime: reactiontime;
property PainThreshold: PainThreshold;
property DamageMultiply: DamageMultiply;
property ProjectileKickback: ProjectileKickback;
property Speed: speed;
property FloatSpeed: FloatSpeed;
property Radius: radius;
property RenderRadius: RenderRadius;
property Height: height;
property ProjectilePassHeight: ProjectilePassHeight;
property Mass: mass;
property XScale: ScaleX;
property YScale: ScaleY;
property SeeSound: SeeSound;
property AttackSound: AttackSound;
property BounceSound: BounceSound;
property WallBounceSound: WallBounceSound;
property PainSound: PainSound;
property DeathSound: DeathSound;
property ActiveSound: ActiveSound;
property CrushPainSound: CrushPainSound;
property Alpha: Alpha;
property MaxTargetRange: MaxTargetRange;
property MeleeThreshold: MeleeThreshold;
property MeleeRange: MeleeRange;
property PushFactor: PushFactor;
property BounceCount: BounceCount;
property WeaveIndexXY: WeaveIndexXY;
property WeaveIndexZ: WeaveIndexZ;
property MinMissileChance: MinMissileChance;
property MaxStepHeight: MaxStepHeight;
property MaxDropoffHeight: MaxDropoffHeight;
property PoisonDamageType: PoisonDamageType;
property RadiusDamageFactor: RadiusDamageFactor;
property SelfDamageFactor: SelfDamageFactor;
property StealthAlpha: StealthAlpha;
property CameraHeight: CameraHeight;
property VSpeed: velz;
property SpriteRotation: SpriteRotation;
property VisibleAngles: VisibleStartAngle, VisibleEndAngle;
property VisiblePitch: VisibleStartPitch, VisibleEndPitch;
property Species: Species;
property Accuracy: accuracy;
property Stamina: stamina;
property TelefogSourceType: TelefogSourceType;
property TelefogDestType: TelefogDestType;
property Ripperlevel: RipperLevel;
property RipLevelMin: RipLevelMin;
property RipLevelMax: RipLevelMax;
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
// need some definition work first
//FRenderStyle RenderStyle;
//int ConversationRoot; // THe root of the current dialogue
// deprecated things.
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
native readonly deprecated("2.3") double X;
native readonly deprecated("2.3") double Y;
native readonly deprecated("2.3") double Z;
native readonly deprecated("2.3") double VelX;
native readonly deprecated("2.3") double VelY;
native readonly deprecated("2.3") double VelZ;
native readonly deprecated("2.3") double MomX;
native readonly deprecated("2.3") double MomY;
native readonly deprecated("2.3") double MomZ;
native deprecated("2.3") double ScaleX;
native deprecated("2.3") double ScaleY;
- allow defining native fields through scripts. Internally this only requires exporting the address, but not the entire field. - added new VARF_Transient flag so that the decision whether to serialize a field does not depend solely on its native status. It may actually make a lot of sense to use the auto-serializer for native fields, too, as this would eliminate a lot of maintenance code. - defined (u)int8/16 as aliases to the byte and short types (Can't we not just get rid of this naming convention already...?) - exporting the fields of Actor revealed a few name clashes between them and some global types, so Actor.Sector was renamed to CurSector and Actor.Inventory was renamed to Actor.Inv.
2016-11-22 18:20:31 +00:00
//FStrifeDialogueNode *Conversation; // [RH] The dialogue to show when this actor is used.;
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
Default
{
Scale 1;
Health DEFAULT_HEALTH;
Reactiontime 8;
Radius 20;
- scriptified Actor.GetBloodType as a virtual function to allow mods more flexibility here. - made CameraHeight a modifiable actor property - it was readonly before. - allow accessing the type constants from ZScript, this required quite a bit of explicit coding because the type system has no capabilities to search for basic types by name.
2017-02-28 11:11:25 +00:00
RenderRadius 0;
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
Height 16;
Mass 100;
RenderStyle 'Normal';
Alpha 1;
MinMissileChance 200;
MeleeRange 64 - 20;
MaxDropoffHeight 24;
MaxStepHeight 24;
BounceFactor 0.7;
WallBounceFactor 0.75;
BounceCount -1;
FloatSpeed 4;
FloatBobPhase -1; // randomly initialize by default
Gravity 1;
Friction 1;
fixed and completed the special field init code. Strings can now be used as class members, and so can structs which contain strings. - made 'DamageMultiply' an actor property and moved the initialization of ConversationRoot to the property handler for the compiler to get this stuff out of the type classes. - consolidate default initialization into one function which performs all the required setup. The original implementation did this when adding the fields but that cannot work because at that time no defaults have been created yet. - fixed: When deriving a class the child class's defaults also must initialize the copied parent fields with special initialization. This part was completely missing. - removed DECORATE code for parsing native classes because it's no longer needed.
2016-11-11 13:40:32 +00:00
DamageFactor 1.0; // damage multiplier as target of damage.
DamageMultiply 1.0; // damage multiplier as source of damage.
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
PushFactor 0.25;
WeaveIndexXY 0;
WeaveIndexZ 16;
DesignatedTeam 255;
PainType "Normal";
DeathType "Normal";
TeleFogSourceType "TeleportFog";
TeleFogDestType 'TeleportFog';
RipperLevel 0;
RipLevelMin 0;
RipLevelMax 0;
DefThreshold 100;
BloodType "Blood", "BloodSplatter", "AxeBlood";
ExplosionDamage 128;
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
ExplosionRadius -1; // i.e. use ExplosionDamage value
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
MissileHeight 32;
SpriteAngle 0;
SpriteRotation 0;
StencilColor "00 00 00";
VisibleAngles 0, 0;
VisiblePitch 0, 0;
- added a 'DefaultStateUsage' property so that this setting can be properly set up for the classes that can inject states into other actors.
2016-11-14 17:31:12 +00:00
DefaultStateUsage SUF_ACTOR|SUF_OVERLAY;
- scriptified Actor.GetBloodType as a virtual function to allow mods more flexibility here. - made CameraHeight a modifiable actor property - it was readonly before. - allow accessing the type constants from ZScript, this required quite a bit of explicit coding because the type system has no capabilities to search for basic types by name.
2017-02-28 11:11:25 +00:00
CameraHeight int.min;
- refactored a few more native meta properties.
2017-02-28 11:47:44 +00:00
FastSpeed -1;
RadiusDamageFactor 1;
SelfDamageFactor 1;
StealthAlpha 0;
- made WoundHealth modifiable to allow more control over the wound state.
2017-02-28 11:56:35 +00:00
WoundHealth 6;
- made GetDeathHeight a virtual scripted function. - made GetGibHealth a virtual scripted function. - removed a few more native meta properties.
2017-02-28 12:40:46 +00:00
GibHealth int.min;
DeathHeight -1;
BurnHeight -1;
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
}
- fixed: Readonly pointers never were flagged as such. - fixed: Assignment from a readonly to a read-allowed pointer must be an error. - made GetDefaultByType a builtin so that it can do proper type assignment to the result, which for a function would be problematic in this case, even if automatic type deduction was implemented. Since this returns the class defaults which are not a real object, the result cannot be subjected to a type cast. - error out if a type cast of a readonly pointer is attempted. - fixed: FxBooleanNot could clobber a local variable because it used the source register to manipulate the result.
2016-11-27 14:50:58 +00:00
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
// Functions
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
- scriptified A_PainShootSkull which was the last remaining bit in g_doom, so this directory is gone now.
2016-11-23 18:47:09 +00:00
// 'parked' global functions.
native static double deltaangle(double ang1, double ang2);
native static double absangle(double ang1, double ang2);
native static Vector2 AngleToVector(double angle, double length = 1);
native static Vector2 RotateVector(Vector2 vec, double angle);
- scriptified the moving camera.
2017-01-13 21:13:03 +00:00
native static double Normalize180(double ang);
- scriptified A_PainShootSkull which was the last remaining bit in g_doom, so this directory is gone now.
2016-11-23 18:47:09 +00:00
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
bool IsPointerEqual(int ptr_select1, int ptr_select2)
{
return GetPointer(ptr_select1) == GetPointer(ptr_select2);
}
- scriptified Hexen's bats. - removed AMinotaurFriend::IsOkayToAttack. The condition it checks (i.e. friendliness with player) is already covered by the base version of this function so this is quite redundant. - removed a few 'virtual' qualifiers from functions that never get overridden.
2016-11-12 08:33:43 +00:00
static double BobSin(double fb)
{
return sin(fb * (180./32)) * 8;
}
- added scriptable virtual overrides for PostBeginPlay, Tick, BeginPlay, Activate and Deactivate.
2016-11-21 13:59:17 +00:00
virtual native void BeginPlay();
virtual native void Activate(Actor activator);
virtual native void Deactivate(Actor activator);
- scriptified the Ironlich.
2016-11-23 20:26:59 +00:00
virtual native int DoSpecialDamage (Actor target, int damage, Name damagetype);
- converted the rest of a_strifestuff.cpp. - changed some very old A_Explode calls which passed all values as integer literals.
2016-11-28 23:16:30 +00:00
virtual native int TakeSpecialDamage (Actor inflictor, Actor source, int damage, Name damagetype);
- scriptified a_alienspectres.cpp.
2016-11-28 10:52:03 +00:00
virtual native void Die(Actor source, Actor inflictor, int dmgflags = 0);
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
virtual native bool Slam(Actor victim);
- scriptified a_spectral.cpp. - consolidated A_Tracer and A_Tracer2. Note that this commit temporarily disables a few features in order to make it compile.
2016-11-28 11:55:33 +00:00
virtual native void Touch(Actor toucher);
- scriptified ASoundSequence. - exported virtual Actor.MarkPrecacheSounds function.
2017-01-14 13:35:11 +00:00
virtual native void MarkPrecacheSounds();
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
- scriptified Actor.GetBloodType as a virtual function to allow mods more flexibility here. - made CameraHeight a modifiable actor property - it was readonly before. - allow accessing the type constants from ZScript, this required quite a bit of explicit coding because the type system has no capabilities to search for basic types by name.
2017-02-28 11:11:25 +00:00
// Called by PIT_CheckThing to check if two actors actually can collide.
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
virtual bool CanCollideWith(Actor other, bool passive)
{
return true;
}
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
- cleaned up and grouped the virtual function declarations in AActor to ensure that everything has been properly exported. - removed the native parts of SpecialBlastHandling. Since this is called from the script side and the only remaining native remnant was an empty function it's now 100% scripted.
2016-11-30 00:39:06 +00:00
// Called when an actor is to be reflected by a disc of repulsion.
// Returns true to continue normal blast processing.
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
virtual bool SpecialBlastHandling (Actor source, double strength)
- cleaned up and grouped the virtual function declarations in AActor to ensure that everything has been properly exported. - removed the native parts of SpecialBlastHandling. Since this is called from the script side and the only remaining native remnant was an empty function it's now 100% scripted.
2016-11-30 00:39:06 +00:00
{
return true;
}
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
// This is called before a missile gets exploded.
virtual int SpecialMissileHit (Actor victim)
- scriptified Hexen's Frost shards. - scriptified all SpecialMissileHit methods.
2016-11-27 20:41:04 +00:00
{
return -1;
}
- added a virtual 'used' method that gets called when the player presses use on an actor. This method will only be called if the actor does not have the USESPECIAL flag - that one will be handled as before.
2017-02-14 23:43:30 +00:00
// Called when the player presses 'use' and an actor is found
virtual bool Used(Actor user)
{
return false;
}
- scriptified Actor.GetBloodType as a virtual function to allow mods more flexibility here. - made CameraHeight a modifiable actor property - it was readonly before. - allow accessing the type constants from ZScript, this required quite a bit of explicit coding because the type system has no capabilities to search for basic types by name.
2017-02-28 11:11:25 +00:00
virtual class<Actor> GetBloodType(int type)
{
Class<Actor> bloodcls;
if (type == 0)
{
bloodcls = BloodType;
}
else if (type == 1)
{
bloodcls = BloodType2;
}
else if (type == 2)
{
bloodcls = BloodType3;
}
else
{
return NULL;
}
if (bloodcls != NULL)
{
bloodcls = GetReplacement(bloodcls);
}
return bloodcls;
}
- made GetDeathHeight a virtual scripted function. - made GetGibHealth a virtual scripted function. - removed a few more native meta properties.
2017-02-28 12:40:46 +00:00
virtual int GetGibHealth()
{
if (GibHealth != int.min)
{
return -abs(GibHealth);
}
else
{
return -int(GetSpawnHealth() * gameinfo.gibfactor);
}
}
virtual double GetDeathHeight()
{
// [RH] Allow the death height to be overridden using metadata.
double metaheight = -1;
if (DamageType == 'Fire')
{
metaheight = BurnHeight;
}
if (metaheight < 0)
{
metaheight = DeathHeight;
}
if (metaheight < 0)
{
return Height * 0.25;
}
else
{
return MAX(metaheight, 0);
}
}
- reworked the obituary system to use scripted virtual overrides. Let's hope this solves the problems with the original code, now that any actor needing special treatment can override it.
2017-02-28 13:30:14 +00:00
virtual String GetObituary(Actor victim, Actor inflictor, Name mod, bool playerattack)
{
if (mod == 'Telefrag')
{
return "$OB_MONTELEFRAG";
}
else if (mod == 'Melee' && HitObituary.Length() > 0)
{
return HitObituary;
}
return Obituary;
}
- added a callback for when damage is drained from a target.
2017-03-29 18:25:54 +00:00
virtual int OnDrain(Actor victim, int damage, Name dmgtype)
{
return damage;
}
- fixed some incomplete checks for static arrays. - made AActor::OkaytoSwitchTarget scripted virtual.
2017-03-15 00:39:59 +00:00
native virtual bool OkayToSwitchTarget(Actor other);
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
native static class<Actor> GetReplacement(class<Actor> cls);
native static class<Actor> GetReplacee(class<Actor> cls);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native static int GetSpriteIndex(name sprt);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native static double GetDefaultSpeed(class<Actor> type);
- scriptified hexenspecialdecs. - made '->' a single token. Although ZScript does not use it, the parser tends to get confused and fatally chokes on leftover arrows so this ensures more robust error handling.
2016-11-27 19:14:43 +00:00
native static class<Actor> GetSpawnableType(int spawnnum);
- scriptified PowerProtection and PowerDamage. - made ModifyDamage calls iterative instead of recursive. With going through the VM they'd be too costly otherwise. - small optimization: Detect empty VM functions right when entering the VM and shortcut them. This is to reduce the overhead of virtual placeholders, which in a few cases (e.g. CanCollideWith and ModifyDamage) can be called quite frequently.
2017-01-01 22:11:48 +00:00
native static int ApplyDamageFactors(class<Inventory> itemcls, Name damagetype, int damage, int defdamage);
- scriptified two of the Acolyte's functions. - added a DActorIterator class. - fixed: It was not possible to have functions of the same name in two different classes because the name they were searched for was not qualified by the class. Changed so that the class name is included now, but to avoid renaming several hundreds of functions all at once, if the search fails, it will repeat with 'Actor' as class name. This commit contains preparations for scriptifying Hexen's Dragon, but that doesn't work yet so it's not included.
2016-11-16 00:36:21 +00:00
native void RemoveFromHash();
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native void ChangeTid(int newtid);
native static int FindUniqueTid(int start = 0, int limit = 0);
native void SetShade(color col);
- added a GetRenderStyle function to Actor, so that the internal render style can be retrieved in a format suitable for scripting.
2017-03-15 09:36:41 +00:00
native clearscope int GetRenderStyle() const;
- implemented the regular Doom status bar. The DOOM status bar and HUD are complete, except the inventory bar.
2017-03-26 20:04:58 +00:00
native clearscope bool CheckKeys(int locknum, bool remote, bool quiet = false);
- implemented the inventory bar. This object is a bit special because it requires a lot of parameters, most of which are easily set to defaults. To make handling easier, most are passed through a container object which does some processing up front. - finished work on the Doom status bar. I also took the opportunity to fix the layout of the inventory bar which is a bit broken in SBARINFO. - tuned the selection rules for deciding what creates the status bar, so that the most recent definition that can be found is chosen.
2017-03-26 23:02:10 +00:00
native clearscope Inventory FirstInv() const;
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope string GetTag(string defstr = "") const;
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native void SetTag(string defstr = "");
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native double GetBobOffset(double frac = 0);
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
native void ClearCounters();
native bool GiveBody (int num, int max=0);
- scriptified Heretic's mace. - fixed: FxAssignSelf did not the correct number of registers for vector operations. - fixed a few asserts in vector2 instructions. - turned the virtual AActor::HitFloor method into a flag MF7_SMASHABLE. The only use of this function was to kill Hexen's pottery when they hit the floor, and this looks like something that can be exposed to modders less clumsily.
2016-11-24 12:45:43 +00:00
native bool HitFloor();
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope bool isTeammate(Actor other) const;
- major progress on the status bar code: SBARINFO's DrawGraphic has been ported into a generic function of the base statusbar class and put to use for a few items on the Strife status bar. - decided to ditch the widget system I had started to lay out. As it turns out that would make things far more complicated and slower than they need to be.
2017-03-23 14:18:09 +00:00
native clearscope int PlayerNumber() const;
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
native void SetFriendPlayer(PlayerInfo player);
- renamed Actor.NoiseAlert to Actor.SoundAlert to deconflict with the same-named action special.
2016-12-11 11:10:05 +00:00
native void SoundAlert(Actor target, bool splash = false, double maxdist = 0);
- scriptified Strife's dagger and crossbow.
2016-11-29 12:00:07 +00:00
native void DaggerAlert(Actor target);
- changed AInventory::HandlePickup to work iteratively instead of recursively. Two reasons for this: 1. if this has to be routed through the VM each recursion will cost 1000 bytes of stack space which simply is not good. 2. having the virtual function only care about the item itself but not the entire inventory chain is a lot less error prone for scripting. Since the scripting interface needs a separate caller function anyway this seemed like a good time to change it. The same will be done for the other chained inventory handlers as well.
2016-11-27 09:40:43 +00:00
native void ClearBounce();
- scriptified Hexen's Bloodscourge and Serpent. - merged the FrontBlock searcher for the Bloodscourge into RoughMonsterSearch. This also fixes the bug that the searcher was not initialized properly for the MageBoss.
2016-11-27 23:49:10 +00:00
native TerrainDef GetFloorTerrain();
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
native bool CheckLocalView(int consoleplayer);
- scriptified FastProjectile.
2017-01-12 23:35:56 +00:00
native bool CheckNoDelay();
native bool UpdateWaterLevel (bool splash = true);
native bool IsZeroDamage();
native void ClearInterpolation();
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope Vector3 PosRelative(sector sec) const;
- scriptified the RandomSpawner. - fixed: String constants were not processed by the compiler backend. - added an explicit name cast for class types.
2017-01-14 01:05:52 +00:00
native void HandleSpawnFlags();
- added a Death.Sky state for missiles that gets used when they hit a sky plane. - fixed: The Alt HUD did not draw the crosshair in HUD off mode.
2017-02-25 19:45:28 +00:00
native void ExplodeMissile(line lin = null, Actor target = null, bool onsky = false);
- scriptified the Ironlich.
2016-11-23 20:26:59 +00:00
native void RestoreDamage();
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope int SpawnHealth() const;
- scriptified parts of a_bossbrain.cpp. Some things cannot be done yet, the script code is there but commented out. - exported thinker iterator and drop item chain to scripting. Unlike its native counterpart the script-side iterator is wrapped into a DObject to allow proper handling for memory management. - fixed: The VMFunctionBuilder only distinguished between member and action functions but failed on static ones. - fixed: FxAssign did not add all needed type casts. Except for purely numeric types it will now wrap the expression in an FxTypeCast. Numeric handling remains unchanged for both performance reasons and not altering semantics for DECORATE. - exported all internal flags as variables to scripting. They still cannot be used in an actor definition. - make ATAG_STATE the same as ATAG_GENERIC. Since state pointers exist as actual variables they can take both values which on occasion can trigger some asserts. - gave PClass a bExported flag, so that scripts cannot see purely internal classes. Especially the types like PInt can cause problems. Todo: we need readonly references to safely expose the actor defaults. Right now some badly behaving code could overwrite them.
2016-10-31 16:02:47 +00:00
native void SetDamage(int dmg);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope double Distance2D(Actor other) const;
native clearscope double Distance3D(Actor other) const;
- fixed initialization of local variables with other local variables. - fixed several occurenced where vectors were treated as floats. NOTE: The entire codegen.cpp file needs to be carefully reviewed for bad use of the REGT_ constants, there's probably more places where using them has broken some type checks. - fixed: committed test version of zscript.txt instead of changed actor.txt by accident. Initialization and assignment for strings is working with this commit.
2016-10-29 14:49:21 +00:00
native void SetOrigin(vector3 newpos, bool moving);
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
native void SetXYZ(vector3 newpos);
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
native Actor GetPointer(int aaptr);
- scriptified the pistol to test if struct member functions work. - made APlayerPawn::PlayAttacking(2) virtual script functions so that mods have better control over player animations. Note that these have no native base so they skip the templated interface for managing virtual functions.
2016-11-19 12:56:29 +00:00
native double BulletSlope(out FTranslatedLineTarget pLineTarget = null, int aimflags = 0);
- more player code exported
2017-04-30 20:16:32 +00:00
native void CheckFakeFloorTriggers (double oldz, bool oldz_has_viewheight = false);
- scriptified a few parts of p_pspr.cpp. - added a speed parameter to A_Lower and A_Raise in the process.
2017-01-19 12:25:56 +00:00
- scriptified a_hereticmisc.cpp.
2016-11-18 20:34:06 +00:00
native bool CheckMissileSpawn(double maxdist);
- exported FCheckPosition to the VM and completed the parameter lists for Actor.CheckPosition and Actor.TryMove.
2017-01-11 23:26:16 +00:00
native bool CheckPosition(Vector2 pos, bool actorsonly = false, FCheckPosition tm = null);
- scriptified D'Sparil. - added retrieval of defaults from an actor pointer.
2016-11-24 00:23:35 +00:00
native bool TestMobjLocation();
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
native static Actor Spawn(class<Actor> type, vector3 pos = (0,0,0), int replace = NO_REPLACE);
- scriptified A_BruisAttack. - removed 'self' as a dedicated token. Internally this gets handled as a normal but implicitly named variable so the token just gets in the way of proper processing. - removed P_ prefix from SpawnMissile export. - fixed a crash with misnamed function exports.
2016-10-23 15:15:24 +00:00
native Actor SpawnMissile(Actor dest, class<Actor> type, Actor owner = null);
- scriptified the IceGuy.
2016-11-26 23:41:06 +00:00
native Actor SpawnMissileXYZ(Vector3 pos, Actor dest, Class<Actor> type, bool checkspawn = true, Actor owner = null);
- Scriptified Heretic's knight.
2016-11-11 21:14:29 +00:00
native Actor SpawnMissileZ (double z, Actor dest, class<Actor> type);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native Actor SpawnMissileAngleZSpeed (double z, class<Actor> type, double angle, double vz, double speed, Actor owner = null, bool checkspawn = true);
- scriptified the Crusader.
2016-11-28 17:36:13 +00:00
native Actor SpawnMissileZAimed (double z, Actor dest, Class<Actor> type);
- scriptified a_alienspectres.cpp.
2016-11-28 10:52:03 +00:00
native Actor SpawnSubMissile(Class<Actor> type, Actor target);
- scriptified the Rocket launcher.
2016-11-20 00:11:01 +00:00
native Actor, Actor SpawnPlayerMissile(class<Actor> type, double angle = 0, double x = 0, double y = 0, double z = 0, out FTranslatedLineTarget pLineTarget = null, bool nofreeaim = false, bool noautoaim = false, int aimflags = 0);
- scriptified D'Sparil. - added retrieval of defaults from an actor pointer.
2016-11-24 00:23:35 +00:00
native void SpawnTeleportFog(Vector3 pos, bool beforeTele, bool setTarget);
- scriptified Hexen's Bloodscourge and Serpent. - merged the FrontBlock searcher for the Bloodscourge into RoughMonsterSearch. This also fixes the bug that the searcher was not initialized properly for the MageBoss.
2016-11-27 23:49:10 +00:00
native Actor RoughMonsterSearch(int distance, bool onlyseekable = false, bool frontonly = false);
- scriptified the Flechette. Not fully tested yet. - fixed issues with the refactoring of the recent commits. This one starts again. - added builtins for TextureID. Note about builtins: Currently they are just hacked into the compiler backend. They really should be made part of the respective types to keep matters clean and allow more widespread use of builtins to create more efficient code.
2016-11-27 11:52:54 +00:00
native int ApplyDamageFactor(Name damagetype, int damage);
native int GetModifiedDamage(Name damagetype, int damage, bool passive);
- scriptified a_alienspectres.cpp.
2016-11-28 10:52:03 +00:00
native bool CheckBossDeath();
- moved A_Light to Actor after finding some mods which used it badly. Besides, it should be fine to use this from PlayerPawns as well.
2016-11-15 12:39:41 +00:00
- scriptified D'Sparil. - added retrieval of defaults from an actor pointer.
2016-11-24 00:23:35 +00:00
void A_Light(int extralight) { if (player) player.extralight = clamp(extralight, -20, 20); }
void A_Light0() { if (player) player.extralight = 0; }
void A_Light1() { if (player) player.extralight = 1; }
void A_Light2() { if (player) player.extralight = 2; }
void A_LightInverse() { if (player) player.extralight = 0x80000000; }
- scriptified Heretic's wizard.
2016-11-11 22:32:13 +00:00
- scriptified A_Mushroom to test something a bit more complex. - fixed: FxMinusSign trashed local variables that were used with negation. - fixed: FxConditional only handled ints and floats, but not pointers and strings. - fixed: A 'no states in non-actors' error was triggered, even for classes without any states.
2016-10-30 13:00:11 +00:00
native Actor OldSpawnMissile(Actor dest, class<Actor> type, Actor owner = null);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native Actor SpawnPuff(class<Actor> pufftype, vector3 pos, double hitdir, double particledir, int updown, int flags = 0, Actor victim = null);
native void SpawnBlood (Vector3 pos1, double dir, int damage);
native void BloodSplatter (Vector3 pos, double hitangle, bool axe = false);
native bool HitWater (sector sec, Vector3 pos, bool checkabove = false, bool alert = true, bool force = false);
native void PlaySpawnSound(Actor missile);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope bool CountsAsKill() const;
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
- scriptified ArtiTeleport. - shortened ArtiEgg and ArtiPork's use state to a single function.
2016-11-25 18:52:35 +00:00
native bool Teleport(Vector3 pos, double angle, int flags);
- scriptified A_BruisAttack. - removed 'self' as a dedicated token. Internally this gets handled as a normal but implicitly named variable so the token just gets in the way of proper processing. - removed P_ prefix from SpawnMissile export. - fixed a crash with misnamed function exports.
2016-10-23 15:15:24 +00:00
native void TraceBleed(int damage, Actor missile);
- scriptified the Minotaur. Interesting tidbit: The damage calculation in P_MinotaurSlam had been incorrect for the Heretic version since the friendly Hexen Dark Servant was added, but nobody ever noticed in 14 years...
2016-11-26 00:14:47 +00:00
native void TraceBleedAngle(int damage, double angle, double pitch);
native void SetIdle(bool nofunction = false);
- scriptified A_BruisAttack. - removed 'self' as a dedicated token. Internally this gets handled as a normal but implicitly named variable so the token just gets in the way of proper processing. - removed P_ prefix from SpawnMissile export. - fixed a crash with misnamed function exports.
2016-10-23 15:15:24 +00:00
native bool CheckMeleeRange();
- scriptified Hexen's Bloodscourge and Serpent. - merged the FrontBlock searcher for the Bloodscourge into RoughMonsterSearch. This also fixes the bug that the searcher was not initialized properly for the MageBoss.
2016-11-27 23:49:10 +00:00
native bool CheckMeleeRange2();
- made Actor.DamageMobj virtual.
2017-01-10 20:31:52 +00:00
native virtual int DamageMobj(Actor inflictor, Actor source, int damage, Name mod, int flags = 0, double angle = 0);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native void PoisonMobj (Actor inflictor, Actor source, int damage, int duration, int period, Name type);
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
native double AimLineAttack(double angle, double distance, out FTranslatedLineTarget pLineTarget = null, double vrange = 0., int flags = 0, Actor target = null, Actor friender = null);
Give the parameter a better name to associate by.
2017-05-17 16:54:42 +00:00
native Actor, int LineAttack(double angle, double distance, double pitch, int damage, Name damageType, class<Actor> pufftype, int flags = 0, out FTranslatedLineTarget victim = null, double offsetz = 0.);
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
native bool CheckSight(Actor target, int flags = 0);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native bool IsVisible(Actor other, bool allaround, LookExParams params = null);
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
native bool HitFriend();
- scriptified Hexen's Firedemon.
2016-11-12 18:16:47 +00:00
native bool MonsterMove();
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
- exported the sound sequence interface to scripting. - split out the map data definitions from base.txt into their own file.
2017-01-14 12:02:08 +00:00
native SeqNode StartSoundSequenceID (int sequence, int type, int modenum, bool nostop = false);
native SeqNode StartSoundSequence (Name seqname, int modenum);
native void StopSoundSequence();
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native void FindFloorCeiling(int flags = 0);
native double, double GetFriction();
native bool, Actor TestMobjZ(bool quick = false);
native bool InStateSequence(State newstate, State basestate);
bool TryWalk ()
{
if (!MonsterMove ())
{
return false;
}
movecount = random[TryWalk]() & 15;
return true;
}
- exported FCheckPosition to the VM and completed the parameter lists for Actor.CheckPosition and Actor.TryMove.
2017-01-11 23:26:16 +00:00
native bool TryMove(vector2 newpos, int dropoff, bool missilecheck = false, FCheckPosition tm = null);
- scriptified Hexen's Firedemon.
2016-11-12 18:16:47 +00:00
native void NewChaseDir();
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native void RandomChaseDir();
- scriptified Hexen's Firedemon.
2016-11-12 18:16:47 +00:00
native bool CheckMissileRange();
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
native bool SetState(state st, bool nofunction = false);
- scriptified ArtiTeleport. - shortened ArtiEgg and ArtiPork's use state to a single function.
2016-11-25 18:52:35 +00:00
native state FindState(statelabel st, bool exact = false);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
bool SetStateLabel(statelabel st, bool nofunction = false) { return SetState(FindState(st), nofunction); }
native action state ResolveState(statelabel st); // this one, unlike FindState, is context aware.
- scriptified the moving camera.
2017-01-13 21:13:03 +00:00
native void LinkToWorld(LinkContext ctx = null);
native void UnlinkFromWorld(out LinkContext ctx = null);
- scriptified the Revenant's code.
2016-11-07 22:16:25 +00:00
native bool CanSeek(Actor target);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope double AngleTo(Actor target, bool absolute = false) const;
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void AddZ(double zadd, bool moving = true);
native void SetZ(double z);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope vector2 Vec2To(Actor other) const;
native clearscope vector3 Vec3To(Actor other) const;
native clearscope vector3 Vec3Offset(double x, double y, double z, bool absolute = false) const;
native clearscope vector3 Vec3Angle(double length, double angle, double z = 0, bool absolute = false) const;
native clearscope vector2 Vec2Angle(double length, double angle, bool absolute = false) const;
native clearscope vector2 Vec2Offset(double x, double y, bool absolute = false) const;
native clearscope vector3 Vec2OffsetZ(double x, double y, double atz, bool absolute = false) const;
native void VelFromAngle(double speed = 0, double angle = 0);
native void Vel3DFromAngle(double speed, double angle, double pitch);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void Thrust(double speed = 0, double angle = 0);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope bool isFriend(Actor other) const;
native clearscope bool isHostile(Actor other) const;
- scriptified several trivial functions from a_action.cpp.
2016-11-01 15:32:47 +00:00
native void AdjustFloorClip();
- scriptified A_SpawnFly. - added support for global variables to the code generator - not the compiler, though. For the handful of entries this is needed for it may just as well be done manually. So far FLevelLocals level is the only one being exported. - fixed: The VM disassembler truncated 64 bit pointers to 15 digits because the output buffer was too small. - resolve entire FxSequences instead of aborting on the first failed entry. This allows to output all errors at once.
2016-11-03 12:38:40 +00:00
native DropItem GetDropItems();
native void CopyFriendliness (Actor other, bool changeTarget, bool resetHealth = true);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native bool LookForMonsters();
native bool LookForTid(bool allaround, LookExParams params = null);
native bool LookForEnemies(bool allaround, LookExParams params = null);
native bool LookForPlayers(bool allaround, LookExParams params = null);
- scriptified A_SpawnFly. - added support for global variables to the code generator - not the compiler, though. For the handful of entries this is needed for it may just as well be done manually. So far FLevelLocals level is the only one being exported. - fixed: The VM disassembler truncated 64 bit pointers to 15 digits because the output buffer was too small. - resolve entire FxSequences instead of aborting on the first failed entry. This allows to output all errors at once.
2016-11-03 12:38:40 +00:00
native bool TeleportMove(Vector3 pos, bool telefrag, bool modifyactor = true);
- fixed damage handling in A_BetaSkullAttack. For unknown reasons this completely bypassed the normal damage function semantics and even multiplied that with a random value. - made some tests about calling script code from native functions. * scriptified A_SkullAttack to have something to test * changed the A_SkullAttack call in A_PainShootSkull. * use a macro to declare the function pointer. Using local static variable init directly results in hideous code for the need of being thread-safe (which, even if the engine was made multithreaded is not needed here.) * Importsnt node here: Apparently passing an actor pointer to the VMValue constructor results in the void * version being called, not the DObject * version.
2016-11-06 10:36:12 +00:00
native double DistanceBySpeed(Actor other, double speed);
native name GetSpecies();
- scriptified Hexen's Firedemon.
2016-11-12 18:16:47 +00:00
native void PlayActiveSound();
- converted half of ClericHoly. (Making a commit before starting on the more complex stuff.) - added a 'constructor' for color values.
2016-11-26 12:18:48 +00:00
native void Howl();
- scriptified some trivial stuff from g_shared.
2016-11-29 18:50:34 +00:00
native void DrawSplash (int count, double angle, int kind);
native void GiveSecret(bool printmsg = true, bool playsound = true);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope double GetCameraHeight() const;
native clearscope double GetGravity() const;
- scriptified the functions in a_possessed.cpp and added the needed exports and constants. - fixed: Script functions did not receive the function name when being created. - relaxed the asserts for PARAM_STATE, because the VM knows nothing about ATAG_STATE. Any state variable's content (e.g. Actor.SeeState) will receive ATAG_GENERIC, rather than ATAG_STATE. - added a 'NeedResult' flag so that certain operations can create shorter code if the result of the expression is not needed. So far only used for postdecrement/increment statements on local variables (which is the most frequent case where this matters.) - fixed postincrement and decrement for local variables. Due to the result preservation semantics it created faulty code.
2016-10-26 09:30:30 +00:00
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native bool CheckClass(class<Actor> checkclass, int ptr_select = AAPTR_DEFAULT, bool match_superclass = false);
- added a larger batch of function exports. - cleaned up the virtual function interface of APlayerPawn which still had many virtual declarations from old times when class properties were handled through virtual overrides. None of this makes sense these days anymore.
2016-11-30 00:25:51 +00:00
native void AddInventory(Inventory inv);
native void RemoveInventory(Inventory inv);
native void ClearInventory();
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
native bool GiveInventory(class<Inventory> type, int amount, bool givecheat = false);
- added a setinv cheat CCMD.
2017-03-14 10:44:21 +00:00
native bool SetInventory(class<Inventory> itemclass, int amount, bool beyondMax = false);
- scriptified cht_Give and cht_Take and made them virtual function of PlayerPawn so that this can be better configured for mods that want other options in here. - improved the class pointer to string cast to print the actual type it describes and not the class pointer's own type. - fixed: The 'is' operator created non-working code when checking the inheritance of a class pointer, it only worked for objects.
2017-01-17 16:31:54 +00:00
native bool TakeInventory(class<Inventory> itemclass, int amount, bool fromdecorate = false, bool notakeinfinite = false);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope Inventory FindInventory(class<Inventory> itemtype, bool subclass = false) const;
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
native Inventory GiveInventoryType(class<Inventory> itemtype);
- also added the 'amount' parameter to DropInventroy and A_DropInventory script functions.
2017-02-23 19:55:12 +00:00
native Inventory DropInventory (Inventory item, int amt = -1);
- scriptified a_strifeitems.cpp and a_debris.cpp. - Changed the glass shards so that they do not have to override FloorBounceMissile. It was the only place where this was virtually overridden and provided little usefulness. - made 'out' variables work. - fixed virtual call handling for HandlePickup.
2016-11-29 11:17:05 +00:00
native bool UseInventory(Inventory item);
- scriptified A_FreezeDeath(Chunks).
2017-01-14 17:26:59 +00:00
native void ObtainInventory(Actor other);
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
native bool GiveAmmo (Class<Ammo> type, int amount);
- sxriptified key and puzzleitem base classes.
2017-01-15 09:37:54 +00:00
native bool UsePuzzleItem(int PuzzleItemType);
- scriptified Strife's dagger and crossbow.
2016-11-29 12:00:07 +00:00
native float AccuracyFactor();
- scriptified MorphProjectile and CustomSprite. This should for now conclude actor class scriptification. The remaining ten classes with the exception of MorphedMonster are all too essential or too closely tied to engine feature so they should remain native.
2017-01-20 00:11:36 +00:00
native bool MorphMonster (Class<Actor> spawntype, int duration, int style, Class<Actor> enter_flash, Class<Actor> exit_flash);
- Fixed: SetCamera didn't have the 'action' identifier, nor did it use the actual 'cam' actor provided, rendering it nonfunctional.
2017-02-08 14:30:00 +00:00
action native void SetCamera(Actor cam, bool revert = false);
- scriptified ArtiHealingRadius. - allow switch/case with names. - fixed break jump target handling for switch/case. This only worked when the break was in the outermost compound statement, those in inner ones were missed.
2016-11-26 23:18:07 +00:00
- scriptified Oracle, Programmer and Rebels.
2016-11-28 18:42:26 +00:00
// DECORATE compatible functions
- made CountInv clearscope and const.
2017-03-07 21:55:15 +00:00
native clearscope int CountInv(class<Inventory> itemtype, int ptr_select = AAPTR_DEFAULT) const;
native double GetDistance(bool checkz, int ptr = AAPTR_TARGET) const;
native double GetAngle(int flags, int ptr = AAPTR_TARGET) const;
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native double GetZAt(double px = 0, double py = 0, double angle = 0, int flags = 0, int pick_pointer = AAPTR_DEFAULT);
- made several read-only actor functions accessible to UI code.
2017-03-07 17:58:18 +00:00
native clearscope int GetSpawnHealth() const;
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native double GetCrouchFactor(int ptr = AAPTR_PLAYER1);
native double GetCVar(string cvar);
- added a GetCVarString ZScript/DECORATE function. - fixed: loading a savegame triggered PlayerEntered events.
2017-03-28 19:36:57 +00:00
native double GetCVarString(string cvar);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native int GetPlayerInput(int inputnum, int ptr = AAPTR_DEFAULT);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native int CountProximity(class<Actor> classname, double distance, int flags = 0, int ptr = AAPTR_DEFAULT);
native double GetSpriteAngle(int ptr = AAPTR_DEFAULT);
native double GetSpriteRotation(int ptr = AAPTR_DEFAULT);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native int GetMissileDamage(int mask, int add, int ptr = AAPTR_DEFAULT);
action native int OverlayID();
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
action native double OverlayX(int layer = 0);
action native double OverlayY(int layer = 0);
Merge branch 'OverlayAlpha' into OverlayExtension9 # Conflicts: # src/p_pspr.cpp # src/r_draw.cpp # wadsrc/static/actors/actor.txt # wadsrc/static/actors/constants.txt
2016-12-26 20:37:22 +00:00
action native double OverlayAlpha(int layer = 0);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
// DECORATE setters - it probably makes more sense to set these values directly now...
void A_SetMass(int newmass) { mass = newmass; }
- scriptified several trivial functions from a_action.cpp.
2016-11-01 15:32:47 +00:00
void A_SetInvulnerable() { bInvulnerable = true; }
void A_UnSetInvulnerable() { bInvulnerable = false; }
void A_SetReflective() { bReflective = true; }
void A_UnSetReflective() { bReflective = false; }
void A_SetReflectiveInvulnerable() { bInvulnerable = true; bReflective = true; }
- fixed copy/paste error in A_UnsetReflectiveInvulnerable.
2016-11-12 12:11:32 +00:00
void A_UnSetReflectiveInvulnerable() { bInvulnerable = false; bReflective = false; }
- scriptified several trivial functions from a_action.cpp.
2016-11-01 15:32:47 +00:00
void A_SetShootable() { bShootable = true; bNonShootable = false; }
void A_UnSetShootable() { bShootable = false; bNonShootable = true; }
void A_NoGravity() { bNoGravity = true; }
void A_Gravity() { bNoGravity = false; Gravity = 1; }
void A_LowGravity() { bNoGravity = false; Gravity = 0.125; }
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_SetGravity(double newgravity) { gravity = clamp(newgravity, 0., 10.); }
- scriptified several trivial functions from a_action.cpp.
2016-11-01 15:32:47 +00:00
void A_SetFloorClip() { bFloorClip = true; AdjustFloorClip(); }
void A_UnSetFloorClip() { bFloorClip = false; FloorClip = 0; }
void A_HideThing() { bInvisible = true; }
void A_UnHideThing() { bInvisible = false; }
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
void A_SetArg(int arg, int val) { if (arg >= 0 && arg < 5) args[arg] = val; }
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_Turn(double turn = 0) { angle += turn; }
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
void A_SetDamageType(name newdamagetype) { damagetype = newdamagetype; }
void A_SetSolid() { bSolid = true; }
void A_UnsetSolid() { bSolid = false; }
void A_SetFloat() { bFloat = true; }
void A_UnsetFloat() { bFloat = false; }
void A_SetFloatBobPhase(int bob) { if (bob >= 0 && bob <= 63) FloatBobPhase = bob; }
void A_SetRipperLevel(int level) { RipperLevel = level; }
void A_SetRipMin(int minimum) { RipLevelMin = minimum; }
void A_SetRipMax(int maximum) { RipLevelMax = maximum; }
- scriptified two more trivial functions.
2016-11-06 08:22:03 +00:00
void A_ScreamAndUnblock() { A_Scream(); A_NoBlocking(); }
void A_ActiveAndUnblock() { A_ActiveSound(); A_NoBlocking(); }
- scriptified Heretic's wizard.
2016-11-11 22:32:13 +00:00
//---------------------------------------------------------------------------
//
// FUNC P_SpawnMissileAngle
//
// Returns NULL if the missile exploded immediately, otherwise returns
// a mobj_t pointer to the missile.
//
//---------------------------------------------------------------------------
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
Actor SpawnMissileAngle (class<Actor> type, double angle, double vz)
- scriptified Heretic's wizard.
2016-11-11 22:32:13 +00:00
{
return SpawnMissileAngleZSpeed (pos.z + 32 + GetBobOffset(), type, angle, vz, GetDefaultSpeed (type));
}
Actor SpawnMissileAngleZ (double z, class<Actor> type, double angle, double vz)
{
return SpawnMissileAngleZSpeed (z, type, angle, vz, GetDefaultSpeed (type));
}
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_SetScale(double scalex, double scaley = 0, int ptr = AAPTR_DEFAULT, bool usezero = false)
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
{
Actor aptr = GetPointer(ptr);
if (aptr)
{
aptr.Scale.X = scalex;
aptr.Scale.Y = scaley != 0 || usezero? scaley : scalex; // use scalex here, too, if only one parameter.
}
}
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_SetSpeed(double speed, int ptr = AAPTR_DEFAULT)
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
{
Actor aptr = GetPointer(ptr);
if (aptr) aptr.Speed = speed;
}
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_SetFloatSpeed(double speed, int ptr = AAPTR_DEFAULT)
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
{
Actor aptr = GetPointer(ptr);
if (aptr) aptr.FloatSpeed = speed;
}
void A_SetPainThreshold(int threshold, int ptr = AAPTR_DEFAULT)
{
Actor aptr = GetPointer(ptr);
if (aptr) aptr.PainThreshold = threshold;
}
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
bool A_SetSpriteAngle(double angle = 0, int ptr = AAPTR_DEFAULT)
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
{
Actor aptr = GetPointer(ptr);
if (!aptr) return false;
aptr.SpriteAngle = angle;
return true;
}
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
bool A_SetSpriteRotation(double angle = 0, int ptr = AAPTR_DEFAULT)
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
{
Actor aptr = GetPointer(ptr);
if (!aptr) return false;
aptr.SpriteRotation = angle;
return true;
}
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") void A_FaceConsolePlayer(double MaxTurnAngle = 0) {}
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
void A_SetSpecial(int spec, int arg0 = 0, int arg1 = 0, int arg2 = 0, int arg3 = 0, int arg4 = 0)
{
special = spec;
args[0] = arg0;
args[1] = arg1;
args[2] = arg2;
args[3] = arg3;
args[4] = arg4;
}
void A_ClearTarget()
{
target = null;
lastheard = null;
lastenemy = null;
}
void A_ChangeLinkFlags(int blockmap = FLAG_NO_CHANGE, int sector = FLAG_NO_CHANGE)
{
UnlinkFromWorld();
if (blockmap != FLAG_NO_CHANGE) bNoBlockmap = blockmap;
if (sector != FLAG_NO_CHANGE) bNoSector = sector;
LinkToWorld();
}
- scriptified A_FatAttack*. - swapped parameters of two-parameter VelToAngle method, so that internal and script version are in line. - fixed parameter asserts to handle NULL pointers properly.
2016-10-27 15:47:46 +00:00
// killough 11/98: kill an object
void A_Die(name damagetype = "none")
{
DamageMobj(null, null, health, damagetype, DMG_FORCED);
}
- scriptified Hexen's Wraith and parts of the Spike.
2016-11-16 23:44:43 +00:00
void SpawnDirt (double radius)
{
- used static constant arrays to shorten some code.
2016-11-20 17:34:27 +00:00
static const class<Actor> chunks[] = { "Dirt1", "Dirt2", "Dirt3", "Dirt4", "Dirt5", "Dirt6" };
- scriptified Hexen's Wraith and parts of the Spike.
2016-11-16 23:44:43 +00:00
double zo = random[Dirt]() / 128. + 1;
Vector3 pos = Vec3Angle(radius, random[Dirt]() * (360./256), zo);
- used static constant arrays to shorten some code.
2016-11-20 17:34:27 +00:00
Actor mo = Spawn (chunks[random[Dirt](0, 5)], pos, ALLOW_REPLACE);
- scriptified Hexen's Wraith and parts of the Spike.
2016-11-16 23:44:43 +00:00
if (mo)
{
mo.Vel.Z = random[Dirt]() / 64.;
}
}
//
// A_SinkMobj
// Sink a mobj incrementally into the floor
//
bool SinkMobj (double speed)
{
if (Floorclip < Height)
{
Floorclip += speed;
return false;
}
return true;
}
//
// A_RaiseMobj
// Raise a mobj incrementally from the floor to
//
bool RaiseMobj (double speed)
{
// Raise a mobj from the ground
if (Floorclip > 0)
{
Floorclip -= speed;
if (Floorclip <= 0)
{
Floorclip = 0;
return true;
}
else
{
return false;
}
}
return true;
}
- scriptified a few parts of p_pspr.cpp. - added a speed parameter to A_Lower and A_Raise in the process.
2017-01-19 12:25:56 +00:00
Actor AimTarget()
{
FTranslatedLineTarget t;
BulletSlope(t, ALF_PORTALRESTRICT);
return t.linetarget;
}
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_Face(Actor faceto, double max_turn = 0, double max_pitch = 270, double ang_offset = 0, double pitch_offset = 0, int flags = 0, double z_ofs = 0);
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_FaceTarget(double max_turn = 0, double max_pitch = 270, double ang_offset = 0, double pitch_offset = 0, int flags = 0, double z_ofs = 0)
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
{
A_Face(target, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_ofs);
}
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_FaceTracer(double max_turn = 0, double max_pitch = 270, double ang_offset = 0, double pitch_offset = 0, int flags = 0, double z_ofs = 0)
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
{
A_Face(tracer, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_ofs);
}
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
void A_FaceMaster(double max_turn = 0, double max_pitch = 270, double ang_offset = 0, double pitch_offset = 0, int flags = 0, double z_ofs = 0)
- got rid of all default parameter redundancies. - scriptified a few more functions.
2016-10-27 22:32:52 +00:00
{
A_Face(master, max_turn, max_pitch, ang_offset, pitch_offset, flags, z_ofs);
}
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
// Action functions
// Meh, MBF redundant functions. Only for DeHackEd support.
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native bool A_LineEffect(int boomspecial = 0, int tag = 0);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
// End of MBF redundant functions.
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
//==========================================================================
//
// old customizable attack functions which use actor parameters.
//
//==========================================================================
private void DoAttack (bool domelee, bool domissile, int MeleeDamage, Sound MeleeSound, Class<Actor> MissileType,double MissileHeight)
{
if (target == NULL) return;
A_FaceTarget ();
if (domelee && MeleeDamage>0 && CheckMeleeRange ())
{
int damage = random[CustomMelee](1, 8) * MeleeDamage;
if (MeleeSound) A_PlaySound (MeleeSound, CHAN_WEAPON);
int newdam = target.DamageMobj (self, self, damage, 'Melee');
target.TraceBleed (newdam > 0 ? newdam : damage, self);
}
else if (domissile && MissileType != NULL)
{
// This seemingly senseless code is needed for proper aiming.
double add = MissileHeight + GetBobOffset() - 32;
AddZ(add);
Actor missile = SpawnMissileXYZ (Pos + (0, 0, 32), target, MissileType, false);
AddZ(-add);
if (missile)
{
// automatic handling of seeker missiles
if (missile.bSeekerMissile)
{
missile.tracer = target;
}
missile.CheckMissileSpawn(radius);
}
}
}
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") void A_MeleeAttack()
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
{
DoAttack(true, false, MeleeDamage, MeleeSound, NULL, 0);
}
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") void A_MissileAttack()
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
{
Class<Actor> MissileType = MissileName;
DoAttack(false, true, 0, 0, MissileType, MissileHeight);
}
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") void A_ComboAttack()
- scriptified the basic attack functions, its properties and the explosion properties to test the new metadata system.
2017-02-28 09:51:32 +00:00
{
Class<Actor> MissileType = MissileName;
DoAttack(true, true, MeleeDamage, MeleeSound, MissileType, MissileHeight);
}
void A_BasicAttack(int melee_damage, sound melee_sound, class<actor> missile_type, double missile_height)
{
DoAttack(true, true, melee_damage, melee_sound, missile_type, missile_height);
}
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_MonsterRail();
native void A_Pain();
- scriptified A_KeenDie. - added an 'exact' parameter to FThinkerIterator's Next function. This is mainly for scripting which allows to do a lot more checks natively when running the iterator while looking for one specific class.
2016-11-05 00:19:41 +00:00
native void A_NoBlocking(bool drop = true);
- scriptified several trivial functions from a_action.cpp.
2016-11-01 15:32:47 +00:00
void A_Fall() { A_NoBlocking(); }
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_XScream();
native void A_Look();
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
native void A_Chase(statelabel melee = null, statelabel missile = null, int flags = 0);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_Scream();
native void A_VileChase();
native void A_BossDeath();
native void A_Detonate();
- fixed: The special called by the InterpolationSpecial actor must have no activator. This required splitting A_CallSpecial into a direct wrapper around P_ExecuteSpecial and implementing itself as a script function calling ExecuteSpecial so that this special case can use a version of the function that can be used without an activator.
2017-02-15 21:49:13 +00:00
bool A_CallSpecial(int special, int arg1=0, int arg2=0, int arg3=0, int arg4=0, int arg5=0)
{
return Level.ExecuteSpecial(special, self, null, false, arg1, arg2, arg3, arg4, arg5);
}
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_ActiveSound();
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_FastChase();
native void A_PlayerScream();
native void A_SkullPop(class<PlayerChunk> skulltype = "BloodySkull");
native void A_CheckPlayerDone();
- scriptified most of a_strifestuff.cpp.
2016-11-28 22:30:14 +00:00
native void A_CheckTerrain();
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_Wander(int flags = 0);
native void A_Look2();
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") native void A_BulletAttack();
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_WolfAttack(int flags = 0, sound whattoplay = "weapons/pistol", double snipe = 1.0, int maxdamage = 64, int blocksize = 128, int pointblank = 2, int longrange = 4, double runspeed = 160.0, class<Actor> pufftype = "BulletPuff");
native void A_PlaySound(sound whattoplay = "weapons/pistol", int slot = CHAN_BODY, double volume = 1.0, bool looping = false, double attenuation = ATTN_NORM, bool local = false);
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") void A_PlayWeaponSound(sound whattoplay) { A_PlaySound(whattoplay, CHAN_WEAPON); }
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_StopSound(int slot = CHAN_VOICE); // Bad default but that's what is originally was...
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") native void A_PlaySoundEx(sound whattoplay, name slot, bool looping = false, int attenuation = 0);
deprecated("2.3") native void A_StopSoundEx(name slot);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native void A_SeekerMissile(int threshold, int turnmax, int flags = 0, int chance = 50, int distance = 10);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
native action state A_Jump(int chance, statelabel label, ...);
- let A_SpawnProjectile, A_FireProjectile, A_SpawnItem(Ex) and A_ThrowGrenade return the spawned actors to the calling code. - fixed the return type checks in CallStateChain. These made some bogus assumptions about what return prototypes to support and would have skipped any multi-return function whose first argument was actually usable.
2017-01-20 11:39:51 +00:00
native Actor A_SpawnProjectile(class<Actor> missiletype, double spawnheight = 32, double spawnofs_xy = 0, double angle = 0, int flags = 0, double pitch = 0, int ptr = AAPTR_TARGET);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_CustomBulletAttack(double spread_xy, double spread_z, int numbullets, int damageperbullet, class<Actor> pufftype = "BulletPuff", double range = 0, int flags = 0, int ptr = AAPTR_TARGET, class<Actor> missile = null, double Spawnheight = 32, double Spawnofs_xy = 0);
- added a new parameter to A_CustomRailgun to customize the inaccuracy induced by a moving target.
2017-01-10 19:08:23 +00:00
native void A_CustomRailgun(int damage, int spawnofs_xy = 0, color color1 = 0, color color2 = 0, int flags = 0, int aim = 0, double maxdiff = 0, class<Actor> pufftype = "BulletPuff", double spread_xy = 0, double spread_z = 0, double range = 0, int duration = 0, double sparsity = 1.0, double driftspeed = 1.0, class<Actor> spawnclass = null, double spawnofs_z = 0, int spiraloffset = 270, int limit = 0, double veleffect = 3);
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
native bool A_SetInventory(class<Inventory> itemtype, int amount, int ptr = AAPTR_DEFAULT, bool beyondMax = false);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native bool A_GiveInventory(class<Inventory> itemtype, int amount = 0, int giveto = AAPTR_DEFAULT);
native bool A_TakeInventory(class<Inventory> itemtype, int amount = 0, int flags = 0, int giveto = AAPTR_DEFAULT);
- let A_SpawnProjectile, A_FireProjectile, A_SpawnItem(Ex) and A_ThrowGrenade return the spawned actors to the calling code. - fixed the return type checks in CallStateChain. These made some bogus assumptions about what return prototypes to support and would have skipped any multi-return function whose first argument was actually usable.
2017-01-20 11:39:51 +00:00
action native bool, Actor A_SpawnItem(class<Actor> itemtype = "Unknown", double distance = 0, double zheight = 0, bool useammo = true, bool transfer_translation = false);
native bool, Actor A_SpawnItemEx(class<Actor> itemtype, double xofs = 0, double yofs = 0, double zofs = 0, double xvel = 0, double yvel = 0, double zvel = 0, double angle = 0, int flags = 0, int failchance = 0, int tid=0);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_Print(string whattoprint, double time = 0, name fontname = "none");
native void A_PrintBold(string whattoprint, double time = 0, name fontname = "none");
- added a 'local' parameter to the A_Log family. - complete "give quakes their own damage type." (was only partially saved.)
2017-01-13 10:48:05 +00:00
native void A_Log(string whattoprint, bool local = false);
native void A_LogInt(int whattoprint, bool local = false);
native void A_LogFloat(double whattoprint, bool local = false);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_SetTranslucent(double alpha, int style = 0);
native void A_SetRenderStyle(double alpha, int style);
native void A_FadeIn(double reduce = 0.1, int flags = 0);
native void A_FadeOut(double reduce = 0.1, int flags = 1); //bool remove == true
native void A_FadeTo(double target, double amount = 0.1, int flags = 0);
native void A_SpawnDebris(class<Actor> spawntype, bool transfer_translation = false, double mult_h = 1, double mult_v = 1);
native void A_SpawnParticle(color color1, int flags = 0, int lifetime = 35, double size = 1, double angle = 0, double xoff = 0, double yoff = 0, double zoff = 0, double velx = 0, double vely = 0, double velz = 0, double accelx = 0, double accely = 0, double accelz = 0, double startalphaf = 1, double fadestepf = -1, double sizestep = 0);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native void A_ExtChase(bool usemelee, bool usemissile, bool playactive = true, bool nightmarefast = false);
Added default value for amount argument of A_DropInventory() https://mantis.zdoom.org/view.php?id=330
2017-02-24 08:15:32 +00:00
native void A_DropInventory(class<Inventory> itemtype, int amount = -1);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_SetBlend(color color1, double alpha, int tics, color color2 = 0);
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") native void A_ChangeFlag(string flagname, bool value);
- added explicit setter functions for the count and link flags so that A_ChangeFlag and A_SetFlag can be deprecated.
2016-10-25 08:15:24 +00:00
native void A_ChangeCountFlags(int kill = FLAG_NO_CHANGE, int item = FLAG_NO_CHANGE, int secret = FLAG_NO_CHANGE);
- added a 'nocheck' parameter to A_Raise* and Thing_Raise.
2017-02-26 16:50:48 +00:00
native void A_RaiseMaster(int flags = 0);
native void A_RaiseChildren(int flags = 0);
native void A_RaiseSiblings(int flags = 0);
- let A_SpawnProjectile, A_FireProjectile, A_SpawnItem(Ex) and A_ThrowGrenade return the spawned actors to the calling code. - fixed the return type checks in CallStateChain. These made some bogus assumptions about what return prototypes to support and would have skipped any multi-return function whose first argument was actually usable.
2017-01-20 11:39:51 +00:00
action native bool, Actor A_ThrowGrenade(class<Actor> itemtype, double zheight = 0, double xyvel = 0, double zvel = 0, bool useammo = true);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_Weave(int xspeed, int yspeed, double xdist, double ydist);
- added A_Morph function.
2017-02-26 20:20:47 +00:00
native bool A_Morph(class<Actor> type, int duration = 0, int flags = 0, class<Actor> enter_flash = null, class<Actor> exit_flash = null);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
- fixed: The default minimum and maximum distances for A_Teleport were swapped.
2017-01-04 22:55:24 +00:00
action native state, bool A_Teleport(statelabel teleportstate = null, class<SpecialSpot> targettype = "BossSpot", class<Actor> fogtype = "TeleportFog", int flags = 0, double mindist = 128, double maxdist = 0, int ptr = AAPTR_DEFAULT);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
action native state, bool A_Warp(int ptr_destination, double xofs = 0, double yofs = 0, double zofs = 0, double angle = 0, int flags = 0, statelabel success_state = null, double heightoffset = 0, double radiusoffset = 0, double pitch = 0);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
native void A_CountdownArg(int argnum, statelabel targstate = null);
native state A_MonsterRefire(int chance, statelabel label);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_LookEx(int flags = 0, double minseedist = 0, double maxseedist = 0, double maxheardist = 0, double fov = 0, statelabel label = null);
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_Recoil(double xyvel);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native bool A_GiveToTarget(class<Inventory> itemtype, int amount = 0, int forward_ptr = AAPTR_DEFAULT);
native bool A_TakeFromTarget(class<Inventory> itemtype, int amount = 0, int flags = 0, int forward_ptr = AAPTR_DEFAULT);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native int A_RadiusGive(class<Inventory> itemtype, double distance, int flags, int amount = 0, class<Actor> filter = null, name species = "None", double mindist = 0, int limit = 0);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_CustomMeleeAttack(int damage = 0, sound meleesound = "", sound misssound = "", name damagetype = "none", bool bleed = true);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_CustomComboAttack(class<Actor> missiletype, double spawnheight, int damage, sound meleesound = "", name damagetype = "none", bool bleed = true);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native void A_Burst(class<Actor> chunktype);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_RadiusThrust(int force = 128, int distance = -1, int flags = RTF_AFFECTSOURCE, int fullthrustdistance = 0);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_RadiusDamageSelf(int damage = 128, double distance = 128, int flags = 0, class<Actor> flashtype = null);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native int A_Explode(int damage = -1, int distance = -1, int flags = XF_HURTSOURCE, bool alert = false, int fulldamagedistance = 0, int nails = 0, int naildamage = 10, class<Actor> pufftype = "BulletPuff", name damagetype = "none");
native void A_Stop();
native void A_Respawn(int flags = 1);
- scriptified A_Saw. - implemented multiple-return-value assignment. Due to some grammar conflicts the originally intended Lua-inspired syntax of 'a, b = Function()' could not be done, so it's '[a, b] = Function()'
2016-11-19 23:25:38 +00:00
native void A_RestoreSpecialPosition();
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_QueueCorpse();
native void A_DeQueueCorpse();
native void A_ClearLastHeard();
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native bool A_SelectWeapon(class<Weapon> whichweapon, int flags = 0);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_ClassBossHealth();
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_SetAngle(double angle = 0, int flags = 0, int ptr = AAPTR_DEFAULT);
native void A_SetPitch(double pitch, int flags = 0, int ptr = AAPTR_DEFAULT);
native void A_SetRoll(double roll, int flags = 0, int ptr = AAPTR_DEFAULT);
native void A_ScaleVelocity(double scale, int ptr = AAPTR_DEFAULT);
native void A_ChangeVelocity(double x = 0, double y = 0, double z = 0, int flags = 0, int ptr = AAPTR_DEFAULT);
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") native void A_SetUserVar(name varname, int value);
deprecated("2.3") native void A_SetUserArray(name varname, int index, int value);
deprecated("2.3") native void A_SetUserVarFloat(name varname, double value);
deprecated("2.3") native void A_SetUserArrayFloat(name varname, int index, double value);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native void A_Quake(int intensity, int duration, int damrad, int tremrad, sound sfx = "world/quake");
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_QuakeEx(int intensityX, int intensityY, int intensityZ, int duration, int damrad, int tremrad, sound sfx = "world/quake", int flags = 0, double mulWaveX = 1, double mulWaveY = 1, double mulWaveZ = 1, int falloff = 0, int highpoint = 0, double rollIntensity = 0, double rollWave = 0);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
action native void A_SetTics(int tics);
native void A_DropItem(class<Actor> item, int dropamount = -1, int chance = 256);
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
native void A_DamageSelf(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_DamageTarget(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_DamageMaster(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_DamageTracer(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_DamageChildren(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_DamageSiblings(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_KillTarget(name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_KillMaster(name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_KillTracer(name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_KillChildren(name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_KillSiblings(name damagetype = "none", int flags = 0, class<Actor> filter = null, name species = "None", int src = AAPTR_DEFAULT, int inflict = AAPTR_DEFAULT);
native void A_RemoveTarget(int flags = 0, class<Actor> filter = null, name species = "None");
native void A_RemoveMaster(int flags = 0, class<Actor> filter = null, name species = "None");
native void A_RemoveTracer(int flags = 0, class<Actor> filter = null, name species = "None");
native void A_RemoveChildren(bool removeall = false, int flags = 0, class<Actor> filter = null, name species = "None");
native void A_RemoveSiblings(bool removeall = false, int flags = 0, class<Actor> filter = null, name species = "None");
native void A_Remove(int removee, int flags = 0, class<Actor> filter = null, name species = "None");
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native int A_GiveToChildren(class<Inventory> itemtype, int amount = 0);
native int A_GiveToSiblings(class<Inventory> itemtype, int amount = 0);
native int A_TakeFromChildren(class<Inventory> itemtype, int amount = 0);
native int A_TakeFromSiblings(class<Inventory> itemtype, int amount = 0);
native void A_SetTeleFog(class<Actor> oldpos, class<Actor> newpos);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_SwapTeleFog();
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native void A_SetHealth(int health, int ptr = AAPTR_DEFAULT);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_ResetHealth(int ptr = AAPTR_DEFAULT);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native void A_SetSpecies(name species, int ptr = AAPTR_DEFAULT);
native void A_SetChaseThreshold(int threshold, bool def = false, int ptr = AAPTR_DEFAULT);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native bool A_FaceMovementDirection(double offset = 0, double anglelimit = 0, double pitchlimit = 0, int flags = 0, int ptr = AAPTR_DEFAULT);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native int A_ClearOverlays(int sstart = 0, int sstop = 0, bool safety = true);
native bool A_CopySpriteFrame(int from, int to, int flags = 0);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native bool A_SetVisibleRotation(double anglestart = 0, double angleend = 0, double pitchstart = 0, double pitchend = 0, int flags = 0, int ptr = AAPTR_DEFAULT);
- scriptified Heretic's Skull Rod. - Took the opportunity and fixed the logic for the Skull Rod's rain spawner. The old code which was part of the 3D floor submission was unable to work with portals at all. The new approach no longer tries to hide the dead projectile in the ceiling, it leaves it where it is and changes a few flags, so that its z-position can be used as reference to get the actual ceiling. This works for line portals, but for sector portals still requires some changes to sector_t::NextHighestCeilingAt to work, but at least this can be made to work unlike the old code. - added names for the player-related translations to A_SetTranslation. - fixed: Failure to resolve a function argument was checked for, too late. - made the parameter for A_SetTranslation a name instead of a string, because it is more efficient. We do not need full strings here.
2016-11-25 15:05:03 +00:00
native void A_SetTranslation(name transname);
Added option to check the location for resizing, changing the return into a bool.
2016-12-18 00:31:25 +00:00
native bool A_SetSize(double newradius, double newheight = -1, bool testpos = false);
- added a distance parameter to A_SprayDecal.
2017-04-14 14:28:54 +00:00
native void A_SprayDecal(String name, double dist = 172);
- added A_SetMugshotState.
2017-02-26 17:46:06 +00:00
native void A_SetMugshotState(String name);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
native void A_RearrangePointers(int newtarget, int newmaster = AAPTR_DEFAULT, int newtracer = AAPTR_DEFAULT, int flags=0);
native void A_TransferPointer(int ptr_source, int ptr_recepient, int sourcefield, int recepientfield=AAPTR_DEFAULT, int flags=0);
- turned everything I could into non-action functions. - fixed emission of the self pointer in FxVMFunctionCall. I did not realize that the self expression only sets up a register for the value, not pushing it onto the stack.
2016-10-22 15:49:08 +00:00
native void A_CopyFriendliness(int ptr_source = AAPTR_MASTER);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- fixed: State labels were resolved in the calling function's context instead of the called function one's. This could cause problems with functions that take states as parameters but use them to set them internally instead of passing them through the A_Jump interface back to the caller, like A_Chase or A_LookEx. This required some quite significant refactoring because the entire state resolution logic had been baked into the compiler which turned out to be a major maintenance problem. Fixed this by adding a new builtin type 'statelabel'. This is an opaque identifier representing a state, with the actual data either directly encoded into the number for single label state or an index into a state information table. The state resolution is now the task of the called function as it should always have remained. Note, that this required giving back the 'action' qualifier to most state jumping functions. - refactored most A_Jump checkers to a two stage setup with a pure checker that returns a boolean and a scripted A_Jump wrapper, for some simpler checks the checker function was entirely omitted and calculated inline in the A_Jump function. It is strongly recommended to use the boolean checkers unless using an inline function invocation in a state as they lead to vastly clearer code and offer more flexibility. - let Min() and Max() use the OP_MIN and OP_MAX opcodes. Although these were present, these function were implemented using some grossly inefficient branching tests. - the DECORATE 'state' cast kludge will now actually call ResolveState because a state label is not a state and needs conversion.
2016-11-14 13:12:27 +00:00
action native bool A_Overlay(int layer, statelabel start = null, bool nooverride = false);
- renamed all instances of 'float' parameters to 'double', so that the Float32 type can be made usable for structs.
2016-11-21 12:04:27 +00:00
native void A_WeaponOffset(double wx = 0, double wy = 32, int flags = 0);
action native void A_OverlayOffset(int layer = PSP_WEAPON, double wx = 0, double wy = 32, int flags = 0);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
action native void A_OverlayFlags(int layer, int flags, bool set);
Merge branch 'OverlayAlpha' into OverlayExtension9 # Conflicts: # src/p_pspr.cpp # src/r_draw.cpp # wadsrc/static/actors/actor.txt # wadsrc/static/actors/constants.txt
2016-12-26 20:37:22 +00:00
action native void A_OverlayAlpha(int layer, double alph);
action native void A_OverlayRenderStyle(int layer, int style);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- use the function defaults from the script instead of explicitly setting them again in the code. This is a needless cause of potential errors and since the values are readily available now it's better to use them in the functions. - fixed: ZCCCompiler did not process array access nodes. - fixed: Function argument names were not placed in the destination list by the compiler. - scriptified several trivial functions from p_actionfunctions.cpp.
2016-10-27 13:53:53 +00:00
int ACS_NamedExecute(name script, int mapnum=0, int arg1=0, int arg2=0, int arg3=0)
{
return ACS_Execute(-int(script), mapnum, arg1, arg2, arg3);
}
int ACS_NamedSuspend(name script, int mapnum=0)
{
return ACS_Suspend(-int(script), mapnum);
}
int ACS_NamedTerminate(name script, int mapnum=0)
{
return ACS_Terminate(-int(script), mapnum);
}
int ACS_NamedLockedExecute(name script, int mapnum=0, int arg1=0, int arg2=0, int lock=0)
{
return ACS_LockedExecute(-int(script), mapnum, arg1, arg2, lock);
}
int ACS_NamedLockedExecuteDoor(name script, int mapnum=0, int arg1=0, int arg2=0, int lock=0)
{
return ACS_LockedExecuteDoor(-int(script), mapnum, arg1, arg2, lock);
}
int ACS_NamedExecuteWithResult(name script, int arg1=0, int arg2=0, int arg3=0, int arg4=0)
{
return ACS_ExecuteWithResult(-int(script), arg1, arg2, arg3, arg4);
}
int ACS_NamedExecuteAlways(name script, int mapnum=0, int arg1=0, int arg2=0, int arg3=0)
{
return ACS_ExecuteAlways(-int(script), mapnum, arg1, arg2, arg3);
}
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
- finished the state usage parser. - added state usage specifiers to Actor and Inventory. The states in these classes must be set to full access so that any existing mod can link to them.
2016-11-14 22:24:10 +00:00
States(Actor, Overlay, Weapon, Item)
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
{
Spawn:
- resorted some of thingdef.cpp's contents into more appropriate files. - split FinishActor into several functions. While DECORATE can, ZSCRIPT cannot do all this in one go. - split the state finalization into several class-specific virtual functions.
2016-10-12 18:42:41 +00:00
TNT1 A -1;
Stop;
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
Null:
- resorted some of thingdef.cpp's contents into more appropriate files. - split FinishActor into several functions. While DECORATE can, ZSCRIPT cannot do all this in one go. - split the state finalization into several class-specific virtual functions.
2016-10-12 18:42:41 +00:00
TNT1 A 1;
Stop;
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
GenericFreezeDeath:
// Generic freeze death frames. Woo!
- resorted some of thingdef.cpp's contents into more appropriate files. - split FinishActor into several functions. While DECORATE can, ZSCRIPT cannot do all this in one go. - split the state finalization into several class-specific virtual functions.
2016-10-12 18:42:41 +00:00
#### # 5 A_GenericFreezeDeath;
---- A 1 A_FreezeDeathChunks;
Wait;
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
GenericCrush:
- resorted some of thingdef.cpp's contents into more appropriate files. - split FinishActor into several functions. While DECORATE can, ZSCRIPT cannot do all this in one go. - split the state finalization into several class-specific virtual functions.
2016-10-12 18:42:41 +00:00
POL5 A -1;
Stop;
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
}
// Internal functions
- implemented the parser basics of a ZScript versioning system. Note that this completely disables the newly added keywords 'play' and 'ui' for unversioned code to allow using them as identifiers as I have found at least one mod that uses a variable named 'play' that would have been rendered broken otherwise. This also disables many ZScript only keywords for other parsing jobs.
2017-03-05 13:03:27 +00:00
deprecated("2.3") private native int __decorate_internal_int__(int i);
deprecated("2.3") private native bool __decorate_internal_bool__(bool b);
deprecated("2.3") private native double __decorate_internal_float__(double f);
- initialize function symbols. At the moment all it does is process the existing native functions. Any further processing will be done once the base classes of the engine can be parsed from the scripting files. - switched the types of the internal 'self' and 'stateowner' parameters so that they get assigned correctly. I can't tell if this will error out if fields get accessed from the caller with the wrong class, but for actual scripting to work these must be correct. The committed 'actor.txt' can be parsed successfully, with the exception of a few subclass references that cannot be resolved yet.
2016-10-11 16:53:10 +00:00
}
Reference in a new issue Copy permalink