AngelScript: The Revenge

[Dimentio]

In my honest opinion, I don't think it's wise to go forth with switching to AngelScript in the near future. It's been 4 years since the last big ZC release, not counting bugfixes, and I think time should be devoted into getting an update with a good amount of new features within this year, instead of spending the next couple months (at least) trying to implement a new scripting language with... not all that much to gain in the short term? Longterm, sure, it'd be easier to develop for, but if we take too long to release a new update, people will start getting bored of what they have now and eventually just start moving off to other languages. ZScript might be bad for development, yes, but the last thing we need is another 8 year gap between major releases to add in a replacement coding language people have to learn all over again. Right now, I think the highest priority should be providing a decent sized update to renew interest, or at least keep it sparked. Keeping interest in the program trumps all other concerns, to me, and improving ZScript isn't impossible (Hell, look at what Zoria has been doing the past 2.5 months. Seriously, the guy is insane, props to him).

If we were to add AngelScript in the future, or at any point in time, we need at least one team working on faster 2.50 updates in the meantime, so if it takes 2 or so years to add AngelScript, people have updates to keep them interested long enough to see the big 3.0 or whichever update. We'd also need heavy communication between the two teams to add what the "filler" 2.50 updates add, so that when AngelScript is implemented, it doesn't just feel like a downgrade compared to the current version. If anything, it should be the superior version, so to get the early adopters on to start making content (and it should be superior in a way that's not significant. I highly doubt Angelscript by itself is a "significant" sign of superiority). Actually, the dev team should make quests just to go with the update, so that when people start playing it, they have content they can play immediately, that is exclusive.

Of course, that's just my opinion. I've never been involved with marketing... anything, really, so my opinion might not be worth much.

EDIT: Also, perhaps we should poll PureZC and see what they think?

[SUCCESSOR]

EDIT: Also, perhaps we should poll PureZC and see what they think?

So we can get more, "ew! change?! HSSSSSS!!!!"? Sounds great. Why not?

[Gleeok]

I've been working on the compiler/zscript converter today. Currently implementing Wait(int frames) which is a bit tricky if we want overly-generic coroutines, which I'm guessing is a no. Right now there are two problems:

1) Nested context calling. It looks like this feature is relatively new, but won't play nice with 1st class objects (eg; think ffc-ish types in ZScript). nested stack space from multiple objects that occupies the same memory sounds like a bad idea to even look into.
2) Modules: Another oldish new feature. Problem is different scripts cannot access anything outside their module unless it's a 'shared' object, which complicates everything from low-level to script level. If there's something like std.as or utility libs I don't know how this will work in practice. It seems like people will get around this by duplicating imported code so the only thing we gain is more RAM usage. :/ Not sure.

Right now I'm defaulting to "a script is it's own fully-featured script and nothing less", so don't over complicate anything right now.

@Saffith : Have you messed with any of the above? Also have you written any angelscript stuff since the old repo? -Just making sure I don't duplicate anything unnecessarily.

EDIT: Also, perhaps we should poll PureZC and see what they think?

That sounds like a great idea. We all know how much purezc likes random polls! I assume it can either be or be by someone whom is unbiased on the matter?


[edit]
Another interesting thing. Consider the following on the same frame:

npc->Update()
{
  ...
  waitframe();
  ...
}

npc collides with x.
script wants to know about it.

engine calls npc->onCollidesWithX()
{
  x.HP -= 2;
  this.HP += 2;
  waitframes(6876);
  this.HP = this.MaxHP; //invalid code path; never gets here
}

I'm assuming that the "intended behavior" is to resume the update method next frame?

[Saffith]

1) Nested context calling. It looks like this feature is relatively new, but won't play nice with 1st class objects (eg; think ffc-ish types in ZScript). nested stack space from multiple objects that occupies the same memory sounds like a bad idea to even look into.

I vaguely recall looking at that and thinking the same thing, but I don't think there's really any need for it. If you want to call a draw method or an event handler or something, you can just do it in another context.

