mirror of
https://github.com/azerothcore/mod-ale
synced 2025-11-29 15:38:17 +08:00
9d9e72e598
Method documentation should be completed. Only thing left now is polishing up (fixing typos, update wording, add enumerator data to method documentation that doesn't have it, etc).. Cleaned whitespaces Corrected/Fixed up some comments Removed all known documented method comments in LuaFunctions.cpp. Commented out methods are now marked as undocumented until they are uncommented & documented in their respective header files. Removed 'Getter, Setter, Boolean, Other' comments in method files Documented VehicleMethods, the rest of PlayerMethods, UnitMethods, CreatureMethods and GuildMethods. Refer to #101 for more information
457 lines
13 KiB
C++
457 lines
13 KiB
C++
/*
|
|
* Copyright (C) 2010 - 2015 Eluna Lua Engine <http://emudevs.com/>
|
|
* This program is free software licensed under GPL version 3
|
|
* Please see the included DOCS/LICENSE.md for more information
|
|
*/
|
|
|
|
#ifndef OBJECTMETHODS_H
|
|
#define OBJECTMETHODS_H
|
|
|
|
/***
|
|
* A basic game object (either an [Item] or a [WorldObject]).
|
|
*
|
|
* Objects in MaNGOS/Trinity are stored an a giant block of "values".
|
|
* Subclasses of Object, like [WorldObject], extend the block with more data specific to that subclass.
|
|
* Further subclasses, like [Player], extend it even further.
|
|
*
|
|
* A detailed map of all the fields in this data block can be found in the UpdateFields.h file of your emulator
|
|
* (it varies depending on the expansion supported).
|
|
*
|
|
* The GetValue methods in this class (e.g. [Object:GetInt32Value]) provide low-level access to the data block.
|
|
* Other methods, like [Object:HasFlag] and [Object:GetScale], merely wrap the GetValue methods and provide a simpler interface.
|
|
*
|
|
* Inherits all methods from: none
|
|
*/
|
|
namespace LuaObject
|
|
{
|
|
/**
|
|
* Returns `true` if the specified flag is set, otherwise `false`.
|
|
*
|
|
* @param uint16 index : the index of the flags data in the [Object]
|
|
* @param uint32 flag : the flag to check for in the flags data
|
|
* @return bool hasFlag
|
|
*/
|
|
int HasFlag(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint32 flag = Eluna::CHECKVAL<uint32>(L, 3);
|
|
|
|
Eluna::Push(L, obj->HasFlag(index, flag));
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the [Object] has been added to its [Map], otherwise `false`.
|
|
*
|
|
* @return bool inWorld
|
|
*/
|
|
int IsInWorld(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->IsInWorld());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the data at the specified index, casted to a signed 32-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @return int32 value
|
|
*/
|
|
int GetInt32Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
Eluna::Push(L, obj->GetInt32Value(index));
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the data at the specified index, casted to a unsigned 32-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @return uint32 value
|
|
*/
|
|
int GetUInt32Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
Eluna::Push(L, obj->GetUInt32Value(index));
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the data at the specified index, casted to a single-precision floating point value.
|
|
*
|
|
* @param uint16 index
|
|
* @return float value
|
|
*/
|
|
int GetFloatValue(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
Eluna::Push(L, obj->GetFloatValue(index));
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the data at the specified index and offset, casted to an unsigned 8-bit integer.
|
|
*
|
|
* E.g. if you want the second byte at index 10, you would pass in 1 as the offset.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint8 offset : should be 0, 1, 2, or 3
|
|
* @return uint8 value
|
|
*/
|
|
int GetByteValue(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint8 offset = Eluna::CHECKVAL<uint8>(L, 3);
|
|
Eluna::Push(L, obj->GetByteValue(index, offset));
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the data at the specified index and offset, casted to a signed 16-bit integer.
|
|
*
|
|
* E.g. if you want the second half-word at index 10, you would pass in 1 as the offset.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint8 offset : should be 0 or 1
|
|
* @return uint16 value
|
|
*/
|
|
int GetUInt16Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint8 offset = Eluna::CHECKVAL<uint8>(L, 3);
|
|
Eluna::Push(L, obj->GetUInt16Value(index, offset));
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the scale/size of the [Object].
|
|
*
|
|
* This affects the size of a [WorldObject] in-game, but [Item]s don't have a "scale".
|
|
*
|
|
* @return float scale
|
|
*/
|
|
int GetScale(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->GetObjectScale());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the entry of the [Object].
|
|
*
|
|
* [Player]s do not have an "entry".
|
|
*
|
|
* @return uint32 entry
|
|
*/
|
|
int GetEntry(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->GetEntry());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the GUID of the [Object].
|
|
*
|
|
* GUID is an unique identifier for the object.
|
|
*
|
|
* However on MaNGOS and cMangos creatures and gameobjects inside different maps can share
|
|
* the same GUID but not on the same map.
|
|
*
|
|
* On TrinityCore this value is unique across all maps
|
|
*
|
|
* @return uint64 guid
|
|
*/
|
|
int GetGUID(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->GET_GUID());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the low-part of the [Object]'s GUID.
|
|
*
|
|
* On TrinityCore all low GUIDs are different for all objects of the same type.
|
|
* For example creatures in instances are assigned new GUIDs when the Map is created.
|
|
*
|
|
* On MaNGOS and cMaNGOS low GUIDs are unique only on the same map.
|
|
* For example creatures in instances use the same low GUID assigned for that spawn in the database.
|
|
* This is why to identify a creature you have to know the instanceId and low GUID. See [Map:GetIntstanceId]
|
|
*
|
|
* @return uint32 guidLow
|
|
*/
|
|
int GetGUIDLow(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->GetGUIDLow());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the TypeId of the [Object].
|
|
*
|
|
* enum TypeID
|
|
* {
|
|
* TYPEID_OBJECT = 0,
|
|
* TYPEID_ITEM = 1,
|
|
* TYPEID_CONTAINER = 2,
|
|
* TYPEID_UNIT = 3,
|
|
* TYPEID_PLAYER = 4,
|
|
* TYPEID_GAMEOBJECT = 5,
|
|
* TYPEID_DYNAMICOBJECT = 6,
|
|
* TYPEID_CORPSE = 7
|
|
* };
|
|
*
|
|
* @return uint8 typeID
|
|
*/
|
|
int GetTypeId(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->GetTypeId());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the data at the specified index, casted to an unsigned 64-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @return uint64 value
|
|
*/
|
|
int GetUInt64Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
obj->GetUInt64Value(index);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the specified flag in the data value at the specified index.
|
|
*
|
|
* If the flag was already set, it remains set.
|
|
*
|
|
* To remove a flag, use [Object:RemoveFlag].
|
|
*
|
|
* @param uint16 index
|
|
* @param uint32 value
|
|
*/
|
|
int SetFlag(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint32 flag = Eluna::CHECKVAL<uint32>(L, 3);
|
|
|
|
obj->SetFlag(index, flag);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index to the given value, converted to a signed 32-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @param int32 value
|
|
*/
|
|
int SetInt32Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
int32 value = Eluna::CHECKVAL<int32>(L, 3);
|
|
obj->SetInt32Value(index, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index to the given value, converted to an unsigned 32-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint32 value
|
|
*/
|
|
int SetUInt32Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint32 value = Eluna::CHECKVAL<uint32>(L, 3);
|
|
obj->SetUInt32Value(index, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index to the given value, converted to an unsigned 32-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint32 value
|
|
*/
|
|
int UpdateUInt32Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint32 value = Eluna::CHECKVAL<uint32>(L, 3);
|
|
obj->UpdateUInt32Value(index, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index to the given value, converted to a single-precision floating point value.
|
|
*
|
|
* @param uint16 index
|
|
* @param float value
|
|
*/
|
|
int SetFloatValue(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
float value = Eluna::CHECKVAL<float>(L, 3);
|
|
|
|
obj->SetFloatValue(index, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index and offset to the given value, converted to an unsigned 8-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint8 offset : should be 0, 1, 2, or 3
|
|
* @param uint8 value
|
|
*/
|
|
int SetByteValue(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint8 offset = Eluna::CHECKVAL<uint8>(L, 3);
|
|
uint8 value = Eluna::CHECKVAL<uint8>(L, 4);
|
|
obj->SetByteValue(index, offset, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index to the given value, converted to an unsigned 16-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint8 offset : should be 0 or 1
|
|
* @param uint16 value
|
|
*/
|
|
int SetUInt16Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint8 offset = Eluna::CHECKVAL<uint8>(L, 3);
|
|
uint16 value = Eluna::CHECKVAL<uint16>(L, 4);
|
|
obj->SetUInt16Value(index, offset, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index to the given value, converted to a signed 16-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint8 offset : should be 0 or 1
|
|
* @param int16 value
|
|
*/
|
|
int SetInt16Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint8 offset = Eluna::CHECKVAL<uint8>(L, 3);
|
|
int16 value = Eluna::CHECKVAL<int16>(L, 4);
|
|
obj->SetInt16Value(index, offset, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the [Object]'s scale/size to the given value.
|
|
*
|
|
* @param float scale
|
|
*/
|
|
int SetScale(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
float size = Eluna::CHECKVAL<float>(L, 2);
|
|
|
|
obj->SetObjectScale(size);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the data at the specified index to the given value, converted to an unsigned 64-bit integer.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint64 value
|
|
*/
|
|
int SetUInt64Value(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint64 value = Eluna::CHECKVAL<uint64>(L, 3);
|
|
obj->SetUInt64Value(index, value);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Removes a flag from the value at the specified index.
|
|
*
|
|
* @param uint16 index
|
|
* @param uint32 flag
|
|
*/
|
|
int RemoveFlag(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
uint16 index = Eluna::CHECKVAL<uint16>(L, 2);
|
|
uint32 flag = Eluna::CHECKVAL<uint32>(L, 3);
|
|
|
|
obj->RemoveFlag(index, flag);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Attempts to convert the [Object] to a [Corpse].
|
|
*
|
|
* If the [Object] is not a [Corpse], returns `nil`.
|
|
*
|
|
* @return [Corpse] corpse : the [Object] as a [Corpse], or `nil`
|
|
*/
|
|
int ToCorpse(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->ToCorpse());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Attempts to convert the [Object] to a [GameObject].
|
|
*
|
|
* If the [Object] is not a [GameObject], returns `nil`.
|
|
*
|
|
* @return [GameObject] gameObject : the [Object] as a [GameObject], or `nil`
|
|
*/
|
|
int ToGameObject(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->ToGameObject());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Attempts to convert the [Object] to a [Unit].
|
|
*
|
|
* If the [Object] is not a [Unit], returns `nil`.
|
|
*
|
|
* @return [Unit] unit : the [Object] as a [Unit], or `nil`
|
|
*/
|
|
int ToUnit(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->ToUnit());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Attempts to convert the [Object] to a [Creature].
|
|
*
|
|
* If the [Object] is not a [Creature], returns `nil`.
|
|
*
|
|
* @return [Creature] creature : the [Object] as a [Creature], or `nil`
|
|
*/
|
|
int ToCreature(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->ToCreature());
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Attempts to convert the [Object] to a [Player].
|
|
*
|
|
* If the [Object] is not a [Player], returns `nil`.
|
|
*
|
|
* @return [Player] player : the [Object] as a [Player], or `nil`
|
|
*/
|
|
int ToPlayer(Eluna* /*E*/, lua_State* L, Object* obj)
|
|
{
|
|
Eluna::Push(L, obj->ToPlayer());
|
|
return 1;
|
|
}
|
|
};
|
|
#endif
|