logo
Main

Forums

Downloads

Unreal-Netiquette

Donate for Oldunreal:
Donate

borderline

Links to our wiki:
Wiki

Walkthrough

Links

Tutorials

Unreal Reference

Usermaps

borderline

Contact us:
Submit News
Page Index Toggle Pages: 1 Send TopicPrint
Hot Topic (More than 10 Replies) Unfinished Language features. (Read 4867 times)
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Unfinished Language features.
Jan 26th, 2015 at 10:12am
Print Post  
UnrealScript language features like an FArray/TMap interface is sth. which seems to be at least supported by some degree by the script compiler, so I tinkering with the idea of trying to experimenting with runtime support for this (e.g. add needed native functions, which are hooked in to some degree).

However as I've never touched this before and actually doesn't have a list of these features I'm asking you guys if you can name the things you know of. This doesn't have to be DeusEx specific, but rather for any unreal 1 game, so i have an idea what i can try and what probably fails.
  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
.:..:
Oldunreal MasterPoster
Developer Team
*
Offline



Posts: 1463
Location: Finland
Joined: Aug 16th, 2005
Gender: Male
Re: Unfinished Language features.
Reply #1 - Jan 26th, 2015 at 2:52pm
Print Post  
FArray is base class of TArray.
TArray is dynamic array object in C++ codes, as for TMap, it is hash mapping for paired values, for example:
TMap<FString,UClass*>, can be used to quick find a matching class reference with a string.

Dynamic array support is broken in UnrealScript on UnrealEngine 1.
Map is fully unsupported in UnrealScript on all UnrealEngine versions.
  

Shivaxi wrote on Jul 25th, 2013 at 12:50pm:
...and now im stuck trying to fix everything you broke for the next 227 release xD Tongue

(ಠ_ಠ)
Back to top
IP Logged
 
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Re: Unfinished Language features.
Reply #2 - Jan 26th, 2015 at 4:02pm
Print Post  
Actually i wanted to type TArray, not FArray.
I know that TArray support is broken, but i just saw TArrayNoInit in Brother Bear, and actually DeusEx has sth like this in it's uc source, but i seems to be just used to have a struct of the right size in place:
Code
Select All
// ----------------------------------------------------------------------
// UnrealScript version of TArray/FArray (originally in Object.uc; moved
// here after removal in version 224)
struct DynamicArray
{
	var const int Num, Max, Ptr;
};
var const native DynamicArray displayBuffer;
 


And as BrotherBear uses a different syntax anyway e.g.
Code
Select All
var array<Actor> AuxAnims;
 