2) Modules: Another oldish new feature. Problem is different scripts cannot access anything outside their module unless it's a 'shared' object, which complicates everything from low-level to script level. If there's something like std.as or utility libs I don't know how this will work in practice. It seems like people will get around this by duplicating imported code so the only thing we gain is more RAM usage. :/ Not sure.

Again, I don't think there's any need. I don't think there's anything that needs isolated, and there shouldn't be any harm in putting everything in the same module.

Also have you written any angelscript stuff since the old repo? -Just making sure I don't duplicate anything unnecessarily.

Nope, haven't touched it.

I'm assuming that the "intended behavior" is to resume the update method next frame?

That's a bit tricky. I was thinking event handlers shouldn't be allowed to Waitframe, since that makes things really complicated. Things like enemies that need to change behavior in response to events would either need to use update methods, like they already do, or have their Waitframes throw exceptions, which is of course a terrible way to handle it. It might also be possible to do something like a stack of AIs; when an enemy gets hit, you'd push a knockback state, then pop it when it finishes. That doesn't actually sound like a good idea to me, though.

Edit: Or make a Waitframe wrapper that returns any necessary state change info. You'd think that would be the first thing I think of. :p

[Gleeok]

Okay great. I think we're on the same page then.

[Gleeok]

There are *lots* of built-ins. I'm guessing about 100 or so can be deprecated though. Doing one section at a time hopefully wont be too bad.

namespace GlobalBindings
{
	int32 Rand(int32 maxvalue);
	void Quit();
	void Waitframe();
	void Waitdraw(); //?

	// DEPRICATED ***
	void Trace(int32 val);
	void TraceB(bool state);
	void TraceS(int32 s[]);
	void TraceToBase(int32 val, int32 base, int32 mindigits);
	void TraceNL();
	void ClearTrace();
	// DEPRICATED ***

	// DEPRICATED ***
	float Sin(float deg);
	float Cos(float deg);
	float Tan(float deg);
	// DEPRICATED ***

	float RadianSin(float rad);
	float RadianCos(float rad);
	float RadianTan(float rad);

	float ArcTan(int32 x, int32 y);
	float ArcSin(float x);
	float ArcCos(float x);
	float Max(float a, float b);
	float Min(float a, float b);
	int32 Pow(int32 base, int32 exp);
	int32 InvPow(int32 base, int32 exp);
	float Log10(float val);
	float Ln(float val);
	int32 Factorial(int32 val);
	float Abs(float val);
	float Sqrt(float val);

	// DEPRICATED ***
	void CopyTile(int32 srctile, int32 desttile);
	void SwapTile(int32 firsttile, int32 secondtile);
	void ClearTile(int32 tileref);
	int32 SizeOfArray(int32 array[]);
	// DEPRICATED ***
}


namespace FFCBindings
{
	int32 Data;
	int32 Script; // DEPRICATED ***
	int32 CSet;
	int32 Delay;
	float X;
	float Y;
	float Vx;
	float Vy;
	float Ax;
	float Ay;
	bool Flags[];
	int32 TileWidth;
	int32 TileHeight;
	int32 EffectWidth;
	int32 EffectHeight;
	int32 Link;
	float InitD[];
	float Misc[];
};


namespace LinkBindings
{
	int32 X;
	int32 Y;
	int32 Z;
	bool Invisible;
	bool CollDetection;
	int32 Jump;
	int32 SwordJinx;
	int32 ItemJinx;
	int32 Drunk;
	int32 Dir;
	int32 HitDir;
	int32 HP;
	int32 MP;
	int32 MaxHP;
	int32 MaxMP;
	int32 Action;
	int32 HeldItem;
	int32 LadderX;

	// DEPRICATED ***
	bool InputStart;
	bool InputMap;
	bool InputUp;
	bool InputDown;
	bool InputLeft;
	bool InputRight;
	bool InputA;
	bool InputB;
	bool InputL;
	bool InputR;
	bool InputEx1;
	bool InputEx2;
	bool InputEx3;
	bool InputEx4;
	bool InputAxisUp;
	bool InputAxisDown;
	bool InputAxisLeft;
	bool InputAxisRight;
	// DEPRICATED ***

