• Most people probably don't realise this, but this forum has had two editors for a number of years. One is the xenForo default editor, and the other is a custom editor I made years back I called BBCEd.

    All the settings for which editor you use was lost during the upgrade. You can find the setting under Account Settings > Preferences > Editor.

CSE2 - The Cave Story decompilation project

Nov 5, 2019 at 5:52 AM
Perfectionist
CS Beta Content Discord Admin
CSE Discord Moderator
"Bleep, Bloop, Bleep, Bloop"
Join Date: Dec 26, 2014
Location: the back of their own hand.
Posts: 1514
Age: 119
That can probably just have its own memory in CSE2, but you'd still have to use numbers, sadly :(
Why would you have to use numbers? Just program it to accept a string for a data structure.
 
Nov 5, 2019 at 5:54 AM
Best elf
"Life begins and ends with Nu."
Join Date: Jun 27, 2013
Location: Cygnus
Posts: 2105
Age: 24
Why would you have to use numbers? Just program it to accept a string for a data structure.
Oh right. Cuz C can do anything. I apologize, my brain too small and am still old fashioned at custom TSC. No seriously, how the hell did i forget that's already a thing? <NAM uses strings in TSC!
 
Nov 5, 2019 at 6:39 AM
Perfectionist
CS Beta Content Discord Admin
CSE Discord Moderator
"Bleep, Bloop, Bleep, Bloop"
Join Date: Dec 26, 2014
Location: the back of their own hand.
Posts: 1514
Age: 119
Oh right. Cuz C can do anything. I apologize, my brain too small and am still old fashioned at custom TSC. No seriously, how the hell did i forget that's already a thing? <NAM uses strings in TSC!
Should be easy enough to do in assembly as well.
 
Nov 5, 2019 at 6:48 AM
Best elf
"Life begins and ends with Nu."
Join Date: Jun 27, 2013
Location: Cygnus
Posts: 2105
Age: 24
I know. That's why I had that strikethrough included. <NAM was made entirely with ASM, too!

<NAM - NAMebox (<NAMstring$)
Creates a namebox to be used alongside only <MSG (and technically, <MS4). The character count for the string can be however long, as long as it can fit in the game screen. Use <NAM$ for removing it.

 
Nov 5, 2019 at 6:52 AM
Perfectionist
CS Beta Content Discord Admin
CSE Discord Moderator
"Bleep, Bloop, Bleep, Bloop"
Join Date: Dec 26, 2014
Location: the back of their own hand.
Posts: 1514
Age: 119
I know. That's why I had that strikethrough included. <NAM was made entirely with ASM, too!

<NAM - NAMebox (<NAMstring$)
Creates a namebox to be used alongside only <MSG (and technically, <MS4). The character count for the string can be however long, as long as it can fit in the game screen. Use <NAM$ for removing it.

That's the string reading part. The harder part is making a data structure system with indexes that are accessible via string... so that you can use it once.
 
Nov 6, 2019 at 12:28 AM
Junior Member
"Fresh from the Bakery"
Join Date: Aug 5, 2019
Location: Hell
Posts: 12
You can't give names to variables in <VAR. Only 008-123.
I was thinking of improving it so that it could have names assigned.

Doesn't it also use flag memory?
That can probably just have its own memory in CSE2, but you'd still have to use numbers, sadly :(
Correct-ish, there's no reason why it would have to use flag memory (that I can think of), but it also doesn't need to use numbers. Where'd you get that idea?

actually, one reason: saving.
so... I'd have to change how the game saves, too.

gonna go look at how that works, one sec
edit:
predictably, it's in "profile.cpp"

here's the save object structure:
Code:
struct PROFILE
{
	char code[8];
	int stage;
	MusicID music;
	int x;
	int y;
	int direct;
	short max_life;
	short star;
	short life;
	short a;
	int select_arms;
	int select_item;
	int equip;
	int unit;
	int counter;
	ARMS arms[8];
	ITEM items[32];
	PERMIT_STAGE permitstage[8];
	signed char permit_mapping[0x80];
	char FLAG[4];
	unsigned char flags[1000];
};