However at some time i read sth. about broken script compiler features refering TArray and iirc even TMap stuff, that the script compiler at least notices a bit of it's syntax and stuff. However, the question i want to investigate is if the compiler actually compiles some of that TArray related code and if he does, did he create opcodes for it? If it does that i could try adding a function to GNatives implementing that functionality. Iirc i saw that Brother Bear had two hardcoded names, added exec's or sth. (can't find it again right now) comparted to ut432 which sounded like TArray support, but actually it did had the first of a set of three functions which sounded like sth which is used to access an TArray. So I'm hoping that the compiler actually creates an opcode for it, hence I'm asking for detailed info about what is already known, so I don't have to start from scratch.
  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
.:..:
Oldunreal MasterPoster
Developer Team
*
Offline



Posts: 1463
Location: Finland
Joined: Aug 16th, 2005
Gender: Male
Re: Unfinished Language features.
Reply #3 - Jan 27th, 2015 at 2:56pm
Print Post  
Well the pre-224 version with "DynamicArray" struct has absolutely no UnrealScript support for dynamic arrays.

224 and later UScript compiler does produce compiled code for array entry accessor, but the native function itself is unimplemented, so if you want you CAN actually override that GNative entry to a fixed version of the accessor:
Code (C++)
Select All
GNatives[EX_DynArrayElement] = &MyCustomObject::execCustomArElement; 


That way this will be functional:
Code
Select All
var array<int> A;
A[0] = 25; 


But you will still need to implement your own native function to modify array size.
  

Shivaxi wrote on Jul 25th, 2013 at 12:50pm:
...and now im stuck trying to fix everything you broke for the next 227 release xD Tongue

(ಠ_ಠ)
Back to top
IP Logged
 
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Re: Unfinished Language features.
Reply #4 - Jan 27th, 2015 at 4:18pm
Print Post  
Thanks!
Does the static array accessor do proper bounds check? Probably not.. as it will try to access UFixedArrayProperty::Count, which is inside the alignment/padding following the UArrayProperty. So i guess i should start with trying to implement a save version of it, which behaves like the static accessor if out of bounds.
  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
.:..:
Oldunreal MasterPoster
Developer Team
*
Offline



Posts: 1463
Location: Finland
Joined: Aug 16th, 2005
Gender: Male
Re: Unfinished Language features.
Reply #5 - Jan 27th, 2015 at 8:58pm
Print Post  
You can rather easily find UE source codes with google, from there you can see how it's implemented.
  

Shivaxi wrote on Jul 25th, 2013 at 12:50pm:
...and now im stuck trying to fix everything you broke for the next 227 release xD Tongue

(ಠ_ಠ)
Back to top
IP Logged
 
Higor
New Member
*
Offline


Oldunreal member

Posts: 27
Location: Behind you
Joined: Oct 21st, 2014
Gender: Male
Re: Unfinished Language features.
Reply #6 - Mar 3rd, 2015 at 5:12pm
Print Post  
Given i'm not a licensee or anything, am I allowed to post what I used in XC_GameEngine to add dynamic array support for UT?
Even if I made unrealscript code compiled with it cross-compatible with 227?
  
Back to top
 
IP Logged
 
[]KAOS[]Casey
Developer Team
Betatester
Offline


nedm

Posts: 3192
Joined: Aug 7th, 2011
Gender: Male
Re: Unfinished Language features.
Reply #7 - Mar 4th, 2015 at 8:13am
Print Post  
As far as I'm concerned, if it's doable in public headers using your own code, it's fine.

Unrealscript for U1 probably generates the same opcodes for generating dynamic arrays as UT. I dont think the compiler for 227 was changed to support dynamic arrays further, only native functions to access TArray<> functions.
  
Back to top
 
IP Logged
 
Smirftsch
Forum Administrator
*****
Online



Posts: 7932
Location: at home
Joined: Apr 30th, 1998
Gender: Male
Re: Unfinished Language features.
Reply #8 - Mar 4th, 2015 at 11:30am
Print Post  
as for 227, well, we have some additions, dots really did a good job there... Smiley

Quote:
Dynamic Array support has been improved:

Added dynamic array length accessing functions: native(640) static final function int GetArraySize( ArrayProperty ArProp ); native(641) static final function bool InsertArrayIdx( ArrayProperty ArProp, int Offset, optional int Count ); native(642) static final function bool RemoveArrayIdx( ArrayProperty ArProp, int Offset, optional int Count );

static native(238) final function string Locs( string InStr ); native(239) static final function string ReplaceStr( string Text, string FindStr, string ReplaceWith, optional bool bCaseInsensitive ); native(240) static final function bool SortArray( ArrayProperty Prop, Function SortCode ); native(241) static final function bool SortStaticArray( Property Prop, Function SortCode, optional int SortSize ); Which does convert string to lower case, replace part of some string, sort dynamic and static arrays (in a very performance effective way).

Added new defaultproperties macros for dynamic arrays: Array.Add(Value), Array.Remove(Value), Array.Empty


Higor wrote on Mar 3rd, 2015 at 5:12pm:
Given i'm not a licensee or anything, am I allowed to post what I used in XC_GameEngine to add dynamic array support for UT?
Even if I made unrealscript code compiled with it cross-compatible with 227?

as long its based on public headers as Casey already said, everything is fine.
  

Sometimes you have to lose a fight to win the war.
Back to top
WWWICQ  
IP Logged
 
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Re: Unfinished Language features.
Reply #9 - Mar 11th, 2015 at 6:04pm
Print Post  
Not directly an unfinished feature, but i wrote a simple hack for script include support:
Code
Select All
// Stripped of everything which would need other depencencies.
struct FFeedbackContextAnsi : public FFeedbackContext
{
	// Variables.
	INT SlowTaskCount;
	INT WarningCount;
	FContextSupplier* Context;
	FOutputDevice* AuxOut;
};
extern DLL_IMPORT class WLog* GLogWindow;

UBOOL URevisionEditorEngine::SafeExec( const TCHAR* Cmd, FOutputDevice& Ar )
{
	const TCHAR* Str = Cmd;

	// Hack for #exec include.
	if( ParseCommand(&Str,TEXT("INCLUDE")) )
	{
		if ( GLogWindow )
		{
			Ar.Logf( NAME_ExecWarning, TEXT("Include command not supported inside UnrealEd.") );
			return 1;
		}
		FString File, Text;
		if ( !Parse(Str,TEXT("FILE="),File) )
		{
			Ar.Logf( NAME_ExecWarning, TEXT("No include file specified."), *File );
			return 1;
		}
		if( !appLoadFileToString( Text, *File ) )
		{
			Ar.Logf( NAME_ExecWarning, TEXT("Include file %s not found."), *File );
			return 1;
		}

		// TODO: Find another way to aquire ScriptCompiler.
		//       Right now assumption is made that if GLogWindow==NULL
		//       GWarn is an FeedbackContextAnsi. MEGA-BARF.
		FFeedbackContextAnsi* AnsiWarn  = (FFeedbackContextAnsi*)GWarn;
		FScriptCompiler* ScriptCompiler = (FScriptCompiler*)AnsiWarn->Context;
		UClass* Class = ScriptCompiler->Class;

		// Split Script text in part before #exec include and after.
		FString Left, Right;
		INT Start;
		Left  = Class->ScriptText->Text;
		Left  = Left.Left( ScriptCompiler->InputPos );
		Start = Max(Max(Left.InStr(TEXT("\r"),1),Left.InStr(TEXT("\n"),1))+1,0);
		Left  = Left.Left( Start );
		Right = FString( ScriptCompiler->Input+ScriptCompiler->InputPos );

		// Hook in changed ScriptText.
		Class->ScriptText->Text  = Left+TEXT("\r\n")+Text+Right;
		ScriptCompiler->Input    = *Class->ScriptText->Text;
		ScriptCompiler->InputLen = Class->ScriptText->Text.Len();
		ScriptCompiler->InputPos = Start;
		return 1;
	}
	else
		return Super::SafeExec( Cmd, Ar );
}
 



So now one can do sth. like this:
Code
Select All
#exec include file="Classes\Test.inc"
 

  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Re: Unfinished Language features.
Reply #10 - Nov 12th, 2015 at 1:41am
Print Post  
I just had a wicked idea how to hack in features to the script compiler. E.g. if you compile a map declaration the uc compiler throws an exception. So basic idea is to attach some kind of debugger to the process, use it to run own code where it had thrown before and afterwards resume at the same position the exception was thrown. Sounds pretty dirty, but might be worth to investigate..
  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Re: Unfinished Language features.
Reply #11 - Jul 2nd, 2019 at 6:43pm
Print Post  
So I finally dived deeper into adding dynamic array support for Deus Ex.

Getting P_GET macros for FArray/TArray is straight forward, as FString is more
less just a fancy TArray<BYTE>, so one can just go from there.
Code
Select All
#define P_GET_FARRAY(var)             FArray var;                          Stack.Step( Stack.Object, &var    );
#define P_GET_FARRAY_OPTX(var,def)    FArray var(def);                     Stack.Step( Stack.Object, &var    );
#define P_GET_FARRAY_REF(var)         FArray var##T; GPropAddr=0;          Stack.Step( Stack.Object, &var##T ); FArray* var = GPropAddr ? (FArray*)GPropAddr:&var##T;
#define P_GET_TARRAY(typ,var)         TArray<typ> var;                     Stack.Step( Stack.Object, &var    );
#define P_GET_TARRAY_OPTX(typ,var,def)TArray<typ> var(def);                Stack.Step( Stack.Object, &var    );
#define P_GET_TARRAY_REF(typ,var)     TArray<typ> var##T; GPropAddr=0;     Stack.Step( Stack.Object, &var##T ); TArray<typ>* var = GPropAddr ? (TArray<typ>*)GPropAddr:&var##T;
 


Note that when using Objects with the P_GET_TARRAY macro you want to the pointer type for typ.

We can now go ahead and use P_GET_ARRAY_REF macro to implement a native function to retrieve the array count for any type.
Code
Select All
native(3100) static final function int DynIntArrayCount( Array<int> Array );

void UHXObject::execDynIntArrayCount( FFrame& Stack, RESULT_DECL )
{
	guard(UHXObject::execDynArrayCount); // Missing "Int" is intentional.
	P_GET_TARRAY_REF(INT,Array)
	P_FINISH;

	*(INT*)Result = Array->Num();
	unguardexec;
} 


Note that the P_GET_TARRAY_REF may not the best implementation, as one can potentially avoid creating the extra fallback copy, but I'm not yet comfortable enough with the script execution system to just head for this. Smiley

You can do macros to speed up the process. Macros in UnrealScript would probably be also helpful here. ^^'
Code
Select All
#define IMPLEMENT_DYNARRAYCOUNT(cls,type) \
	void cls::execDyn##type##ArrayCount( FFrame& Stack, RESULT_DECL ) \
	{ \
		((UHXObject*)this)->UHXObject::execDynIntArrayCount( Stack, Result ); \
	}

IMPLEMENT_DYNARRAYCOUNT(UHXObject,Byte);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Float);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,String);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Name);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Object);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Guid);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Vector);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Plane);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Rotator);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Coords);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Scale);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,Color);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,BoundingBox);
IMPLEMENT_DYNARRAYCOUNT(UHXObject,BoundingVolume); 