	// DEPRICATED ***
	bool PressStart;
	bool PressMap;
	bool PressUp;
	bool PressDown;
	bool PressLeft;
	bool PressRight;
	bool PressA;
	bool PressB;
	bool PressL;
	bool PressR;
	bool PressEx1;
	bool PressEx2;
	bool PressEx3;
	bool PressEx4;
	bool PressAxisUp;
	bool PressAxisDown;
	bool PressAxisLeft;
	bool PressAxisRight;
	// DEPRICATED ***

	// DEPRICATED ***
	int32 InputMouseX;
	int32 InputMouseY;
	int32 InputMouseB;
	int32 InputMouseZ;
	// DEPRICATED ***

	bool Item[];
	int32 Equipment;
	int32 Tile;
	int32 Flip;
	int32 HitZHeight;
	int32 HitXOffset;
	int32 HitYOffset;
	int32 DrawXOffset;
	int32 DrawYOffset;
	int32 DrawZOffset;
	float_or_int32 Misc[];
	void Warp(int32 DMap, int32 screen);
	void PitWarp(int32 DMap, int32 screen);
	SelectAWeapon(int32 dir);
	SelectBWeapon(int32 dir);
};


namespace Screen
{
	float_or_int32 D[];
	int32 Flags[];
	int32 EFlags[];
	int32 ComboD[];
	int32 ComboC[];
	int32 ComboF[];
	int32 ComboI[];
	int32 ComboT[];
	int32 ComboS[];
	int32 MovingBlockX;
	int32 MovingBlockY;
	int32 MovingBlockCombo;
	int32 MovingBlockCSet;
	int32 UnderCombo;
	int32 UnderCSet;
	bool State[];
	int32 Door[];
	int32 RoomType;
	int32 RoomData;
	void TriggerSecrets();
	bool Lit;
	int32 Wavy;
	int32 Quake;
	void SetSideWarp(int32 warp, int32 screen, int32 dmap, int32 type);
	void SetTileWarp(int32 warp, int32 screen, int32 dmap, int32 type);
	void GetSideWarpDMap(int32 warp);
	void GetSideWarpScreen(int32 warp);
	void GetSideWarpType(int32 warp);
	void GetTileWarpDMap(int32 warp);
	void GetTileWarpScreen(int32 warp);
	void GetTileWarpType(int32 warp);
	int32 LayerMap(int32 n);
	int32 LayerScreen(int32 n);
	int32 NumItems();
	item LoadItem(int32 num);
	item CreateItem(int32 id);
	ffc LoadFFC(int32 num); // DEPRICATED ***
	int32 NumNPCs();
	npc LoadNPC(int32 num);
	npc CreateNPC(int32 id);
	int32 NumLWeapons();
	lweapon LoadLWeapon(int32 num);
	lweapon CreateLWeapon(int32 type);
	int32 NumEWeapons();
	eweapon LoadEWeapon(int32 num);
	eweapon CreateEWeapon(int32 type);
	bool isSolid(int32 x, int32 y);
	void ClearSprites(int32 spritelist);