i'm sure it would be easy enough (even for me) to load in the JSON library and change the structure to
Code:
struct PROFILE
{
	char code[8];
	json variables;
	int stage;
	MusicID music;
	int x;
	int y;
	int direct;
	short max_life;
	short star;
	short life;
	short a;
	int select_arms;
	int select_item;
	int equip;
	int unit;
	int counter;
	ARMS arms[8];
	ITEM items[32];
	PERMIT_STAGE permitstage[8];
	signed char permit_mapping[0x80];
	char FLAG[4];
	unsigned char flags[1000];
};

here's the code for saving a profile:
Code:
BOOL SaveProfile(const char *name)
{
	PROFILE profile;
	FILE *fp;
	const char *FLAG = "FLAG";
	char path[MAX_PATH];

	// Get path
	if (name)
		sprintf(path, "%s/%s", gModulePath, name);
	else
		sprintf(path, "%s/%s", gModulePath, gDefaultName);

	// Open file
	fp = fopen(path, "wb");
	if (fp == NULL)
		return FALSE;

	// Set up profile
	memset(&profile, 0, sizeof(PROFILE));
	memcpy(profile.code, gProfileCode, sizeof(profile.code));
	memcpy(profile.FLAG, FLAG, sizeof(profile.FLAG));
	profile.stage = gStageNo;
	profile.music = gMusicNo;
	profile.x = gMC.x;
	profile.y = gMC.y;
	profile.direct = gMC.direct;
	profile.max_life = gMC.max_life;
	profile.life = gMC.life;
	profile.star = gMC.star;
	profile.select_arms = gSelectedArms;
	profile.select_item = gSelectedItem;
	profile.equip = gMC.equip;
	profile.unit = gMC.unit;
	profile.counter = gCounter;
	memcpy(profile.arms, gArmsData, sizeof(profile.arms));
	memcpy(profile.items, gItemData, sizeof(profile.items));
	memcpy(profile.permitstage, gPermitStage, sizeof(profile.permitstage));
	memcpy(profile.permit_mapping, gMapping, sizeof(profile.permit_mapping));
	memcpy(profile.flags, gFlagNPC, sizeof(profile.flags));

	// Write to file
	fwrite(profile.code, 8, 1, fp);
	File_WriteLE32(profile.stage, fp);
	File_WriteLE32(profile.music, fp);
	File_WriteLE32(profile.x, fp);
	File_WriteLE32(profile.y, fp);
	File_WriteLE32(profile.direct, fp);
	File_WriteLE16(profile.max_life, fp);
	File_WriteLE16(profile.star, fp);
	File_WriteLE16(profile.life, fp);
	File_WriteLE16(profile.a, fp);
	File_WriteLE32(profile.select_arms, fp);
	File_WriteLE32(profile.select_item, fp);
	File_WriteLE32(profile.equip, fp);
	File_WriteLE32(profile.unit, fp);
	File_WriteLE32(profile.counter, fp);
	for (int arm = 0; arm < 8; arm++)
	{
		File_WriteLE32(profile.arms[arm].code, fp);
		File_WriteLE32(profile.arms[arm].level, fp);
		File_WriteLE32(profile.arms[arm].exp, fp);
		File_WriteLE32(profile.arms[arm].max_num, fp);
		File_WriteLE32(profile.arms[arm].num, fp);
	}
	for (int item = 0; item < 32; item++)
		File_WriteLE32(profile.items[item].code, fp);
	for (int stage = 0; stage < 8; stage++)
	{
		File_WriteLE32(profile.permitstage[stage].index, fp);
		File_WriteLE32(profile.permitstage[stage].event, fp);
	}
	fwrite(profile.permit_mapping, 0x80, 1, fp);
	fwrite(FLAG, 4, 1, fp);
	fwrite(profile.flags, 1000, 1, fp);

	fclose(fp);
	return TRUE;
}
maybe change it to:

Code:
BOOL SaveProfile(const char *name)
{
	PROFILE profile;
	FILE *fp;
	const char *FLAG = "FLAG";
	char path[MAX_PATH];

	// Get path
	if (name)
		sprintf(path, "%s/%s", gModulePath, name);
	else
		sprintf(path, "%s/%s", gModulePath, gDefaultName);

	// Open file
	fp = fopen(path, "wb");
	if (fp == NULL)
		return FALSE;

	// Set up profile
	memset(&profile, 0, sizeof(PROFILE));
	memcpy(profile.code, gProfileCode, sizeof(profile.code));
	memcpy(profile.FLAG, FLAG, sizeof(profile.FLAG));
	profile.stage = gStageNo;
	profile.music = gMusicNo;
	profile.x = gMC.x;
	profile.y = gMC.y;
	profile.direct = gMC.direct;
	profile.max_life = gMC.max_life;
	profile.life = gMC.life;
	profile.star = gMC.star;
	profile.select_arms = gSelectedArms;
	profile.select_item = gSelectedItem;
	profile.equip = gMC.equip;
	profile.unit = gMC.unit;
	profile.counter = gCounter;
	profile.variables = JSON.stringify(variables); // that's javascript syntax but you get the point
	memcpy(profile.arms, gArmsData, sizeof(profile.arms));
	memcpy(profile.items, gItemData, sizeof(profile.items));
	memcpy(profile.permitstage, gPermitStage, sizeof(profile.permitstage));
	memcpy(profile.permit_mapping, gMapping, sizeof(profile.permit_mapping));
	memcpy(profile.flags, gFlagNPC, sizeof(profile.flags));

	// Write to file
	fwrite(profile.code, 8, 1, fp);
	File_WriteLE32(profile.stage, fp);
	File_WriteLE32(profile.music, fp);
	File_WriteLE32(profile.x, fp);
	File_WriteLE32(profile.y, fp);
	File_WriteLE32(profile.direct, fp);
	File_WriteLE16(profile.max_life, fp);
	File_WriteLE16(profile.star, fp);
	File_WriteLE16(profile.life, fp);
	File_WriteLE16(profile.a, fp);
	File_WriteLE32(profile.select_arms, fp);
	File_WriteLE32(profile.select_item, fp);
	File_WriteLE32(profile.equip, fp);
	File_WriteLE32(profile.unit, fp);
	File_WriteLE32(profile.counter, fp);
	for (int arm = 0; arm < 8; arm++)
	{
		File_WriteLE32(profile.arms[arm].code, fp);
		File_WriteLE32(profile.arms[arm].level, fp);
		File_WriteLE32(profile.arms[arm].exp, fp);
		File_WriteLE32(profile.arms[arm].max_num, fp);
		File_WriteLE32(profile.arms[arm].num, fp);
	}
	for (int item = 0; item < 32; item++)
		File_WriteLE32(profile.items[item].code, fp);
	for (int stage = 0; stage < 8; stage++)
	{
		File_WriteLE32(profile.permitstage[stage].index, fp);
		File_WriteLE32(profile.permitstage[stage].event, fp);
	}
	fwrite(profile.permit_mapping, 0x80, 1, fp);
	fwrite(FLAG, 4, 1, fp);
	fwrite(profile.flags, 1000, 1, fp);
	

	fwrite(profile.variables, sizeOf(JSON.stringify(profile.variables)), 1, fp);

	fclose(fp);
	return TRUE;
}

That's the string reading part. The harder part is making a data structure system with indexes that are accessible via string... so that you can use it once.
that's why I'm thinking JSON, it seems perfect for the part
keys can be whatever you want, with as many as you want
values can be anything that can be serialized