However, a HUGE downside is that the native function needs to be per type, however we can at least get away with just having to supply DynObjectArrayCount as it also works for any subclass, and well the next best way is to declare it for any other type we may want to use. Including structs also declared in Core.Object (Deus Ex):
Code
Select All
native(3100) static final function int DynIntArrayCount( Array<int> Array );
native(3101) static final function int DynByteArrayCount( Array<byte> Array );
native(3102) static final function int DynFloatArrayCount( Array<float> Array );
native(3103) static final function int DynStringArrayCount( Array<String> Array );
native(3104) static final function int DynNameArrayCount( Array<Name> Array );
native(3105) static final function int DynObjectArrayCount( Array<Object> Array );
native(3106) static final function int DynGuidArrayCount( Array<Guid> Array );
native(3107) static final function int DynVectorArrayCount( Array<Vector> Array );
native(3108) static final function int DynPlaneArrayCount( Array<Plane> Array );
native(3109) static final function int DynRotatorArrayCount( Array<Rotator> Array );
native(3110) static final function int DynCoordsArrayCount( Array<Coords> Array );
native(3111) static final function int DynScaleArrayCount( Array<Scale> Array );
native(3112) static final function int DynColorArrayCount( Array<Color> Array );
native(3113) static final function int DynBoundingBoxArrayCount( Array<BoundingBox> Array );
native(3114) static final function int DynBoundingVolumeArrayCount( Array<BoundingVolume> Array ); 