	 // DEPRICATED ***
	void Rectangle(int32 layer, int32 x, int32 y, int32 x2, int32 y2, int32 color, float_or_int32 scale, int32 rx, int32 ry, int32 rangle, bool fill, int32 opacity);
	void Circle(int32 layer, int32 x, int32 y, int32 radius, int32 color, float_or_int32 scale, int32 rx, int32 ry, int32 rangle, bool fill, int32 opacity);
	void Arc(int32 layer, int32 x, int32 y, int32 radius, int32 startangle, int32 endangle, int32 color, float_or_int32 scale, int32 rx, int32 ry, int32 rangle, bool closed, bool fill, int32 opacity);
	void Ellipse(int32 layer, int32 x, int32 y, int32 xradius, int32 yradius, int32 color, float_or_int32 scale, int32 rx, int32 ry, int32 rangle, bool fill, int32 opacity);
	void Spline(int32 layer, int32 x1, int32 y1, int32 x2, int32 y2, int32 x3, int32 y3,int32 x4, int32 y4, int32 color, int32 opacity);
	void Line(int32 layer, int32 x, int32 y, int32 x2, int32 y2, int32 color, float_or_int32 scale, int32 rx, int32 ry, int32 rangle, int32 opacity);
	void PutPixel(int32 layer, int32 x, int32 y, int32 color, int32 rx, int32 ry, int32 rangle, int32 opacity);
	void DrawTile(int32 layer, int32 x, int32 y, int32 tile, int32 blockw, int32 blockh, int32 cset, int32 xscale, int32 yscale, int32 rx, int32 ry, int32 rangle, int32 flip, bool transparency, int32 opacity);
	void FastTile( int32 layer, int32 x, int32 y, int32 tile, int32 cset, int32 opacity );
	void DrawCombo(int32 layer, int32 x, int32 y, int32 combo, int32 w, int32 h, int32 cset, int32 xscale, int32 yscale, int32 rx, int32 ry, int32 rangle, int32 frame, int32 flip, bool transparency, int32 opacity);
	void FastCombo( int32 layer, int32 x, int32 y, int32 combo, int32 cset, int32 opacity );
	 // DEPRICATED ***

	void Message(int32 string);

	 // DEPRICATED ***
	void DrawCharacter(int32 layer, int32 x, int32 y, int32 font,int32 color, int32 background_color,int32 width, int32 height, int32 glyph, int32 opacity );
	void DrawInteger(int32 layer, int32 x, int32 y, int32 font,int32 color, int32 background_color,int32 width, int32 height, int32 number, int32 number_decimal_places, int32 opacity);
	void DrawString( int32 layer, int32 x, int32 y, int32 font,int32 color, int32 background_color,int32 format, int32 ptr[], int32 opacity );
	void Quad( int32 layer, int32 x1, int32 y1, int32 x2, int32 y2, int32 x3, int32 y3, int32 x4, int32 y4,int32 w, int32 h, int32 cset, int32 flip, int32 texture, int32 render_mode);
	void Triangle( int32 layer, int32 x1, int32 y1, int32 x2, int32 y2, int32 x3, int32 y3,int32 w, int32 h, int32 cset, int32 flip, int32 texture, int32 render_mode);
	void Quad3D( int32 layer, int32 pos[], int32 uv[], int32 cset[], int32 size[], int32 flip, int32 texture, int32 render_mode );
	void Triangle3D( int32 layer, int32 pos[], int32 uv[], int32 csets[], int32 size[], int32 flip, int32 texture, int32 render_mode );
	void SetRenderTarget( int32 bitmap_id );
	void DrawBitmap( int32 layer, int32 bitmap_id, int32 source_x, int32 source_y, int32 source_w, int32 source_h, int32 dest_x, int32 dest_y, int32 dest_w, int32 dest_h, float_or_int32 rotation, bool mask);
	void DrawLayer(int32 layer, int32 source_map, int32 source_screen, int32 source_layer, int32 x, int32 y, float_or_int32 rotation, int32 opacity);
	void DrawScreen(int32 layer, int32 map, int32 source_screen, int32 x, int32 y, float_or_int32 rotation);
	 // DEPRICATED ***
}; 


namespace ItemBindings
{
	bool isValid();
	int32 X;
	int32 Y;
	int32 Jump;
	int32 DrawStyle;
	int32 ID;
	int32 OriginalTile;
	int32 Tile;
	int32 CSet;
	int32 FlashCSet;
	int32 NumFrames;
	int32 Frame;
	int32 ASpeed;
	int32 Delay;
	bool Flash;
	int32 Flip;
	int32 Pickup;
	int32 Extend;
	int32 TileWidth;
	int32 TileHeight;
	int32 HitWidth;
	int32 HitHeight;
	int32 HitZHeight;
	int32 HitXOffset;
	int32 HitYOffset;
	int32 DrawXOffset;
	int32 DrawYOffset;
	int32 DrawZOffset;
	float_or_int32 Misc[];
};

