Ares Developer Scrapbook - Revision history

MarkJFox: 9 revisions imported

2025-03-31T19:37:04Z

9 revisions imported

← Older revision	Revision as of 21:37, 31 March 2025
(No difference)

en>DCoder: Remark about stack alignment

2011-01-10T19:33:08Z

Remark about stack alignment

← Older revision		Revision as of 21:33, 10 January 2011
Line 269:		Line 269:

	This uses the same methods to read values from the INI files. Notice that this uses a pointer-to-global-flag - if we were to instantiate the template using the actual value, we would get the value of that flag at that moment in time without any way to update it later! That value will most likely be NULL, or the value from the global Rulesmd.ini, as these objects are created very early in the loading process. By instantiating the template with a pointer-to-flag instead, we retain the ability to read that flag's value at any future point in time, as long as the RulesClass::Instance itself doesn't get destroyed (which will happen after the match, but our objects should not need to access the value at that point, and they'll be destroyed not long after that, so there's no problem there).		This uses the same methods to read values from the INI files. Notice that this uses a pointer-to-global-flag - if we were to instantiate the template using the actual value, we would get the value of that flag at that moment in time without any way to update it later! That value will most likely be NULL, or the value from the global Rulesmd.ini, as these objects are created very early in the loading process. By instantiating the template with a pointer-to-flag instead, we retain the ability to read that flag's value at any future point in time, as long as the RulesClass::Instance itself doesn't get destroyed (which will happen after the match, but our objects should not need to access the value at that point, and they'll be destroyed not long after that, so there's no problem there).

			== Caution ==
			When you're extracting data from the stack, make sure that the function isn't doing special stack alignment (<tt>and esp, not 7</tt> is a common idiom to align the stack to 8 bytes, which is required when the function uses local double-precision variables). If it is, you cannot extract data using ESP offsets and must use EBP offsets instead.

	[[Category:Ares]]		[[Category:Ares]]

en>DCoder: Adding another landmine to watch out for.

2010-08-30T17:41:55Z

Adding another landmine to watch out for.

← Older revision		Revision as of 19:41, 30 August 2010
Line 241:		Line 241:

	Since this creates a template rather than an object of type {{Tt\|T}}, the compiler will possibly have difficulty figuring out what you're trying to do. If you're having problems, a member function {{Tt\|Get()}} is provided to get the actual T value stored in the template, and a {{Tt\|GetEx()}} is provided to get a pointer to that T value.		Since this creates a template rather than an object of type {{Tt\|T}}, the compiler will possibly have difficulty figuring out what you're trying to do. If you're having problems, a member function {{Tt\|Get()}} is provided to get the actual T value stored in the template, and a {{Tt\|GetEx()}} is provided to get a pointer to that T value.

			=== Boolean context ===
			If you want to use the value of a non-boolean (numeric) Valueable in a boolean context, use:
			if(!!pData->Property)
			or
			if(pData->Property != 0)
			instead of
			if(pData->Property)
			. The last version usually results in unexpected results thanks to C++ automagic rules.

	=== Template Customizable<T> ===		=== Template Customizable<T> ===

en>DCoder: Added Valueable and Customizable

2010-08-17T18:44:44Z

Added Valueable and Customizable

@@ Line 4: / Line 4: @@
 Using the <code>WhatAmI()</code> member function. <code>WhatAmI()</code> returns a numeric value that can be compared to a multitude of predefined constants which tell you exactly what kind of object you're dealing with (more technically, it returns an eAbstractType, which is a typedef of an int).<br>
 <code>WhatAmI()</code> is a pure virtual function of AbstractClass, the highest level of YR's class hierarchy; as such, it should exist on all objects you could possibly encounter.
 ====Example====
@@ Line 196: / Line 198: @@
 :''from BulletExt::ExtData::DamageOccupants()''
   BulletClass* TheBullet = this->AttachedToObject;
 [[Category:Ares]]

en>Nighthawk200: Why doesn't this have a category?

2010-04-18T14:38:31Z

Why doesn't this have a category?