edit: found a JSON library
github nlohmann/json

any thoughts on all of this?
 
Last edited:
Nov 6, 2019 at 6:16 AM
Perfectionist
CS Beta Content Discord Admin
CSE Discord Moderator
"Bleep, Bloop, Bleep, Bloop"
Join Date: Dec 26, 2014
Location: the back of their own hand.
Posts: 1514
Age: 119
I was thinking of improving it so that it could have names assigned.




Correct-ish, there's no reason why it would have to use flag memory (that I can think of), but it also doesn't need to use numbers. Where'd you get that idea?

actually, one reason: saving.
so... I'd have to change how the game saves, too.

gonna go look at how that works, one sec
edit:
predictably, it's in "profile.cpp"

here's the save object structure:
Code:
struct PROFILE
{
	char code[8];
	int stage;
	MusicID music;
	int x;
	int y;
	int direct;
	short max_life;
	short star;
	short life;
	short a;
	int select_arms;
	int select_item;
	int equip;
	int unit;
	int counter;
	ARMS arms[8];
	ITEM items[32];
	PERMIT_STAGE permitstage[8];
	signed char permit_mapping[0x80];
	char FLAG[4];
	unsigned char flags[1000];
};

i'm sure it would be easy enough (even for me) to load in the JSON library and change the structure to
Code:
struct PROFILE
{
	char code[8];
	json variables;
	int stage;
	MusicID music;
	int x;
	int y;
	int direct;
	short max_life;
	short star;
	short life;
	short a;
	int select_arms;
	int select_item;
	int equip;
	int unit;
	int counter;
	ARMS arms[8];
	ITEM items[32];
	PERMIT_STAGE permitstage[8];
	signed char permit_mapping[0x80];
	char FLAG[4];
	unsigned char flags[1000];
};

here's the code for saving a profile:
Code:
BOOL SaveProfile(const char *name)
{
	PROFILE profile;
	FILE *fp;
	const char *FLAG = "FLAG";
	char path[MAX_PATH];

	// Get path
	if (name)
		sprintf(path, "%s/%s", gModulePath, name);
	else
		sprintf(path, "%s/%s", gModulePath, gDefaultName);

	// Open file
	fp = fopen(path, "wb");
	if (fp == NULL)
		return FALSE;

	// Set up profile
	memset(&profile, 0, sizeof(PROFILE));
	memcpy(profile.code, gProfileCode, sizeof(profile.code));
	memcpy(profile.FLAG, FLAG, sizeof(profile.FLAG));
	profile.stage = gStageNo;
	profile.music = gMusicNo;
	profile.x = gMC.x;
	profile.y = gMC.y;
	profile.direct = gMC.direct;
	profile.max_life = gMC.max_life;
	profile.life = gMC.life;
	profile.star = gMC.star;
	profile.select_arms = gSelectedArms;
	profile.select_item = gSelectedItem;
	profile.equip = gMC.equip;
	profile.unit = gMC.unit;
	profile.counter = gCounter;
	memcpy(profile.arms, gArmsData, sizeof(profile.arms));
	memcpy(profile.items, gItemData, sizeof(profile.items));
	memcpy(profile.permitstage, gPermitStage, sizeof(profile.permitstage));
	memcpy(profile.permit_mapping, gMapping, sizeof(profile.permit_mapping));
	memcpy(profile.flags, gFlagNPC, sizeof(profile.flags));

	// Write to file
	fwrite(profile.code, 8, 1, fp);
	File_WriteLE32(profile.stage, fp);
	File_WriteLE32(profile.music, fp);
	File_WriteLE32(profile.x, fp);
	File_WriteLE32(profile.y, fp);
	File_WriteLE32(profile.direct, fp);
	File_WriteLE16(profile.max_life, fp);
	File_WriteLE16(profile.star, fp);
	File_WriteLE16(profile.life, fp);
	File_WriteLE16(profile.a, fp);
	File_WriteLE32(profile.select_arms, fp);
	File_WriteLE32(profile.select_item, fp);
	File_WriteLE32(profile.equip, fp);
	File_WriteLE32(profile.unit, fp);
	File_WriteLE32(profile.counter, fp);
	for (int arm = 0; arm < 8; arm++)
	{
		File_WriteLE32(profile.arms[arm].code, fp);
		File_WriteLE32(profile.arms[arm].level, fp);
		File_WriteLE32(profile.arms[arm].exp, fp);
		File_WriteLE32(profile.arms[arm].max_num, fp);
		File_WriteLE32(profile.arms[arm].num, fp);
	}
	for (int item = 0; item < 32; item++)
		File_WriteLE32(profile.items[item].code, fp);
	for (int stage = 0; stage < 8; stage++)
	{
		File_WriteLE32(profile.permitstage[stage].index, fp);
		File_WriteLE32(profile.permitstage[stage].event, fp);
	}
	fwrite(profile.permit_mapping, 0x80, 1, fp);
	fwrite(FLAG, 4, 1, fp);
	fwrite(profile.flags, 1000, 1, fp);

	fclose(fp);
	return TRUE;
}
maybe change it to:

Code:
BOOL SaveProfile(const char *name)
{
	PROFILE profile;
	FILE *fp;
	const char *FLAG = "FLAG";
	char path[MAX_PATH];

	// Get path
	if (name)
		sprintf(path, "%s/%s", gModulePath, name);
	else
		sprintf(path, "%s/%s", gModulePath, gDefaultName);

	// Open file
	fp = fopen(path, "wb");
	if (fp == NULL)
		return FALSE;

	// Set up profile
	memset(&profile, 0, sizeof(PROFILE));
	memcpy(profile.code, gProfileCode, sizeof(profile.code));
	memcpy(profile.FLAG, FLAG, sizeof(profile.FLAG));
	profile.stage = gStageNo;
	profile.music = gMusicNo;
	profile.x = gMC.x;
	profile.y = gMC.y;
	profile.direct = gMC.direct;
	profile.max_life = gMC.max_life;
	profile.life = gMC.life;
	profile.star = gMC.star;
	profile.select_arms = gSelectedArms;
	profile.select_item = gSelectedItem;
	profile.equip = gMC.equip;
	profile.unit = gMC.unit;
	profile.counter = gCounter;
	profile.variables = JSON.stringify(variables); // that's javascript syntax but you get the point
	memcpy(profile.arms, gArmsData, sizeof(profile.arms));
	memcpy(profile.items, gItemData, sizeof(profile.items));
	memcpy(profile.permitstage, gPermitStage, sizeof(profile.permitstage));
	memcpy(profile.permit_mapping, gMapping, sizeof(profile.permit_mapping));
	memcpy(profile.flags, gFlagNPC, sizeof(profile.flags));

	// Write to file
	fwrite(profile.code, 8, 1, fp);
	File_WriteLE32(profile.stage, fp);
	File_WriteLE32(profile.music, fp);
	File_WriteLE32(profile.x, fp);
	File_WriteLE32(profile.y, fp);
	File_WriteLE32(profile.direct, fp);
	File_WriteLE16(profile.max_life, fp);
	File_WriteLE16(profile.star, fp);
	File_WriteLE16(profile.life, fp);
	File_WriteLE16(profile.a, fp);
	File_WriteLE32(profile.select_arms, fp);
	File_WriteLE32(profile.select_item, fp);
	File_WriteLE32(profile.equip, fp);
	File_WriteLE32(profile.unit, fp);
	File_WriteLE32(profile.counter, fp);
	for (int arm = 0; arm < 8; arm++)
	{
		File_WriteLE32(profile.arms[arm].code, fp);
		File_WriteLE32(profile.arms[arm].level, fp);
		File_WriteLE32(profile.arms[arm].exp, fp);
		File_WriteLE32(profile.arms[arm].max_num, fp);
		File_WriteLE32(profile.arms[arm].num, fp);
	}
	for (int item = 0; item < 32; item++)
		File_WriteLE32(profile.items[item].code, fp);
	for (int stage = 0; stage < 8; stage++)
	{
		File_WriteLE32(profile.permitstage[stage].index, fp);
		File_WriteLE32(profile.permitstage[stage].event, fp);
	}
	fwrite(profile.permit_mapping, 0x80, 1, fp);
	fwrite(FLAG, 4, 1, fp);
	fwrite(profile.flags, 1000, 1, fp);
	

	fwrite(profile.variables, sizeOf(JSON.stringify(profile.variables)), 1, fp);

	fclose(fp);
	return TRUE;
}


