ZDoom

A long time ago, I suggested something like this for ZDoom. I've finally programmed it.
Clamps down and returns one of the two numbers entered, and nothing else. To get more results, pick inside of pick can happen:
...to get a result of 1, 2, 9, or 12. Lots of possibilities with this, that's for sure.

Here's the pull request.

I think a better implementation would be to allow an infinite amount of parameters and then randomly select one instead of nesting these calls.

The name is misleading, that's not a clamp. (Thread title had me scratching my head, what's a random clamp and how could it be useful?)

It's something that randomly picks one of the numbers given, right? Then why not call it pick?

And what Graf said. pick(x, ...)

Name change: Done. Now Pick.

And I have no idea how I'm going to allow unlimited parameters, truthfully. Mind giving me a hand?

After scanning the initial '(', read in variables until ')' is encountered. Store these in a TArray<FxExpression*> and pass that to FxPick which then processes this further with the casting.

I think 'choose' would make a better name.

The question then comes to mind, what if we have something like pick(1,2,(user_somenumber*82))? Wouldn't that throw it off?

Not if parsed properly. The ParseExpression functions parse an entire expression and store it as an FxExpression object. This object can be anything, ranging from a constant to some complex constructs that requires several levels of recursion to be evaluated.

I'm not sure what to do about resolving with the array though. Any ideas?

Here's my code so far. Again, this is... very alien territory for me so it shouldn't be a surprise if I completely screwed the code up entirely.

Currently, it doesn't work. Access violation occurs in the Resolve call.

Spoiler:

---

thingdef_exp.h

Code: Select all

class FxPick : public FxExpression
{
protected:
	FRandom * rng;
	TArray<FxExpression*> min;

public:

	FxPick(FRandom *, TArray<FxExpression*> mi, const FScriptPosition &pos);
	~FxPick();
	FxExpression *Resolve(FCompileContext&);

	ExpVal EvalExpression(AActor *self);
};

thingdef_expression.cpp

Code: Select all

//==========================================================================
//
//
//
//==========================================================================
FxPick::FxPick(FRandom * r, TArray<FxExpression*> mi, const FScriptPosition &pos)
: FxExpression(pos)
{
	int index = 0;
	int max = mi.Max();
	if (max > 0)
	{
		for (index = 0; index < max; index++)
			min.Push(new FxIntCast(mi[index]));
	}
	else min.Clear();
	rng = r;
	ValueType = VAL_Int;
}

//==========================================================================
//
//
//
//==========================================================================

FxPick::~FxPick()
{
	min.Clear();
}

//==========================================================================
//
//
//
//==========================================================================

FxExpression *FxPick::Resolve(FCompileContext &ctx)
{
	int index = 0;
	CHECKRESOLVED();
	int max = min.Max();
	if (max > 0)
	{
		for (index = 0; index < max; index++)
		{
			RESOLVE(min[index], ctx); //<--Access violation occurs here, not sure how to change it.
			ABORT(min[index]);
		}
		
	}
	return this;
};


//==========================================================================
//
//
//
//==========================================================================

ExpVal FxPick::EvalExpression(AActor *self)
{
	ExpVal val;
	val.Type = VAL_Int;
	int max = min.Max();
	if (max > 0)
	{
		int select = (*rng)(max);
		val.Int = min[select]->EvalExpression(self).GetInt();
	}
	else
	{
		val.Int = (*rng)();
	}
	return val;
}

thingdef_exp.cpp

Code: Select all

	else if (sc.CheckToken(TK_Pick))
	{
		FRandom *rng;
		TArray<FxExpression*> list;
		list.Clear();
		int index = 0;

		if (sc.CheckToken('['))
		{
			sc.MustGetToken(TK_Identifier);
			rng = FRandom::StaticFindRNG(sc.String);
			sc.MustGetToken(']');
		}
		else
		{
			rng = &pr_exrandom;
		}
		sc.MustGetToken('(');

		while (!(sc.CheckToken(')')))
		{
			FxExpression *min = ParseExpressionM(sc, cls);
			list.Push(min);
			if (sc.CheckToken(')'))
				break;
			else
				sc.MustGetToken(',');
		}

		return new FxPick(rng, list, sc);
	}

You try to get the size of your array by calling min.Max() when you should call min.Size(). Max() returns the amount of reserved memory, not the amount of elements in use.

That did the trick! Thanks Graf!

The pull request has been updated.

Added, but I had to plug a memory leak. You forgot to delete the array's contents.

Aw hell. Sorry. Yeah, I still have a lot to learn.

Thanks for that though!

Perhaps a dumb question, but is this supposed to work in decorate? For me, using it in an action function makes ZDoom shut down in the startup, without any error message.

Copy and paste your code, and I'll take a look at it. I only really designed this for DECORATE usage though. Whether it works in ACS or not was something I didn't have in mind for this to begin with. This is mainly because I don't want to make Graf clean up after my abysmal mess again.

If the latter, this is code I used to test it.

Decorate.

I used the latest (Dec 16) x64 build in here.

Actually there is an error message, the window just closed so fast I couldn't see it first: "Call to an unknown function Pick".

For example, this code can cause the error:

Spoiler:

---

Code: Select all

Actor NewPlasmaBall : PlasmaBall replaces PlasmaBall
 {
  +HITMASTER
  States
   {
    Death:
	 TNT1 A 0 A_GiveInventory("Thrust", 1, AAPTR_MASTER)
	 Goto Super::Death
   }
 }


Actor Thrust : CustomInventory
 {
  States
   {
	Pickup:
	 TNT1 A 0 A_ChangeVelocity(0,0,pick(90,900))
	 Stop
   }
 }