Note that I have not yet checked if whether the baseclass for a struct is enough, say beeing able to use Array<Plane> with DynVectorArrayCount. I also haven't checked whether the DynByteArrayCount also works with enums.

And now for some good news, we can use the operator system to wrap these all under
a common name:
Code
Select All
static final preoperator int DynArrayCount( Array<int>            Array ) { return DynIntArrayCount           (Array); }
static final preoperator int DynArrayCount( Array<float>          Array ) { return DynFloatArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<String>         Array ) { return DynStringArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Name>           Array ) { return DynNameArrayCount          (Array); }
static final preoperator int DynArrayCount( Array<Object>         Array ) { return DynObjectArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Guid>           Array ) { return DynGuidArrayCount          (Array); }
static final preoperator int DynArrayCount( Array<Vector>         Array ) { return DynVectorArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Plane>          Array ) { return DynPlaneArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<Rotator>        Array ) { return DynRotatorArrayCount       (Array); }
static final preoperator int DynArrayCount( Array<Coords>         Array ) { return DynCoordsArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Scale>          Array ) { return DynScaleArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<Color>          Array ) { return DynColorArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<BoundingBox>    Array ) { return DynBoundingBoxArrayCount   (Array); }
static final preoperator int DynArrayCount( Array<BoundingVolume> Array ) { return DynBoundingVolumeArrayCount(Array); } 



As this is just pure unrealscript, we can also just implement the operators into any other, even pure unrealscript class:
Code
Select All
static final preoperator int DynArrayCount( Array<int>            Array ) { return Class'HXObject'.static.DynIntArrayCount           (Array); }
static final preoperator int DynArrayCount( Array<float>          Array ) { return Class'HXObject'.static.DynFloatArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<String>         Array ) { return Class'HXObject'.static.DynStringArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Name>           Array ) { return Class'HXObject'.static.DynNameArrayCount          (Array); }
static final preoperator int DynArrayCount( Array<Object>         Array ) { return Class'HXObject'.static.DynObjectArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Guid>           Array ) { return Class'HXObject'.static.DynGuidArrayCount          (Array); }
static final preoperator int DynArrayCount( Array<Vector>         Array ) { return Class'HXObject'.static.DynVectorArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Plane>          Array ) { return Class'HXObject'.static.DynPlaneArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<Rotator>        Array ) { return Class'HXObject'.static.DynRotatorArrayCount       (Array); }
static final preoperator int DynArrayCount( Array<Coords>         Array ) { return Class'HXObject'.static.DynCoordsArrayCount        (Array); }
static final preoperator int DynArrayCount( Array<Scale>          Array ) { return Class'HXObject'.static.DynScaleArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<Color>          Array ) { return Class'HXObject'.static.DynColorArrayCount         (Array); }
static final preoperator int DynArrayCount( Array<BoundingBox>    Array ) { return Class'HXObject'.static.DynBoundingBoxArrayCount   (Array); }
static final preoperator int DynArrayCount( Array<BoundingVolume> Array ) { return Class'HXObject'.static.DynBoundingVolumeArrayCount(Array); } 