← Older revision		Revision as of 16:38, 18 April 2010
Line 196:		Line 196:
	:''from BulletExt::ExtData::DamageOccupants()''		:''from BulletExt::ExtData::DamageOccupants()''
	BulletClass* TheBullet = this->AttachedToObject;		BulletClass* TheBullet = this->AttachedToObject;

			[[Category:Ares]]

en>DCoder: Updating game_cast

2009-12-27T09:06:47Z

Updating game_cast

← Older revision		Revision as of 11:06, 27 December 2009
Line 2:		Line 2:

	===How do I best figure out stuff like "Is this object a BuildingType?"===		===How do I best figure out stuff like "Is this object a BuildingType?"===
	Using the <code>WhatAmI()</code> member. <code>WhatAmI()</code> returns a numeric value that can be compared to a multitude of predefined constants which tell you exactly what kind of object you're dealing with (more technically, it returns an eAbstractType, which is a typedef of an int).<br>		Using the <code>WhatAmI()</code> member function. <code>WhatAmI()</code> returns a numeric value that can be compared to a multitude of predefined constants which tell you exactly what kind of object you're dealing with (more technically, it returns an eAbstractType, which is a typedef of an int).<br>
	<code>WhatAmI()</code> is a pure virtual function of AbstractClass, the highest level of YR's class hierarchy; as such, it should exist on all objects you could possibly encounter.		<code>WhatAmI()</code> is a pure virtual function of AbstractClass, the highest level of YR's class hierarchy; as such, it should exist on all objects you could possibly encounter.