namespace WeaponBindings
{
	bool isValid();
	void UseSprite(int32 id);
	bool Behind;
	int32 ID;
	int32 X;
	int32 Y;
	int32 Z;
	int32 Jump;
	int32 DrawStyle;
	int32 Dir;
	int32 OriginalTile;
	int32 Tile;
	int32 OriginalCSet;
	int32 CSet;
	int32 FlashCSet;
	int32 NumFrames;
	int32 Frame;
	int32 ASpeed;
	int32 Damage;
	int32 Step;
	int32 Angle;
	bool Angular;
	bool CollDetection;
	int32 DeadState;
	bool Flash;
	int32 Flip;
	int32 Extend;
	int32 TileWidth;
	int32 TileHeight;
	int32 HitWidth;
	int32 HitHeight;
	int32 HitZHeight;
	int32 HitXOffset;
	int32 HitYOffset;
	int32 DrawXOffset;
	int32 DrawYOffset;
	int32 DrawZOffset;
	float_or_int32 Misc[];
}; 

namespace ItemDataBindings
{
	float_or_int32 InitD[];
	void GetName(int32 buffer[]);
	int32 Family;
	int32 Level;
	int32 Power;
	int32 Amount;
	int32 MaxIncrement;
	int32 Max;
	bool Keep;
	int32 Counter;
	int32 UseSound;
}; 


namespace GameBindings
{
	int32 GetCurScreen();
	int32 GetCurDMapScreen();
	int32 GetCurLevel();
	int32 GetCurMap();
	int32 GetCurDMap();
	int32 DMapFlags[];
	int32 DMapLevel[];
	int32 DMapCompass[];
	int32 DMapContinue[];
	int32 DMapMIDI[];
	void GetDMapName(int32 DMap, int32 buffer[]);
	void GetDMapTitle(int32 DMap, int32 buffer[]);
	void GetDMapIntro(int32 DMap, int32 buffer[]);
	int32 DMapOffset[];
	int32 DMapMap[];
	int32 NumDeaths;
	int32 Cheat;
	int32 Time;
	bool TimeValid;
	bool HasPlayed;
	bool Standalone;
	int32 GuyCount[];
	int32 ContinueDMap;
	int32 ContinueScreen;
	int32 LastEntranceDMap;
	int32 LastEntranceScreen;
	int32 Counter[];
	int32 MCounter[];
	int32 DCounter[];
	int32 Generic[];
	int32 LItems[];
	int32 LKeys[];
	int32 GetScreenFlags(int32 map, int32 screen, int32 flagset);
	int32 GetScreenEFlags(int32 map, int32 screen, int32 flagset);
	bool GetScreenState(int32 map, int32 screen, int32 flag);
	void SetScreenState(int32 map, int32 screen, int32 flag, bool value);
	float_or_int32 GetScreenD(int32 screen, int32 reg);
	void SetScreenD(int32 screen, int32 reg, float_or_int32 value);
	float_or_int32 GetDMapScreenD(int32 dmap, int32 screen, int32 reg);
	void SetDMapScreenD(int32 dmap, int32 screen, int32 reg, float_or_int32 value);
	itemdata LoadItemData(int32 item);
	void PlaySound(int32 soundid);
	void PlayMIDI(int32 MIDIid);
	int32 GetMIDI();
	bool PlayEnhancedMusic(int32 filename[], int32 track);
	void GetDMapMusicFilename(int32 dmap, int32 buf[]);
	int32 GetDMapMusicTrack(int32 dmap);
	void SetDMapEnhancedMusic(int32 dmap, int32 filename[], int32 track);
	int32 GetComboData(int32 map, int32 screen, int32 position);
	void SetComboData(int32 map, int32 screen, int32 position, int32 value);
	int32 GetComboCSet(int32 map, int32 screen, int32 position);
	void SetComboCSet(int32 map, int32 screen, int32 position, int32 value);
	int32 GetComboFlag(int32 map, int32 screen, int32 position);
	void SetComboFlag(int32 map, int32 screen, int32 position, int32 value);
	int32 GetComboType(int32 map, int32 screen, int32 position);
	void SetComboType(int32 map, int32 screen, int32 position, int32 value);
	int32 GetComboInherentFlag(int32 map, int32 screen, int32 position);
	void SetComboInherentFlag(int32 map, int32 screen, int32 position, int32 value);
	int32 GetComboSolid(int32 map, int32 screen, int32 position);
	void SetComboSolid(int32 map, int32 screen, int32 position, int32 value);
	int32 ComboTile(int32 combo);
	void GetSaveName(int32 buffer[]);
	void SetSaveName(int32 name[]);
	void End();
	void Save();
	bool ShowSaveScreen();
	void ShowSaveQuitScreen();
	void GetMessage(int32 string, int32 buffer[]);
	int32 GetFFCScript(int32 name[]);
	bool ClickToFreezeEnabled;
}; 


