[asherkin]

Originally Posted by Spirit_12 Another alternative?

2 arrays.

[Spirit_12]

Well I was hoping you could come up with a better option.

[hmmmmm]

You could go with a StringMap to store all the elements you want and even wrap it in a sexy MethodMap. Here's an example I stole from Headline:

PHP Code:

methodmap PlayerData < StringMap
{
    public PlayerData(int data, int data2, float data3)
    {
        StringMap strMap = new StringMap();

        strMap.SetValue("data", data);
        strMap.SetValue("data2", data2);
        strMap.SetValue("data3", data3);

        return view_as<PlayerData>(strMap);
    }

    property int Data
    {
        public get()
        {
            return view_as<int>(this.GetValue("data"));
        }

        public set(int val)
        {
            this.SetValue("data", val);
        }
    }

    property int Data2
    {
        public get()
        {
            return view_as<int>(this.GetValue("data2"));
        }

        public set(int val)
        {
            this.SetValue("data2", val);
        }
    }

    property float Data3
    {
        public get()
        {
            return view_as<float>(this.GetValue("data3"));
        }

        public set(float val)
        {
            this.SetValue("data3", val);
        }
    }
} 


[sdz]

or you know a keyvalues object

[Spirit_12]

Wouldn’t creating 2 arrays be faster than keyvalues? This function will be called multiple times in a short span, so I’m trying to keep it as light as possible.

[fragnichtnach]

Quiet expensive but that would work as well:
Store everything in a string with a delimiter and split and convert the strings afterwards. All you need is a string without an additional array.

edit: nevermind, just read your last post about keeping it as light as possible :-)

[Bacardi]

I prefer that code can be read easily, not too complex structures... so add more arrays if must

[shanapu]

Originally Posted by asherkin Enumstructs are discouraged and are not available in modern syntax.

boom, that's a punch in the stomach. I had just fallen in love with enums.
What are the reasons you discourage from enums except for the modern syntax part? Is there any performance or 'technical' issues?
Would you recommend to rewrite plugins with intense use of complex enumstructs?

Originally Posted by hmmmmm You could go with a StringMap to store all the elements you want and even wrap it in a sexy MethodMap. Here's an example I stole from Headline: Spoiler PHP Code: methodmap PlayerData < StringMap {     public PlayerData(int data, int data2, float data3)     {         StringMap strMap = new StringMap();         strMap.SetValue("data", data);         strMap.SetValue("data2", data2);         strMap.SetValue("data3", data3);         return view_as<PlayerData>(strMap);     }     property int Data     {         public get()         {             return view_as<int>(this.GetValue("data"));         }         public set(int val)         {             this.SetValue("data", val);         }     }     property int Data2     {         public get()         {             return view_as<int>(this.GetValue("data2"));         }         public set(int val)         {             this.SetValue("data2", val);         }     }     property float Data3     {         public get()         {             return view_as<float>(this.GetValue("data3"));         }         public set(float val)         {             this.SetValue("data3", val);         }     } }

I used sourcemods methodmap since introduction on may parts, but never wrote my own mm before.
It needed some time to get into mm, but now I understand why you call them sexy and why there was such a "hype" with the introduction.
Seems I found a new love.

But there is an issue with your (& headlines) example or do I still not understand the whole thing?
If I'm correct this part(s) won't work:

PHP Code:

        public get()
        {
            return view_as<int>(this.GetValue("data"));
        } 


even with view_as<int> GetValue returns a bool. And it has 2 parameter, key & value.
So this part should be:

PHP Code:

        public get()
        {
            int val;
            this.GetValue("data", val);
            return val;
        } 


complete:

PHP Code:

methodmap PlayerData < StringMap
{
    public PlayerData(int data, int data2, float data3)
    {
        StringMap strMap = new StringMap();

        strMap.SetValue("data", data);
        strMap.SetValue("data2", data2);
        strMap.SetValue("data3", data3);

        return view_as<PlayerData>(strMap);
    }

    property int Data
    {
        public get()
        {
            int val;
            this.GetValue("data", val);
            return val;
        }

        public set(int val)
        {
            this.SetValue("data", val);
        }
    }

    property int Data2
    {
        public get()
        {
            int val;
            this.GetValue("data2", val);
            return val;
        }

        public set(int val)
        {
            this.SetValue("data2", val);
        }
    }

    property float Data3
    {
        public get()
        {
            float val;
            this.GetValue("data3", val);
            return val;
        }

        public set(float val)
        {
            this.SetValue("data3", val);
        }
    }
} 