Line 154:		Line 154:

	===I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)Class pointer?===		===I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)Class pointer?===
	If you need to get a final class like Building or Aircraft, use the {{Tt\|~~game_cast~~}} template which works similarly to {{Tt\|dynamic_cast}}:		If you need to get a final class like Building or Aircraft, use the {{Tt\|specific_cast}} template which works similarly to {{Tt\|dynamic_cast}}:

	if(BuildingClass * pBuilding = ~~game_cast~~<BuildingClass *>(ptr)) {		if(BuildingClass * pBuilding = specific_cast<BuildingClass *>(ptr)) {
	''// if we got here, that means {{tt\|ptr}} was a base pointer pointing to a BuildingClass *.		''// if we got here, that means {{tt\|ptr}} was a base pointer pointing to a BuildingClass *.
	}		}

	If you want to upcast a generic pointer to another generic pointer (i.e. {{Tt\|ObjectClass }} to {{Tt\|TechnoClass }}), you ~~still need~~ {{tt\|~~reinterpret_cast~~}} ~~and manual check~~:		If you want to upcast a generic pointer to another generic pointer (i.e. {{Tt\|ObjectClass }} to {{Tt\|TechnoClass }}), you should use {{tt\|generic_cast}} in the same vein:
	if(~~ABS_IS_TECHNO(ptr)) {~~		if(TechnoClass ptr = generic_cast<TechnoClass >(ptr)) {
	TechnoClass ptr = ~~reinterpret_cast~~<TechnoClass >(ptr);		''// if we got here, that means even though {{tt\|ptr}} was an {{Tt\|ObjectClass }}, it actually points to a {{Tt\|TechnoClass }} descendant.
	}		}
	~~ABS_IS* macros are defined in yrpp/Helpers/Macro.h , the possible variants are ABS_IS_OBJECT, ABS_IS_TECHNO, ABS_IS_FOOT, corresponding to the~~ three non-abstract generic pointer types {{Tt\|ObjectClass }}, {{Tt\|TechnoClass }} and {{Tt\|FootClass *}}.		The three non-abstract generic pointer types are {{Tt\|ObjectClass }}, {{Tt\|TechnoClass }} and {{Tt\|FootClass *}} - you can convert from right to left directly, and you need this template to convert from left to right.

	~~This will also be customized in the future~~.

	'''Note:''' The intelligent casts like dynamic won't work, as they rely on the RTTI which is likely to be different between the game's and Ares's objects.		'''Note:''' The intelligent casts like dynamic won't work, as they rely on the RTTI which is likely to be different between the game's and Ares's objects.

en>DCoder: /* I have a pointer to a given game object/class - how do I get its type class? */ -- specific case

2009-12-18T20:05:25Z

I have a pointer to a given game object/class - how do I get its type class?: -- specific case

← Older revision		Revision as of 22:05, 18 December 2009
Line 143:		Line 143:
	==Hierarchy Traversal==		==Hierarchy Traversal==
	===I have a pointer to a given game object/class - how do I get its type class?===		===I have a pointer to a given game object/class - how do I get its type class?===
			==== Generic Type Data ====
			If you are looking for a pointer to a generic class like ObjectTypeClass * or TechnoTypeClass *, use the following:
	{{tt\|ptr->GetType()}} returns an {{tt\|ObjectTypeClass }} to the type data		{{tt\|ptr->GetType()}} returns an {{tt\|ObjectTypeClass }} to the type data
	On TechnoClass and its derivates, {{tt\|ptr->GetTechnoType()}} returns a {{tt\|TechnoTypeClass }} to the same type data		On TechnoClass and its derivates, {{tt\|ptr->GetTechnoType()}} returns a {{tt\|TechnoTypeClass }} to the same type data
Line 148:		Line 150:
	reinterpret_cast<TargetTypeClass *>(ptr->GetTechnoType())		reinterpret_cast<TargetTypeClass *>(ptr->GetTechnoType())
	and that's it.		and that's it.
			==== Specific Type Data ====
			If you have a specific class pointer, say, a BuildingClass , you can just use ->Type to access its type data (BuildingTypeClass ). All four TechnoClass derivates have this member with the appropriate type.

	===I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)Class pointer?===		===I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)Class pointer?===

en>DCoder: /* I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building|Infantry|Vehicle|Aircraft)Class pointer? */ - game_cast info

2009-12-15T05:53:59Z

I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building|Infantry|Vehicle|Aircraft)Class pointer?: - game_cast info

← Older revision		Revision as of 07:53, 15 December 2009
Line 150:		Line 150:

	===I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)Class pointer?===		===I have a Techno-/ObjectClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)Class pointer?===
	~~Sometime in the future~~, ~~there will be an automagic way to do this. In~~ the ~~meantime, you have~~ to ~~do it the following way~~:		If you need to get a final class like Building or Aircraft, use the {{Tt\|game_cast}} template which works similarly to {{Tt\|dynamic_cast}}:

	~~Use <code>WhatAmI()</code> as you [[#{{anchorencode:How do I best figure out stuff like "Is this object a BuildingType?"}}\|learned above]] to safeguard a cast to the correct type.~~		if(BuildingClass * pBuilding = game_cast<BuildingClass *>(ptr)) {
	if(~~ptr->WhatAmI() == abs_Building) {~~		''// if we got here, that means {{tt\|ptr}} was a base pointer pointing to a BuildingClass *.
	BuildingClass * pBuilding = ~~reinterpret_cast~~<BuildingClass *>(ptr);
	}		}
	/* the intelligent casts like dynamic won't work,
	as they rely on the RTTI which is likely to be different between the game's and Ares's objects.		If you want to upcast a generic pointer to another generic pointer (i.e. {{Tt\|ObjectClass }} to {{Tt\|TechnoClass }}), you still need {{tt\|reinterpret_cast}} and manual check:
	Additionally, do '''not''' just (BuildingClass *)ptr instead. Seriously.		if(ABS_IS_TECHNO(ptr)) {
	*/		TechnoClass ptr = reinterpret_cast<TechnoClass >(ptr);
			}
			ABS_IS* macros are defined in yrpp/Helpers/Macro.h , the possible variants are ABS_IS_OBJECT, ABS_IS_TECHNO, ABS_IS_FOOT, corresponding to the three non-abstract generic pointer types {{Tt\|ObjectClass }}, {{Tt\|TechnoClass }} and {{Tt\|FootClass *}}.

			This will also be customized in the future.

			'''Note:''' The intelligent casts like dynamic won't work, as they rely on the RTTI which is likely to be different between the game's and Ares's objects.
			Additionally, do '''not''' just (BuildingClass *)ptr instead. Seriously.

	===I have a Techno-/ObjectTypeClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)TypeClass pointer?===		===I have a Techno-/ObjectTypeClass-derived pointer, how do I get the exact (Building\|Infantry\|Vehicle\|Aircraft)TypeClass pointer?===

en>Renegade: Massively rewrote this to make it easier to read and understand; D, please check if everything is still correct.

2009-12-14T22:34:51Z

Massively rewrote this to make it easier to read and understand; D, please check if everything is still correct.

Show changes

en>DCoder: Creating

2009-12-02T19:34:51Z

Creating

New page

;When I get a random TechnoClass- or ObjectClass-derived class's pointer, how do I find out its exact (Building|Infantry|Vehicle|Aircraft)Class?
;When I get a random TechnoTypeClass- or ObjectTypeClass-derived class's pointer, how do I find out its exact (Building|Infantry|Vehicle|Aircraft)TypeClass?
::There is no magic mechanism to upcast the pointer properly (for now, one will be provided soon).
::{{tt|ptr->WhatAmI()}} returns an enum value corresponding to this object's class. Refer to eAbstractType and its defines in {{tt|GeneralDefinitions.h}}.
::So the resulting code could look like this:
if(ptr->WhatAmI() == abs_Building) {
BuildingClass * pBuilding = reinterpret_cast<BuildingClass *>(ptr);
}
/* the intelligent casts like dynamic won't work,
as they rely on the RTTI which is likely to be different between the game's and Ares's objects.
Additionally, do '''not''' just (BuildingClass *)ptr instead. Seriously.
*/

;How do I get that class's extension?
::Unlike the game's classes which are in a hierarchy, Ares's extension classes are all siblings. That means that a {{tt|BuildingExt}} doesn't contain {{tt|TechnoExt}} even though it seems like it should.
::So the answer depends on which extension class you need. If you need data from {{tt|TechnoTypeExt}}, you call {{Tt|TechnoTypeExt::ExtMap.Find(ptr)}} and receive a {{tt|TechnoTypeExt *}} associated with this object.
{{tt|Find}} might return NULL if there is no data associated with this object, but that shouldn't happen normally, all objects which can have extension data are attached to the ExtMap when they are created/destroyed. So you don't need to check for NULL when you fetch it.

;How do I best figure out stuff like "Is this object a BuildingType?"
::<tt>ptr->WhatAmI() == abs_BuildingType</tt>

;How do I best figure out stuff like "Is this object of this particular BuildingType?" (e.g. "Is this a GADEPT?")
::I'm assuming you are doing the smart thing and taking GADEPT from the INI, and not hardcoding it? Then this approach should work best:
// For example's sake, let's say the INI looks like this:
// [MySection]
// MyValue=GADEPT

// when parsing ini
void FooExt::ExtData::LoadFromINIFile(FooClass *pThis, CCINIClass *pINI) {
// note that the following read is performed from the owning object's INI section - the same way works in Rules, where an object called MTNK has a section [MTNK]
// if the value set on this flag is more than 0 characters long (iow, you set it to a non-whitespace value
if(pINI->ReadString(pThis->ID, "SomeValue", "", Ares::readBuffer, Ares::readLength)) {
// ::Find iterates the currently declared BuildingTypes array and returns pointer to the one with the ID given as argument
this->SomeValue = BuildingTypeClass::Find(Ares::readBuffer);
}
}

// and when you need to check, you do this:
// assuming pSomething is the pointer to FooExt::ExtData, iow what was called {{tt|this}} in the reader function
// and pTarget is the building whose type you want to check against SomeValue

if(pTarget->Type == pSomething->SomeValue) {
// pTarget is a building of the same type as you specified SomeValue= to be
}

;If I have a UnitClass *, how do I get its UnitTypeClass *?
::{{tt|ptr->GetType()}} returns an {{tt|ObjectTypeClass *}} to the type data
::and {{tt|ptr->GetTechnoType()}} returns a {{tt|TechnoTypeClass *}} to the same type data (naturally only valid on {{tt|TechnoClass}} and its derivates)
::and both of them are actually pointers to the final derived type of the object, just downcasted (this is a C++ covariant return type limitation). So if you know the exact type you need and are sure that the object's type is appropriate, you can use
::::{{tt|reinterpret_cast<TargetTypeClass *>(ptr->GetTechnoType())}}.