So one could start from there and start to add structs declared in Actor, etc. but the approach is the same. It kinda sucks, but it should actually be good enough for a lot of tasks. I started to use it to specifcy an arbitrary amount of sounds in defaultproperties, to pick a random selected one out of it.

Also, one can always continue and start implementing += operators to add items, etc.

When you use dynamic arrays in native classes, you run into the issues with them not getting exported as TArrayNoInit, so you would end up having to maintain your constructors to deal with them, but you can hook UArrayProperty::ExportCppItem, while solves this issue in an automated way.
Code
Select All
//
// Did always export as TArray, but it needs to be either TArrayNoInit
// inside classes or the E_NoInit constructor needs to be called,
// as otherwise it would empty the array.
//
// Needless to say that manually calling E_NoInit isn't an option.
//
void UArrayPropertySubstitute::ExportCppItem( FOutputDevice& Ar ) const
{
	guard(UArrayPropertySubstitute::ExportCppItem);
	Ar.Log( (PropertyFlags&CPF_Parm) ? TEXT("TArray<") : TEXT("TArrayNoInit<") );
	Inner->ExportCppItem( Ar );
	Ar.Log( TEXT(">") );
	unguardobj;
} 


  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Re: Unfinished Language features.
Reply #12 - Jul 2nd, 2019 at 7:55pm
Print Post  
While it is still to me pretty unclear how I would design the operators to work with the dynamic arrays, only one operator is dead clear to me, to be implemented in that way:

To use !MyArray as a shortcut for DynArrayCount(MyArray)==0

Code
Select All
// Shortcut for DynArrayCount(Array)==0.
static final preoperator bool !( out Array<int>            Array ) { return DynIntArrayCount           (Array)==0; }
static final preoperator bool !( out Array<byte>           Array ) { return DynByteArrayCount          (Array)==0; }
static final preoperator bool !( out Array<float>          Array ) { return DynFloatArrayCount         (Array)==0; }
static final preoperator bool !( out Array<String>         Array ) { return DynStringArrayCount        (Array)==0; }
static final preoperator bool !( out Array<Name>           Array ) { return DynNameArrayCount          (Array)==0; }
static final preoperator bool !( out Array<Object>         Array ) { return DynObjectArrayCount        (Array)==0; }
static final preoperator bool !( out Array<Guid>           Array ) { return DynGuidArrayCount          (Array)==0; }
static final preoperator bool !( out Array<Vector>         Array ) { return DynVectorArrayCount        (Array)==0; }
static final preoperator bool !( out Array<Plane>          Array ) { return DynPlaneArrayCount         (Array)==0; }
static final preoperator bool !( out Array<Rotator>        Array ) { return DynRotatorArrayCount       (Array)==0; }
static final preoperator bool !( out Array<Coords>         Array ) { return DynCoordsArrayCount        (Array)==0; }
static final preoperator bool !( out Array<Scale>          Array ) { return DynScaleArrayCount         (Array)==0; }
static final preoperator bool !( out Array<Color>          Array ) { return DynColorArrayCount         (Array)==0; }
static final preoperator bool !( out Array<BoundingBox>    Array ) { return DynBoundingBoxArrayCount   (Array)==0; }
static final preoperator bool !( out Array<BoundingVolume> Array ) { return DynBoundingVolumeArrayCount(Array)==0; } 

  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
han
Global Moderator
Unreal Rendering Guru
Developer Team
*****
Offline


Oldunreal member

Posts: 565
Location: Germany
Joined: Dec 10th, 2014
Gender: Male
Re: Unfinished Language features.
Reply #13 - Jul 7th, 2019 at 9:51am
Print Post  
I started using Num() instead of DynArrayCount(), which is shorter, and is somewhat in the line of what was done in the same way for string functions.
  

HX on Mod DB. Revision on Steam.
Back to top
 
IP Logged
 
Page Index Toggle Pages: 1
Send TopicPrint
Bookmarks: del.icio.us Digg Facebook Google Google+ Linked in reddit StumbleUpon Twitter Yahoo