right?!?

[Neuro Toxin]

Using Dynamic's class builder....

https://console.aus-tg.com/index.php...tedynamicclass

#if defined _dynamic_class_myclass_
  #endinput
#endif
#define _dynamic_class_myclass_

methodmap MyClass < Dynamic
{
	public MyClass()
	{
		// First we make a new dymanic object
		Dynamic myclass = Dynamic(64, 0);

		// Next we will define all the members
		// -> We do this to force the offsets to always be in the same location
		//    over multiple instances of the same class.
		myclass.SetInt("Client", 0);
		myclass.SetBool("BoolValue", false);
		myclass.SetString("StringValue", "", 64);
		return view_as<MyClass>(myclass);
	}

	// Note that I use static offsets to access members.
	// -> This improves performance by caching member offsets
	// -> This is why we force the members in during the contructor
	// -> Failure to force members in the constructor will cause corruption

	property int Client
	{
		public get()
		{
			static DynamicOffset offset = INVALID_DYNAMIC_OFFSET;
			if (offset == INVALID_DYNAMIC_OFFSET)
			{
				offset = this.GetMemberOffset("Client");
				if (offset == INVALID_DYNAMIC_OFFSET)
					SetFailState("A serious error occured in Dynamic methodmap @ MyClass.Client!");
			}
			return this.GetIntByOffset(offset);
		}
		public set(int value)
		{
			static DynamicOffset offset = INVALID_DYNAMIC_OFFSET;
			if (offset == INVALID_DYNAMIC_OFFSET)
			{
				offset = this.GetMemberOffset("Client");
				if (offset == INVALID_DYNAMIC_OFFSET)
				{
					offset = this.SetInt("Client", value);
					return;
				}
			}
			this.SetIntByOffset(offset, value);
		}
	}

	property bool BoolValue
	{
		public get()
		{
			static DynamicOffset offset = INVALID_DYNAMIC_OFFSET;
			if (offset == INVALID_DYNAMIC_OFFSET)
			{
				offset = this.GetMemberOffset("BoolValue");
				if (offset == INVALID_DYNAMIC_OFFSET)
					SetFailState("A serious error occured in Dynamic methodmap @ MyClass.BoolValue!");
			}
			return this.GetBoolByOffset(offset);
		}
		public set(bool value)
		{
			static DynamicOffset offset = INVALID_DYNAMIC_OFFSET;
			if (offset == INVALID_DYNAMIC_OFFSET)
			{
				offset = this.GetMemberOffset("BoolValue");
				if (offset == INVALID_DYNAMIC_OFFSET)
				{
					offset = this.SetBool("BoolValue", value);
					return;
				}
			}
			this.SetBoolByOffset(offset, value);
		}
	}

	public bool GetStringValue(char[] buffer, int length)
	{
		static DynamicOffset offset = INVALID_DYNAMIC_OFFSET;
		if (offset == INVALID_DYNAMIC_OFFSET)
		{
			offset = this.GetMemberOffset("StringValue");
			if (offset == INVALID_DYNAMIC_OFFSET)
				SetFailState("A serious error occured in Dynamic methodmap @ MyClass.StringValue!");
		}
		this.GetStringByOffset(offset, buffer, length);
		return true;
	}

	public void SetStringValue(const char[] buffer)
	{
		static DynamicOffset offset = INVALID_DYNAMIC_OFFSET;
		if (offset == INVALID_DYNAMIC_OFFSET)
		{
			offset = this.GetMemberOffset("StringValue");
			if (offset == INVALID_DYNAMIC_OFFSET)
			{
				offset = this.SetString("StringValue", buffer);
				return;
			}
		}
		this.SetStringByOffset(offset, buffer);
	}
}

[hmmmmm]

Originally Posted by shanapu right?!?

You are right, thanks for correcting the mistake.