namespace NPCBindings
{
	bool isValid();
	void GetName(int32 buffer[]);
	int32 ID;
	int32 Type;
	int32 X;
	int32 Y;
	int32 Z;
	int32 Jump;
	int32 Dir;
	int32 Rate;
	int32 Haltrate;
	int32 Homing;
	int32 Hunger;
	int32 Step;
	bool CollDetection;
	int32 ASpeed;
	int32 DrawStyle;
	int32 HP;
	int32 Damage;
	int32 WeaponDamage;
	int32 Stun;
	int32 OriginalTile;
	int32 Tile;
	int32 Weapon;
	int32 ItemSet;
	int32 CSet;
	int32 BossPal;
	int32 SFX;
	int32 Extend;
	int32 TileWidth;
	int32 TileHeight;
	int32 HitWidth;
	int32 HitHeight;
	int32 HitZHeight;
	int32 HitXOffset;
	int32 HitYOffset;
	int32 DrawXOffset;
	int32 DrawYOffset;
	int32 DrawZOffset;
	int32 Defense[];
	int32 Attributes[];
	int32 MiscFlags;
	float_or_int32 Misc[];
	void BreakShield();
};

I've put in a preprocessor which greatly simplifies the conversion layer, and can remap many things via macros. It would be a multi-pass "parser." Currently the idea is to load the script buffer, generate a list of all imported files, tag on a conversion file at the top, then process those files into memory, where a third pass can be run before finally outputting the converted scripts or sending it to the AS compiler.

Things like operators '->' to '.' etc., or different script types are trivial so I expect a > 95% initial success rate. Hopefully I can get this part finished and start looking at actual output files next week.
We'll see how well this works. O_o

[SUCCESSOR]

Things like operators '->' to '.' etc., or different script types are trivial so I expect a > 95% initial success rate. Hopefully I can get this part finished and start looking at actual output files next week.
We'll see how well this works. O_o

Does that mean in AngelScript you can just do:

example_ptr.foo = 9;

Or do you dereference it with a star and parentheses? Cuz that is more annoying than the arrow operator.

Did some google-fu. AS doesn't have pointers(?), but ...handles... I'm even more confused now.

I like AS! Let's get this going so I can get to really learning it.

[Tamamo]

I would prefer we actually use Lua this time around.
Angelscript hasn't aged well these pass years.

[DarkDragon]

What are the advantages of LUA over AS?

One concern I have with LUA (which also applies to AS): the only large project I am personally familiar with that uses LUA heavily is ToME, and it had significant performance problems (actions take place is less than real time once many scripts start acting at once). Is this a concern, or just that ToME is poorly designed?

[Gleeok]

What are the advantages of LUA over AS?

One concern I have with LUA (which also applies to AS): the only large project I am personally familiar with that uses LUA heavily is ToME, and it had significant performance problems (actions take place is less than real time once many scripts start acting at once). Is this a concern, or just that ToME is poorly designed?

LUA is used by at least hundreds of games. Unfortunately you probably won't get a list by googling for it as most of the titles are by large game studios. If ToME used AS then it would be at least as slow, if not slower, I would assume. Once the spritelist gets optimized and we avoid using the AS GC (reference types) for anything built-in or trivial it shouldn't be an issue.

Would you like to wager on an ZScript vs AS performance comparison?

Also Tamano is just joking. I don't think that was serious.