that's why I'm thinking JSON, it seems perfect for the part
keys can be whatever you want, with as many as you want
values can be anything that can be serialized

edit: found a JSON library
github nlohmann/json

any thoughts on all of this?
Using JSON in assembly?! Why I ought to smack you!
 
Nov 7, 2019 at 1:47 AM
Junior Member
"Fresh from the Bakery"
Join Date: Aug 5, 2019
Location: Hell
Posts: 12
Using JSON in assembly?! Why I ought to smack you!
I don't see any assembly here.
Does TSC count as assembly?
if so, I wasn't thinking of using JSON in it,
I was thinking of using JSON to store the "variables" & their data internally (in C++)

although, I was thinking of making it possible to make arrays & stuff in TSC

<ARD (array define)
Code:
<ARDNAMEOFARRAY<ARD
<ARS (array set)
Code:
<ARSNAMEOFARRAY[INDEX]<ARSdata<ARS
<ARG (array get; name may need to be changed as this may already exist)
Code:
<ARGNAMEOFARRAY[INDEX]<ARG
<ARL (array length; returns length of array. mainly used for getting the latest index of an array.)
Code:
<ARLNAMEOFARRAY<ARL
for example,
say you kill a Mimiga (dark example, but memorable)
Code:
<ARDkilledMimigas<ARD
<MSGKilled Jack!<ARSkilledMimigas[<ARLkilledMimigas<ARL]<ARSJack<ARS<NOD
You have killed <ARLkilledMimigas<ARL mimigas!<NOD<CLO<END
<ILT (is less than)
<IGT (is greater than)

maybe a <MTH (math) command?
<MTH:ADD(or MULTIPLY, or DIVIDE, or SUBTRACT, or SQRT, or ROUND, or FLOOR, i don't know)<MTHTOADD1<MTHTOADD2<MTH


also thinking of adding a FOR loop command (to loop through the arrays) but maybe that's not a good idea?

it would probably go like this
syntax: <FOR: incrementing variable (goes up by one at end of each cycle)<FOR conditional (needs to be true; if it's false, it breaks the loop)<FOR (code to repeat)<FOE
for example,
Code:
<FOR:<VAR:INCREMENTINGVAR<VAR0<VAR<FOR<ILT:<GVRINCREMENTINGVAR<GVR<FOR<ARLkilledMimigas<ARL<FOR 
     <MSGYou have killed <ARG:killedMimigas[<GVR (get var)INCREMENTINGVAR<GVR]!<NOD
<FOE(for end)

you could use it for repetitive stuff, too:
<MSG100 bottles of beer on the wall, 100 bottles of beer!<NOD
Take one down, pass it around,<NOD
<FOR:<VARasdf<VAR0<VAR<ILT:<GVRasdf<GVR:99<FOR
    <MTHSUBTRACT<MTH0<MTH<GVRasdf<GVR<MTH bottles of beer on the wall!<NOD
    <MTHSUBTRACT<MTH0<MTH<GVRasdf<GVR<MTH bottles of beer on the wall, <MTHSUBTRACT<MTH0<MTH<GVRasdf<GVR<MTH bottles of beer!<NOD
    Take one down, pass it around, 
<FOE
0 bottles of beer on the wall!<NOD<CLO<END

that's all for now, will edit this with new ideas later

am I being too ambitious?
 
Last edited:
Nov 7, 2019 at 5:41 AM
Best elf
"Life begins and ends with Nu."
Join Date: Jun 27, 2013
Location: Cygnus
Posts: 2105
Age: 24
Looking into the plans for the new <VAR system multiple times so I can get a grip of how it'd work, I can see this being more practical than classic <VAR. Hell, it looks like most stuff from <VAR is already taken care of from your new command list! I don't think though, that I understand how <ARS would convert "Jack" to a single value like 1 and add it to the killedMimigas string's total. Unless you plan on using universal defines for a separate .tsc file for all maps to read. Maybe an explanation will be needed...
 
Nov 7, 2019 at 11:18 AM
Perfectionist
CS Beta Content Discord Admin
CSE Discord Moderator
"Bleep, Bloop, Bleep, Bloop"
Join Date: Dec 26, 2014
Location: the back of their own hand.
Posts: 1514
Age: 119
Why make so many operations? Why not just have an <SCR that lets you program things normally?
 
Nov 7, 2019 at 10:23 PM
Junior Member
"Fresh from the Bakery"
Join Date: Aug 5, 2019
Location: Hell
Posts: 12
Why make so many operations? Why not just have an <SCR that lets you program things normally?
I don't know. In Javascript, eval() is a lot less efficient.
I can see the point, though - it's just that I don't know how to do that yet.


Looking into the plans for the new <VAR system multiple times so I can get a grip of how it'd work, I can see this being more practical than classic <VAR. Hell, it looks like most stuff from <VAR is already taken care of from your new command list! I don't think though, that I understand how <ARS would convert "Jack" to a single value like 1 and add it to the killedMimigas string's total. Unless you plan on using universal defines for a separate .tsc file for all maps to read. Maybe an explanation will be needed...
I haven't seen the classic <VAR - do you have a link to the thread?

also,
<ARS is "array set"
so
Code:
<ARSkilledMimigas[<ARLkilledMimigas<ARL]<ARSJack<ARS
would set the array index[array's length] to "Jack"
basically, it appends "Jack" to the array, because arrays start at 0

equivalent of (in Javascript) killedMimigas.push("Jack")

so if killedMimigas was already
["Sue", "Toroko", "King"]
then <ARSkilledMimigas[<ARLkilledMimigas<ARL]<ARSJack<ARS would change it into
["Sue", "Toroko", "King", "Jack"]
 
Last edited:
Nov 7, 2019 at 11:51 PM
Best elf
"Life begins and ends with Nu."
Join Date: Jun 27, 2013
Location: Cygnus
Posts: 2105
Age: 24
I haven't seen the classic <VAR - do you have a link to the thread?
There is no thread for <VAR, unfortunately. Most custom ASM don't exactly have its own thread, unless theyre being released in bulk or contributed to a thread to dump them in for collecting. However, all the information on it is in my earlier post in this thread and in the Hackinator guide in Booster's Lab.

You may also need to just fiddle around with it in a modded version of vanilla for testing purposes.
 
Nov 8, 2019 at 2:53 AM
Junior Member
"Fresh from the Bakery"
Join Date: Aug 5, 2019
Location: Hell
Posts: 12
There is no thread for <VAR, unfortunately. Most custom ASM don't exactly have its own thread, unless theyre being released in bulk or contributed to a thread to dump them in for collecting. However, all the information on it is in my earlier post in this thread and in the Hackinator guide in Booster's Lab.

You may also need to just fiddle around with it in a modded version of vanilla for testing purposes.
OK, thanks


Edit:
Because my free time right now is at an all-time low, I can't work on this (at this time).
If I release anything it will be in at least a month.
If someone else wants to work on it, that's welcome, but I can't spare the time right now.
 
Last edited:
Top