diff --git a/mta-mono/mta-mono.vcxproj b/mta-mono/mta-mono.vcxproj index 821c827..68b9851 100644 --- a/mta-mono/mta-mono.vcxproj +++ b/mta-mono/mta-mono.vcxproj @@ -13,6 +13,24 @@ + + + + + + + + + + + + + + + + + + diff --git a/mta-mono/src/CMonoClass.cpp b/mta-mono/src/CMonoClass.cpp index 0881724..13263d7 100644 --- a/mta-mono/src/CMonoClass.cpp +++ b/mta-mono/src/CMonoClass.cpp @@ -26,11 +26,26 @@ CMonoObject* CMonoClass::New( MonoDomain* pMonoDomain ) return new CMonoObject( pObject ); } +CMonoObject* CMonoClass::New( MonoDomain* pMonoDomain, SColor& pColor ) +{ + void *args[] = { &pColor.R, &pColor.G, &pColor.B, &pColor.A }; + + return this->New( pMonoDomain, args, 4 ); +} + + +CMonoObject* CMonoClass::New( MonoDomain* pMonoDomain, Vector2& vecVector ) +{ + void *args[] = { &vecVector.fX, &vecVector.fY }; + + return this->New( pMonoDomain, args, 2 ); +} + CMonoObject* CMonoClass::New( MonoDomain* pMonoDomain, Vector3& vecVector ) { void *args[] = { &vecVector.fX, &vecVector.fY, &vecVector.fZ }; - return this->New( mono_domain_get(), args, 3 ); + return this->New( pMonoDomain, args, 3 ); } CMonoObject* CMonoClass::New( MonoDomain* pMonoDomain, void** args, int argc ) @@ -44,7 +59,7 @@ CMonoObject* CMonoClass::New( MonoDomain* pMonoDomain, void** args, int argc ) return NULL; } - MonoMethod* pMonoMethod = mono_class_get_method_from_name( this->m_pMonoClass, ".ctor", argc ); + MonoMethod* pMonoMethod = this->GetMethod( ".ctor", argc ); if( !pMonoMethod ) { diff --git a/mta-mono/src/CMonoClass.h b/mta-mono/src/CMonoClass.h index 1ca2361..e953141 100644 --- a/mta-mono/src/CMonoClass.h +++ b/mta-mono/src/CMonoClass.h @@ -18,6 +18,8 @@ public: ~CMonoClass(); CMonoObject* New( MonoDomain* pMonoDomain ); + CMonoObject* New( MonoDomain* pMonoDomain, SColor& pColor ); + CMonoObject* New( MonoDomain* pMonoDomain, Vector2& vecVector ); CMonoObject* New( MonoDomain* pMonoDomain, Vector3& vecVector ); CMonoObject* New( MonoDomain* pMonoDomain, void** args, int argc ); diff --git a/mta-mono/src/CMonoFunctions.cpp b/mta-mono/src/CMonoFunctions.cpp index 64fcd8b..d8a2cb2 100644 --- a/mta-mono/src/CMonoFunctions.cpp +++ b/mta-mono/src/CMonoFunctions.cpp @@ -11,17 +11,6 @@ *********************************************************/ #include "CMonoFunctions.h" -#include "CMonoObject.h" - -#include "CResource.h" -#include "CResourceManager.h" - -extern ILuaModuleManager10 *g_pModuleManager; -extern CResourceManager *g_pResourceManager; - -#define RESOURCE g_pResourceManager->GetFromList( mono_domain_get() ) - -#define MONO_DECLARE(a,b) mono_add_internal_call("MultiTheftAuto.Native."#a"::"#b,CMonoFunctions::a::b ); void CMonoFunctions::AddInternals( void ) { @@ -29,8 +18,15 @@ void CMonoFunctions::AddInternals( void ) mono_add_internal_call( "MultiTheftAuto.Debug::Info", CMonoFunctions::Debug::Info ); mono_add_internal_call( "MultiTheftAuto.Debug::Error", CMonoFunctions::Debug::Error ); - mono_add_internal_call( "MultiTheftAuto.Native.Config::Get", CMonoFunctions::Config::Get ); - mono_add_internal_call( "MultiTheftAuto.Native.Config::Set", CMonoFunctions::Config::Set ); + MONO_DECLARE( Config, Get ); + MONO_DECLARE( Config, Set ); + + MONO_DECLARE( Server, GetMaxPlayers ); + MONO_DECLARE( Server, SetMaxPlayers ); + MONO_DECLARE( Server, OutputChatBox ); + MONO_DECLARE( Server, OutputConsole ); + MONO_DECLARE( Server, SetPassword ); + MONO_DECLARE( Server, GetVersion ); // Element create/destroy MONO_DECLARE( Element, Create ); @@ -38,6 +34,7 @@ void CMonoFunctions::AddInternals( void ) MONO_DECLARE( Element, Clone ); // Element get funcs + MONO_DECLARE( Element, GetByType ); MONO_DECLARE( Element, IsElement ); MONO_DECLARE( Element, GetType ); MONO_DECLARE( Element, GetByID ); @@ -94,8 +91,508 @@ void CMonoFunctions::AddInternals( void ) MONO_DECLARE( Element, SetFrozen ); MONO_DECLARE( Element, SetLowLod ); - // Vehicle create/destroy functions - MONO_DECLARE( Vehicle, Create ); + // Player get functions + MONO_DECLARE( Player, GetCount ); + MONO_DECLARE( Player, GetFromName ); + MONO_DECLARE( Player, GetPing ); + MONO_DECLARE( Player, GetMoney ); + MONO_DECLARE( Player, GetRandom ); + MONO_DECLARE( Player, IsMuted ); + MONO_DECLARE( Player, GetTeam ); + MONO_DECLARE( Player, GetWantedLevel ); + MONO_DECLARE( Player, GetAlivePlayers ); + MONO_DECLARE( Player, GetDeadPlayers ); + MONO_DECLARE( Player, GetIdleTime ); + MONO_DECLARE( Player, IsMapForced ); + MONO_DECLARE( Player, GetNametagText ); + MONO_DECLARE( Player, GetNametagColor ); + MONO_DECLARE( Player, IsNametagShowing ); + MONO_DECLARE( Player, GetSerial ); + MONO_DECLARE( Player, GetUserName ); + MONO_DECLARE( Player, GetBlurLevel ); + MONO_DECLARE( Player, GetName ); + MONO_DECLARE( Player, GetIP ); + MONO_DECLARE( Player, GetAccount ); + MONO_DECLARE( Player, GetVersion ); + MONO_DECLARE( Player, GetACInfo ); + + // Player set functions + MONO_DECLARE( Player, SetMoney ); + MONO_DECLARE( Player, GiveMoney ); + MONO_DECLARE( Player, TakeMoney ); + MONO_DECLARE( Player, Spawn ); + MONO_DECLARE( Player, ShowHudComponent ); + MONO_DECLARE( Player, SetWantedLevel ); + MONO_DECLARE( Player, ForceMap ); + MONO_DECLARE( Player, SetNametagText ); + MONO_DECLARE( Player, SetNametagColor ); + MONO_DECLARE( Player, SetNametagShowing ); + MONO_DECLARE( Player, SetMuted ); + MONO_DECLARE( Player, SetBlurLevel ); + MONO_DECLARE( Player, Redirect ); + MONO_DECLARE( Player, SetName ); + MONO_DECLARE( Player, DetonateSatchels ); + MONO_DECLARE( Player, TakeScreenShot ); + MONO_DECLARE( Player, SetTeam ); + + // Input funcs + MONO_DECLARE( Player, BindKey ); + MONO_DECLARE( Player, UnbindKey ); + MONO_DECLARE( Player, GetControlState ); + MONO_DECLARE( Player, IsControlEnabled ); + + MONO_DECLARE( Player, SetControlState ); + MONO_DECLARE( Player, ToggleControl ); + MONO_DECLARE( Player, ToggleAllControls ); + + // Log in/out funcs + MONO_DECLARE( Player, LogIn ); + MONO_DECLARE( Player, LogOut ); + + // Admin funcs + MONO_DECLARE( Player, Kick ); + MONO_DECLARE( Player, Ban ); + + // Cursor get funcs + MONO_DECLARE( Player, IsCursorShowing ); + + // Cursor set funcs + MONO_DECLARE( Player, ShowCursor ); + + // Chat funcs + MONO_DECLARE( Player, ShowChat ); + + // Camera get functions + MONO_DECLARE( Player, GetCameraMatrix ); + MONO_DECLARE( Player, GetCameraTarget ); + MONO_DECLARE( Player, GetCameraInterior ); + + // Camera set functions + MONO_DECLARE( Player, SetCameraMatrix ); + MONO_DECLARE( Player, SetCameraTarget ); + MONO_DECLARE( Player, SetCameraInterior ); + MONO_DECLARE( Player, FadeCamera ); + + // Ped get functions + MONO_DECLARE( Ped, Create ); + MONO_DECLARE( Ped, GetArmor ); + MONO_DECLARE( Ped, IsChoking ); + MONO_DECLARE( Ped, IsDead ); + MONO_DECLARE( Ped, IsDucked ); + MONO_DECLARE( Ped, GetStat ); + MONO_DECLARE( Ped, GetTarget ); + MONO_DECLARE( Ped, GetWeapon ); + MONO_DECLARE( Ped, GetClothesTexture ); + MONO_DECLARE( Ped, GetClothesModel ); + MONO_DECLARE( Ped, DoesHaveJetPack ); + MONO_DECLARE( Ped, IsOnGround ); + MONO_DECLARE( Ped, GetFightingStyle ); + MONO_DECLARE( Ped, GetMoveAnim ); + MONO_DECLARE( Ped, GetGravity ); + MONO_DECLARE( Ped, GetContactElement ); + MONO_DECLARE( Ped, GetWeaponSlot ); + MONO_DECLARE( Ped, IsDoingGangDriveby ); + MONO_DECLARE( Ped, IsOnFire ); + MONO_DECLARE( Ped, IsHeadless ); + MONO_DECLARE( Ped, IsFrozen ); + MONO_DECLARE( Ped, GetOccupiedVehicle ); + MONO_DECLARE( Ped, GetOccupiedVehicleSeat ); + MONO_DECLARE( Ped, IsInVehicle ); + MONO_DECLARE( Ped, GetWeaponProperty ); + MONO_DECLARE( Ped, GetOriginalWeaponProperty ); + + // Ped set functions + MONO_DECLARE( Ped, SetArmor ); + MONO_DECLARE( Ped, Kill ); + MONO_DECLARE( Ped, SetStat ); + MONO_DECLARE( Ped, AddClothes ); + MONO_DECLARE( Ped, RemoveClothes ); + MONO_DECLARE( Ped, GiveJetPack ); + MONO_DECLARE( Ped, RemoveJetPack ); + MONO_DECLARE( Ped, SetFightingStyle ); + MONO_DECLARE( Ped, SetMoveAnim ); + MONO_DECLARE( Ped, SetGravity ); + MONO_DECLARE( Ped, SetChoking ); + MONO_DECLARE( Ped, SetWeaponSlot ); + MONO_DECLARE( Ped, WarpIntoVehicle ); + MONO_DECLARE( Ped, RemoveFromVehicle ); + MONO_DECLARE( Ped, SetDoingGangDriveby ); + MONO_DECLARE( Ped, SetAnimation ); + MONO_DECLARE( Ped, SetAnimationProgress ); + MONO_DECLARE( Ped, SetOnFire ); + MONO_DECLARE( Ped, SetHeadless ); + MONO_DECLARE( Ped, SetFrozen ); + MONO_DECLARE( Ped, ReloadWeapon ); + MONO_DECLARE( Ped, SetWeaponProperty ); + + // Ped body? + MONO_DECLARE( Ped, GetBodyPartName ); + MONO_DECLARE( Ped, GetClothesByTypeIndex ); + MONO_DECLARE( Ped, GetTypeIndexFromClothes ); + MONO_DECLARE( Ped, GetClothesTypeName ); + + // Weapon give/take functions + MONO_DECLARE( Ped, GiveWeapon ); + MONO_DECLARE( Ped, TakeWeapon ); + MONO_DECLARE( Ped, TakeAllWeapons ); + MONO_DECLARE( Ped, SetWeaponAmmo ); + + // Vehicle create/destroy functions + MONO_DECLARE( Vehicle, Create ); + + // Vehicle get functions + MONO_DECLARE( Vehicle, GetType ); + MONO_DECLARE( Vehicle, GetVariant ); + MONO_DECLARE( Vehicle, GetColor ); + MONO_DECLARE( Vehicle, GetModelFromName ); + MONO_DECLARE( Vehicle, GetLandingGearDown ); + MONO_DECLARE( Vehicle, GetMaxPassengers ); + MONO_DECLARE( Vehicle, GetName ); + MONO_DECLARE( Vehicle, GetNameFromModel ); + MONO_DECLARE( Vehicle, GetOccupant ); + MONO_DECLARE( Vehicle, GetOccupants ); + MONO_DECLARE( Vehicle, GetController ); + MONO_DECLARE( Vehicle, GetSirensOn ); + MONO_DECLARE( Vehicle, GetTurnVelocity ); + MONO_DECLARE( Vehicle, GetTurretPosition ); + MONO_DECLARE( Vehicle, IsLocked ); + MONO_DECLARE( Vehicle, GetOfType ); + MONO_DECLARE( Vehicle, GetUpgradeOnSlot ); + MONO_DECLARE( Vehicle, GetUpgrades ); +// MONO_DECLARE( Vehicle, GetUpgradeSlotName ); + MONO_DECLARE( Vehicle, GetUpgradeSlotName ); + MONO_DECLARE( Vehicle, GetCompatibleUpgrades ); + MONO_DECLARE( Vehicle, GetDoorState ); + MONO_DECLARE( Vehicle, GetWheelStates ); + MONO_DECLARE( Vehicle, GetLightState ); + MONO_DECLARE( Vehicle, GetPanelState ); + MONO_DECLARE( Vehicle, GetOverrideLights ); + MONO_DECLARE( Vehicle, GetTowedByVehicle ); + MONO_DECLARE( Vehicle, GetTowingVehicle ); + MONO_DECLARE( Vehicle, GetPaintjob ); + MONO_DECLARE( Vehicle, GetPlateText ); + MONO_DECLARE( Vehicle, IsDamageProof ); + MONO_DECLARE( Vehicle, IsFuelTankExplodable ); + MONO_DECLARE( Vehicle, IsFrozen ); + MONO_DECLARE( Vehicle, IsOnGround ); + MONO_DECLARE( Vehicle, GetEngineState ); + MONO_DECLARE( Vehicle, IsTrainDerailed ); + MONO_DECLARE( Vehicle, IsTrainDerailable ); + MONO_DECLARE( Vehicle, GetTrainDirection ); + MONO_DECLARE( Vehicle, GetTrainSpeed ); + MONO_DECLARE( Vehicle, IsBlown ); + MONO_DECLARE( Vehicle, GetHeadLightColor ); + MONO_DECLARE( Vehicle, GetDoorOpenRatio ); + MONO_DECLARE( Vehicle, IsTaxiLightOn ); + + // Vehicle set functions + MONO_DECLARE( Vehicle, Fix ); + MONO_DECLARE( Vehicle, Blow ); + MONO_DECLARE( Vehicle, SetTurnVelocity ); + MONO_DECLARE( Vehicle, SetColor ); + MONO_DECLARE( Vehicle, SetLandingGearDown ); + MONO_DECLARE( Vehicle, SetLocked ); + MONO_DECLARE( Vehicle, SetDoorsUndamageable ); + MONO_DECLARE( Vehicle, SetSirensOn ); + MONO_DECLARE( Vehicle, SetTaxiLightOn ); + MONO_DECLARE( Vehicle, AddUpgrade ); + MONO_DECLARE( Vehicle, RemoveUpgrade ); + MONO_DECLARE( Vehicle, SetDoorState ); + MONO_DECLARE( Vehicle, SetWheelStates ); + MONO_DECLARE( Vehicle, SetLightState ); + MONO_DECLARE( Vehicle, SetPanelState ); + MONO_DECLARE( Vehicle, SetIdleRespawnDelay ); + MONO_DECLARE( Vehicle, SetRespawnDelay ); + MONO_DECLARE( Vehicle, SetRespawnPosition ); + MONO_DECLARE( Vehicle, ToggleRespawn ); + MONO_DECLARE( Vehicle, ResetExplosionTime ); + MONO_DECLARE( Vehicle, ResetIdleTime ); + MONO_DECLARE( Vehicle, Spawn ); + MONO_DECLARE( Vehicle, Respawn ); + MONO_DECLARE( Vehicle, SetOverrideLights ); + MONO_DECLARE( Vehicle, AttachTrailer ); + MONO_DECLARE( Vehicle, DetachTrailer ); + MONO_DECLARE( Vehicle, SetEngineState ); + MONO_DECLARE( Vehicle, SetDirtLevel ); + MONO_DECLARE( Vehicle, SetDamageProof ); + MONO_DECLARE( Vehicle, SetPaintjob ); + MONO_DECLARE( Vehicle, SetFuelTankExplodable ); + MONO_DECLARE( Vehicle, SetTrainDerailed ); + MONO_DECLARE( Vehicle, SetTrainDerailable ); + MONO_DECLARE( Vehicle, SetTrainDirection ); + MONO_DECLARE( Vehicle, SetTrainSpeed ); + MONO_DECLARE( Vehicle, SetHeadLightColor ); + MONO_DECLARE( Vehicle, SetTurretPosition ); + MONO_DECLARE( Vehicle, SetDoorOpenRatio ); + MONO_DECLARE( Vehicle, SetVariant ); + MONO_DECLARE( Vehicle, GiveSirens ); + MONO_DECLARE( Vehicle, RemoveSirens ); + MONO_DECLARE( Vehicle, SetSirens ); + MONO_DECLARE( Vehicle, GetSirens ); + MONO_DECLARE( Vehicle, GetSirenParams ); + MONO_DECLARE( Vehicle, SetPlateText ); + + // Marker create/destroy functions + MONO_DECLARE( Marker, Create ); + + // Marker get functions + MONO_DECLARE( Marker, GetCount ); + MONO_DECLARE( Marker, GetType ); + MONO_DECLARE( Marker, GetSize ); + MONO_DECLARE( Marker, GetColor ); + MONO_DECLARE( Marker, GetTarget ); + MONO_DECLARE( Marker, GetIcon ); + + // Marker set functions + MONO_DECLARE( Marker, SetType ); + MONO_DECLARE( Marker, SetSize ); + MONO_DECLARE( Marker, SetColor ); + MONO_DECLARE( Marker, SetTarget ); + MONO_DECLARE( Marker, SetIcon ); + + // Blip create/destroy functions + MONO_DECLARE( Blip, Create ); + MONO_DECLARE( Blip, CreateAttachedTo ); + + // Blip get functions + MONO_DECLARE( Blip, GetIcon ); + MONO_DECLARE( Blip, GetSize ); + MONO_DECLARE( Blip, GetColor ); + MONO_DECLARE( Blip, GetOrdering ); + MONO_DECLARE( Blip, GetVisibleDistance ); + + // Blip set functions + MONO_DECLARE( Blip, SetIcon ); + MONO_DECLARE( Blip, SetSize ); + MONO_DECLARE( Blip, SetColor ); + MONO_DECLARE( Blip, SetOrdering ); + MONO_DECLARE( Blip, SetVisibleDistance ); + + // Object create/destroy functions + MONO_DECLARE( Object, Create ); + + // Object get functions + MONO_DECLARE( Object, GetScale ); + + // Object set functions + MONO_DECLARE( Object, SetScale ); + MONO_DECLARE( Object, Move ); + MONO_DECLARE( Object, Stop ); + + // Radar area create/destroy funcs + MONO_DECLARE( RadarArea, Create ); + + // Radar area get funcs + MONO_DECLARE( RadarArea, GetSize ); + MONO_DECLARE( RadarArea, GetColor ); + MONO_DECLARE( RadarArea, IsFlashing ); + MONO_DECLARE( RadarArea, IsInside ); + + // Radar area set funcs + MONO_DECLARE( RadarArea, SetSize ); + MONO_DECLARE( RadarArea, SetColor ); + MONO_DECLARE( RadarArea, SetFlashing ); + + // Pickup create/destroy funcs + MONO_DECLARE( Pickup, Create ); + + // Pickup get funcs + MONO_DECLARE( Pickup, GetType ); + MONO_DECLARE( Pickup, GetWeapon ); + MONO_DECLARE( Pickup, GetAmount ); + MONO_DECLARE( Pickup, GetAmmo ); + MONO_DECLARE( Pickup, GetRespawnInterval ); + MONO_DECLARE( Pickup, IsSpawned ); + + // Pickup set funcs + MONO_DECLARE( Pickup, SetType ); + MONO_DECLARE( Pickup, SetRespawnInterval ); + MONO_DECLARE( Pickup, Use ); + + // Shape create funcs + MONO_DECLARE( Shape, CreateCircle ); + MONO_DECLARE( Shape, CreateCuboid ); + MONO_DECLARE( Shape, CreateSphere ); + MONO_DECLARE( Shape, CreateRectangle ); + MONO_DECLARE( Shape, CreatePolygon ); + MONO_DECLARE( Shape, CreateTube ); + + // Explosion funcs + MONO_DECLARE( Explosion, Create ); + + // Audio funcs + MONO_DECLARE( Audio, PlayFrontEnd ); + MONO_DECLARE( Audio, PlayMission ); + + // Team get funcs + MONO_DECLARE( Team, Create ); + MONO_DECLARE( Team, GetFromName ); + MONO_DECLARE( Team, GetName ); + MONO_DECLARE( Team, GetColor ); + MONO_DECLARE( Team, CountPlayers ); + MONO_DECLARE( Team, GetFriendlyFire ); + + // Team set funcs + MONO_DECLARE( Team, SetName ); + MONO_DECLARE( Team, SetColor ); + MONO_DECLARE( Team, SetFriendlyFire ); + + // Water funcs + MONO_DECLARE( Water, Create ); + MONO_DECLARE( Water, SetLevel ); + MONO_DECLARE( Water, SetLevelAll ); + MONO_DECLARE( Water, SetLevelWorld ); + MONO_DECLARE( Water, ResetLevelWorld ); + MONO_DECLARE( Water, GetVertexPosition ); + MONO_DECLARE( Water, SetVertexPosition ); + MONO_DECLARE( Water, GetColor ); + MONO_DECLARE( Water, SetColor ); + MONO_DECLARE( Water, ResetColor ); + + // General world get funcs + MONO_DECLARE( World, GetTime ); + MONO_DECLARE( World, GetWeather ); + MONO_DECLARE( World, GetZoneName ); + MONO_DECLARE( World, GetGravity ); + MONO_DECLARE( World, GetGameSpeed ); + MONO_DECLARE( World, GetWaveHeight ); + MONO_DECLARE( World, GetFPSLimit ); + MONO_DECLARE( World, GetMinuteDuration ); + MONO_DECLARE( World, IsGarageOpen ); + MONO_DECLARE( World, GetTrafficLightState ); + MONO_DECLARE( World, GetTrafficLightsLocked ); + MONO_DECLARE( World, GetJetpackMaxHeight ); + MONO_DECLARE( World, GetAircraftMaxVelocity ); + MONO_DECLARE( World, GetInteriorSoundsEnabled ); + MONO_DECLARE( World, GetRainLevel ); + MONO_DECLARE( World, GetSunSize ); + MONO_DECLARE( World, GetSunColor ); + MONO_DECLARE( World, GetWindVelocity ); + MONO_DECLARE( World, GetFarClipDistance ); + MONO_DECLARE( World, GetFogDistance ); + MONO_DECLARE( World, GetAircraftMaxHeight ); + MONO_DECLARE( World, GetOcclusionsEnabled ); + MONO_DECLARE( World, GetMoonSize ); + MONO_DECLARE( World, GetSkyGradient ); + MONO_DECLARE( World, GetHeatHaze ); + MONO_DECLARE( World, GetJetpackWeaponEnabled ); + MONO_DECLARE( World, GetCloudsEnabled ); + + // General world set funcs + MONO_DECLARE( World, SetTime ); + MONO_DECLARE( World, SetWeather ); + MONO_DECLARE( World, SetWeatherBlended ); + MONO_DECLARE( World, SetGravity ); + MONO_DECLARE( World, SetGameSpeed ); + MONO_DECLARE( World, SetWaveHeight ); + MONO_DECLARE( World, SetSkyGradient ); + MONO_DECLARE( World, ResetSkyGradient ); + MONO_DECLARE( World, SetHeatHaze ); + MONO_DECLARE( World, ResetHeatHaze ); + MONO_DECLARE( World, SetFPSLimit ); + MONO_DECLARE( World, SetMinuteDuration ); + MONO_DECLARE( World, SetGarageOpen ); + MONO_DECLARE( World, SetGlitchEnabled ); + MONO_DECLARE( World, IsGlitchEnabled ); + MONO_DECLARE( World, SetJetpackWeaponEnabled ); + MONO_DECLARE( World, SetCloudsEnabled ); + MONO_DECLARE( World, SetTrafficLightState ); + MONO_DECLARE( World, SetTrafficLightsLocked ); + MONO_DECLARE( World, SetJetpackMaxHeight ); + MONO_DECLARE( World, SetInteriorSoundsEnabled ); + MONO_DECLARE( World, SetRainLevel ); + MONO_DECLARE( World, SetSunSize ); + MONO_DECLARE( World, SetSunColor ); + MONO_DECLARE( World, SetWindVelocity ); + MONO_DECLARE( World, SetFarClipDistance ); + MONO_DECLARE( World, SetFogDistance ); + MONO_DECLARE( World, SetAircraftMaxHeight ); + MONO_DECLARE( World, SetAircraftMaxVelocity ); + MONO_DECLARE( World, SetOcclusionsEnabled ); + MONO_DECLARE( World, ResetRainLevel ); + MONO_DECLARE( World, ResetSunSize ); + MONO_DECLARE( World, ResetSunColor ); + MONO_DECLARE( World, ResetWindVelocity ); + MONO_DECLARE( World, ResetFarClipDistance ); + MONO_DECLARE( World, ResetFogDistance ); + MONO_DECLARE( World, RemoveWorldModel ); + MONO_DECLARE( World, RestoreWorldModel ); + MONO_DECLARE( World, RestoreAllWorldModels ); + MONO_DECLARE( World, SetMoonSize ); + MONO_DECLARE( World, ResetMoonSize ); + + // Account get funcs + MONO_DECLARE( Account, Get ); + MONO_DECLARE( Account, GetAll ); + MONO_DECLARE( Account, GetPlayer ); + MONO_DECLARE( Account, IsGuest ); +// MONO_DECLARE( Account, GetData ); +// MONO_DECLARE( Account, GetAllData ); + MONO_DECLARE( Account, GetSerial ); +// MONO_DECLARE( Account, GetBySerial ); + + // Account set funcs + MONO_DECLARE( Account, Add ); + MONO_DECLARE( Account, Remove ); + MONO_DECLARE( Account, SetPassword ); +// MONO_DECLARE( Account, SetData ); + MONO_DECLARE( Account, CopyData ); + + MONO_DECLARE( Ban, Add ); + MONO_DECLARE( Ban, Remove ); + +// MONO_DECLARE( Ban, GetBans ); + MONO_DECLARE( Ban, Reload ); + + MONO_DECLARE( Ban, GetIP ); + MONO_DECLARE( Ban, GetSerial ); + MONO_DECLARE( Ban, GetUsername ); + MONO_DECLARE( Ban, GetNick ); + MONO_DECLARE( Ban, GetReason ); + MONO_DECLARE( Ban, GetAdmin ); + + MONO_DECLARE( Ban, GetBanTime ); + MONO_DECLARE( Ban, GetUnbanTime ); + + MONO_DECLARE( Ban, SetUnbanTime ); + MONO_DECLARE( Ban, SetReason ); + MONO_DECLARE( Ban, SetAdmin ); + + // Resource funcs + MONO_DECLARE( Resource, Create ); + MONO_DECLARE( Resource, Copy ); + MONO_DECLARE( Resource, GetRootElement ); + MONO_DECLARE( Resource, GetMapRootElement ); + MONO_DECLARE( Resource, GetDynamicElementRoot ); +// MONO_DECLARE( Resource, AddMap ); +// MONO_DECLARE( Resource, AddConfig ); + MONO_DECLARE( Resource, RemoveFile ); +// MONO_DECLARE( Resource, AddConfig ); +// MONO_DECLARE( Resource, AddMap ); +// MONO_DECLARE( Resource, GetConfig ); +// MONO_DECLARE( Resource, GetExportedFunctions ); + MONO_DECLARE( Resource, GetFromName ); + MONO_DECLARE( Resource, GetInfo ); + MONO_DECLARE( Resource, GetLastStartTime ); + MONO_DECLARE( Resource, GetLoadFailureReason ); + MONO_DECLARE( Resource, GetLoadTime ); + MONO_DECLARE( Resource, GetName ); + MONO_DECLARE( Resource, GetResources ); + MONO_DECLARE( Resource, GetState ); + MONO_DECLARE( Resource, GetCurrent ); + MONO_DECLARE( Resource, Refresh ); + MONO_DECLARE( Resource, RemoveDefaultSetting ); + MONO_DECLARE( Resource, Start ); + MONO_DECLARE( Resource, Restart ); + MONO_DECLARE( Resource, Stop ); + MONO_DECLARE( Resource, SetDefaultSetting ); +// MONO_DECLARE( Resource, SetDefaultSetting ); +// MONO_DECLARE( Resource, SetDefaultSetting ); + MONO_DECLARE( Resource, SetInfo ); + MONO_DECLARE( Resource, Rename ); + MONO_DECLARE( Resource, Delete ); +// MONO_DECLARE( Resource, GetACLRequests ); + MONO_DECLARE( Resource, UpdateACLRequest ); } void CMonoFunctions::Debug::Log( MonoString *string ) @@ -149,385 +646,99 @@ bool CMonoFunctions::Config::Set( MonoString *msKey, MonoString *msValue ) return false; } -// Element create/destroy - -DWORD CMonoFunctions::Element::Create( MonoString* msTypeName, MonoString* msID ) +unsigned int CMonoFunctions::Server::GetMaxPlayers( void ) { if( RESOURCE ) { - const char* szTypeName = mono_string_to_utf8( msTypeName ); - const char* szID = mono_string_to_utf8( msID ); - - return (DWORD)CLuaFunctionDefinitions::CreateElement( RESOURCE->GetLua(), szTypeName, szID ); + return CLuaFunctionDefinitions::GetMaxPlayers( RESOURCE->GetLua() ); } - - return NULL; -} - -bool CMonoFunctions::Element::Destroy( DWORD pUserData ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::DestroyElement( RESOURCE->GetLua(), (void*)pUserData ); - } - - return false; -} - -DWORD CMonoFunctions::Element::Clone( DWORD pUserData, MonoObject* vecPosition, bool bCloneElement ) -{ - if( RESOURCE ) - { - CMonoObject pPosition( vecPosition ); - - float fX = pPosition.GetPropertyValue( "X" ); - float fY = pPosition.GetPropertyValue( "Y" ); - float fZ = pPosition.GetPropertyValue( "Z" ); - - return (DWORD)CLuaFunctionDefinitions::CloneElement( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ), bCloneElement ); - } - - return false; -} - -// Element get funcs - -bool CMonoFunctions::Element::IsElement( DWORD pUserData ) -{ - if( RESOURCE ) - { - return (unsigned int)CLuaFunctionDefinitions::IsElement( RESOURCE->GetLua(), (void*)pUserData ); - } - - return false; -} - -MonoString* CMonoFunctions::Element::GetType( DWORD pUserData ) -{ - if( RESOURCE ) - { - const string strType = CLuaFunctionDefinitions::GetElementType( RESOURCE->GetLua(), (void*)pUserData ); - - return mono_string_new( mono_domain_get(), strType.c_str() ); - } - - return mono_string_new( mono_domain_get(), "" ); -} - -DWORD CMonoFunctions::Element::GetByID( MonoString* msID, unsigned int uiIndex ) -{ - if( RESOURCE ) - { - const char* szID = mono_string_to_utf8( msID ); - - return (DWORD)CLuaFunctionDefinitions::GetElementByID( RESOURCE->GetLua(), szID, uiIndex ); - } - - return NULL; -} - -DWORD CMonoFunctions::Element::GetByIndex( int iIndex ) -{ - if( RESOURCE ) - { - return (DWORD)CLuaFunctionDefinitions::GetElementByIndex( RESOURCE->GetLua(), iIndex ); - } - - return NULL; -} - -DWORD CMonoFunctions::Element::GetChild( DWORD pUserData, int iIndex ) -{ - if( RESOURCE ) - { - return (DWORD)CLuaFunctionDefinitions::GetElementChild( RESOURCE->GetLua(), (void*)pUserData, iIndex ); - } - - return NULL; -} - -int CMonoFunctions::Element::GetChildrenCount( DWORD pUserData ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::GetElementChildrenCount( RESOURCE->GetLua(), (void*)pUserData ); - } - + return 0; } -MonoString* CMonoFunctions::Element::GetID( DWORD pUserData ) +bool CMonoFunctions::Server::SetMaxPlayers( unsigned int uiMax ) { if( RESOURCE ) { - const string strID = CLuaFunctionDefinitions::GetElementID( RESOURCE->GetLua(), (void*)pUserData ); - - return mono_string_new( mono_domain_get(), strID.c_str() ); + return CLuaFunctionDefinitions::SetMaxPlayers( RESOURCE->GetLua(), uiMax ); } - - return mono_string_new( mono_domain_get(), "" ); -} - -unsigned int CMonoFunctions::Element::GetParent( DWORD pUserData ) -{ - if( RESOURCE ) - { - return (unsigned int)CLuaFunctionDefinitions::GetElementParent( RESOURCE->GetLua(), (void*)pUserData ); - } - - return NULL; -} - -MonoObject* CMonoFunctions::Element::GetPosition( DWORD pUserData ) -{ - if( RESOURCE ) - { - Vector3 vecPosition; - - if( CLuaFunctionDefinitions::GetElementPosition( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) - { - CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "Vector3", vecPosition ); - - if( pObject ) - { - return pObject->GetObject(); - } - } - } - - return NULL; -} - -MonoObject* CMonoFunctions::Element::GetRotation( DWORD pUserData ) -{ - if( RESOURCE ) - { - Vector3 vecPosition; - - if( CLuaFunctionDefinitions::GetElementRotation( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) - { - CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "Vector3", vecPosition ); - - if( pObject ) - { - return pObject->GetObject(); - } - } - } - - return NULL; -} - -MonoObject* CMonoFunctions::Element::GetVelocity( DWORD pUserData ) -{ - if( RESOURCE ) - { - Vector3 vecPosition; - - if( CLuaFunctionDefinitions::GetElementVelocity( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) - { - CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "Vector3", vecPosition ); - - if( pObject ) - { - return pObject->GetObject(); - } - } - } - - return NULL; -} - -unsigned char CMonoFunctions::Element::GetInterior( DWORD pUserData ) -{ - if( RESOURCE ) - { - unsigned char ucInterior; - - if( CLuaFunctionDefinitions::GetElementInterior( RESOURCE->GetLua(), (void*)pUserData, ucInterior ) ) - { - return ucInterior; - } - } - + return 0; } -bool CMonoFunctions::Element::IsWithinColShape( DWORD pUserData ) +bool CMonoFunctions::Server::OutputChatBox( MonoString* msText, DWORD pElement, MonoObject* mpColor, bool bColorCoded ) { if( RESOURCE ) { - bool bWithin; + const char* szText = mono_string_to_utf8( msText ); - if( CLuaFunctionDefinitions::IsElementWithinColShape( RESOURCE->GetLua(), (void*)pUserData, bWithin ) ) - { - return bWithin; - } - } - - return false; -} - -bool CMonoFunctions::Element::IsWithinMarker( DWORD pUserData ) -{ - if( RESOURCE ) - { - bool bWithin; - - if( CLuaFunctionDefinitions::IsElementWithinMarker( RESOURCE->GetLua(), (void*)pUserData, bWithin ) ) - { - return bWithin; - } - } - - return false; -} - -unsigned short CMonoFunctions::Element::GetDimension( DWORD pUserData ) -{ - if( RESOURCE ) - { - unsigned short usDimension; - - if( CLuaFunctionDefinitions::GetElementDimension( RESOURCE->GetLua(), (void*)pUserData, usDimension ) ) - { - return usDimension; - } - } - - return 0; -} - -MonoString* CMonoFunctions::Element::GetZoneName( DWORD pUserData, bool bCitiesOnly ) -{ - if( RESOURCE ) - { - string strOutName; - - if( CLuaFunctionDefinitions::GetElementZoneName( RESOURCE->GetLua(), (void*)pUserData, strOutName, bCitiesOnly ) ) - { - return RESOURCE->NewString( strOutName ); - } - } - - return NULL; -} - -bool CMonoFunctions::Element::IsAttached( DWORD pUserData ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::IsElementAttached( RESOURCE->GetLua(), (void*)pUserData ); - } - - return false; -} - -DWORD CMonoFunctions::Element::GetAttachedTo( DWORD pUserData ) -{ - if( RESOURCE ) - { - return (DWORD)CLuaFunctionDefinitions::GetElementAttachedTo( RESOURCE->GetLua(), (void*)pUserData ); - } - - return NULL; -} - -DWORD CMonoFunctions::Element::GetColShape( DWORD pUserData ) -{ - if( RESOURCE ) - { - return (DWORD)CLuaFunctionDefinitions::GetElementColShape( RESOURCE->GetLua(), (void*)pUserData ); - } - - return NULL; -} - -unsigned char CMonoFunctions::Element::GetAlpha( DWORD pUserData ) -{ - if( RESOURCE ) - { - unsigned char ucAlpha; + CMonoObject pColor( mpColor ); - if( CLuaFunctionDefinitions::GetElementAlpha( RESOURCE->GetLua(), (void*)pUserData, ucAlpha ) ) - { - return ucAlpha; - } + unsigned char ucRed = pColor.GetPropertyValue< unsigned char >( "R" ); + unsigned char ucGreen = pColor.GetPropertyValue< unsigned char >( "G" ); + unsigned char ucBlue = pColor.GetPropertyValue< unsigned char >( "B" ); + + return CLuaFunctionDefinitions::OutputChatBox( RESOURCE->GetLua(), szText, (void*)pElement, ucRed, ucGreen, ucBlue, bColorCoded ); } - - return 0; -} - -bool CMonoFunctions::Element::IsDoubleSided( DWORD pUserData ) -{ - if( RESOURCE ) - { - bool bDoubleSided; - - if( CLuaFunctionDefinitions::IsElementDoubleSided( RESOURCE->GetLua(), (void*)pUserData, bDoubleSided ) ) - { - return bDoubleSided; - } - } - + return false; } -float CMonoFunctions::Element::GetHealth( DWORD pUserData ) +bool CMonoFunctions::Server::OutputConsole( MonoString* msText, DWORD pElement ) { if( RESOURCE ) { - float fHealth; - - if( CLuaFunctionDefinitions::GetElementHealth( RESOURCE->GetLua(), (void*)pUserData, fHealth ) ) - { - return fHealth; - } - } + const char* szText = mono_string_to_utf8( msText ); + return CLuaFunctionDefinitions::OutputConsole( RESOURCE->GetLua(), szText, (void*)pElement ); + } + return false; } -unsigned short CMonoFunctions::Element::GetModel( DWORD pUserData ) +bool CMonoFunctions::Server::SetPassword( MonoString* msPassword, bool bSave ) { if( RESOURCE ) { - unsigned short usModel; - - if( CLuaFunctionDefinitions::GetElementModel( RESOURCE->GetLua(), (void*)pUserData, usModel ) ) - { - return usModel; - } - } + const char* szPassword = mono_string_to_utf8( msPassword ); + return CLuaFunctionDefinitions::SetServerPassword( RESOURCE->GetLua(), szPassword, bSave ); + } + return false; } -bool CMonoFunctions::Element::IsInWater( DWORD pUserData ) +MonoObject* CMonoFunctions::Server::GetVersion( void ) { if( RESOURCE ) { - bool bInWater; - - if( CLuaFunctionDefinitions::IsElementInWater( RESOURCE->GetLua(), (void*)pUserData, bInWater ) ) - { - return bInWater; - } - } + LuaTable pLuaTable = CLuaFunctionDefinitions::GetVersion( RESOURCE->GetLua() ); - return false; -} - -MonoObject* CMonoFunctions::Element::GetAttachedOffsetPosition( DWORD pUserData ) -{ - if( RESOURCE ) - { - Vector3 vecPosition, vecRotation; - - if( CLuaFunctionDefinitions::GetElementAttachedOffsets( RESOURCE->GetLua(), (void*)pUserData, vecPosition, vecRotation ) ) + if( !pLuaTable.empty() ) { - CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "Vector3", vecPosition ); - + unsigned long ulNumber = pLuaTable[ "number" ]->GetNumber< unsigned long >(); + const char* szString = pLuaTable[ "mta" ]->GetString(); + const char* szName = pLuaTable[ "name" ]->GetString(); + const char* szBuildType = pLuaTable[ "type" ]->GetString(); + unsigned long ulNetcode = pLuaTable[ "netcode" ]->GetNumber< unsigned long >(); + const char* szOS = pLuaTable[ "os" ]->GetString(); + const char* szBuildTag = pLuaTable[ "tag" ]->GetString(); + const char* szSortable = pLuaTable[ "sortable" ]->GetString(); + + void *args[] = + { + &ulNumber, + &szString, + &szName, + &szBuildType, + &ulNetcode, + &szOS, + &szBuildTag, + &szSortable + }; + + CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "ServerVersion", args, 8 ); + if( pObject ) { return pObject->GetObject(); @@ -537,395 +748,3 @@ MonoObject* CMonoFunctions::Element::GetAttachedOffsetPosition( DWORD pUserData return NULL; } - -MonoObject* CMonoFunctions::Element::GetAttachedOffsetRotation( DWORD pUserData ) -{ - if( RESOURCE ) - { - Vector3 vecPosition, vecRotation; - - if( CLuaFunctionDefinitions::GetElementAttachedOffsets( RESOURCE->GetLua(), (void*)pUserData, vecPosition, vecRotation ) ) - { - CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "Vector3", vecRotation ); - - if( pObject ) - { - return pObject->GetObject(); - } - } - } - - return NULL; -} - -DWORD CMonoFunctions::Element::GetSyncer( DWORD pUserData ) -{ - if( RESOURCE ) - { - return (DWORD)CLuaFunctionDefinitions::GetElementSyncer( RESOURCE->GetLua(), (void*)pUserData ); - } - - return NULL; -} - -bool CMonoFunctions::Element::GetCollisionsEnabled( DWORD pUserData ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::GetElementCollisionsEnabled( RESOURCE->GetLua(), (void*)pUserData ); - } - - return false; -} - -bool CMonoFunctions::Element::IsFrozen( DWORD pUserData ) -{ - if( RESOURCE ) - { - bool bFrozen; - - if( CLuaFunctionDefinitions::IsElementFrozen( RESOURCE->GetLua(), (void*)pUserData, bFrozen ) ) - { - return bFrozen; - } - } - - return false; -} - -DWORD CMonoFunctions::Element::GetLowLod( DWORD pUserData ) -{ - if( RESOURCE ) - { - void* pUserData; - - if( CLuaFunctionDefinitions::GetLowLodElement( RESOURCE->GetLua(), (void*)pUserData, pUserData ) ) - { - return (DWORD)pUserData; - } - } - - return NULL; -} - -bool CMonoFunctions::Element::IsLowLod( DWORD pUserData ) -{ - if( RESOURCE ) - { - bool bIsLowLod; - - if( CLuaFunctionDefinitions::IsElementLowLod( RESOURCE->GetLua(), (void*)pUserData, bIsLowLod ) ) - { - return bIsLowLod; - } - } - - return false; -} - -// Element set funcs - -bool CMonoFunctions::Element::ClearVisibleTo( DWORD pUserData ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::ClearElementVisibleTo( RESOURCE->GetLua(), (void*)pUserData ); - } - - return false; -} - -bool CMonoFunctions::Element::SetID( DWORD pUserData, MonoString* msID ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementID( RESOURCE->GetLua(), (void*)pUserData, string( mono_string_to_utf8( msID ) ) ); - } - - return false; -} - -bool CMonoFunctions::Element::SetData( DWORD pUserData, MonoString* msKey, CLuaArgument& Variable ) -{ - if( RESOURCE ) - { - string strKey( mono_string_to_utf8( msKey ) ); - - return CLuaFunctionDefinitions::SetElementData( RESOURCE->GetLua(), (void*)pUserData, strKey, Variable ); - } - - return false; -} - -bool CMonoFunctions::Element::RemoveData( DWORD pUserData, MonoString* msKey ) -{ - if( RESOURCE ) - { - string strKey( mono_string_to_utf8( msKey ) ); - - return CLuaFunctionDefinitions::RemoveElementData( RESOURCE->GetLua(), (void*)pUserData, strKey ); - } - - return false; -} - -bool CMonoFunctions::Element::SetParent( DWORD pUserData, DWORD pTarget ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementParent( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget ); - } - - return false; -} - -bool CMonoFunctions::Element::SetPosition( DWORD pUserData, MonoObject* pPosition, bool bWarp ) -{ - if( RESOURCE ) - { - CMonoObject pPosition( pPosition ); - - float fX = pPosition.GetPropertyValue( "X" ); - float fY = pPosition.GetPropertyValue( "Y" ); - float fZ = pPosition.GetPropertyValue( "Z" ); - - return CLuaFunctionDefinitions::SetElementPosition( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ), bWarp ); - } - - return false; -} - -bool CMonoFunctions::Element::SetRotation( DWORD pUserData, MonoObject* pRotation, MonoString* msRotationOrder, bool bNewWay ) -{ - if( RESOURCE ) - { - CMonoObject pPosition( pRotation ); - - float fX = pPosition.GetPropertyValue( "X" ); - float fY = pPosition.GetPropertyValue( "Y" ); - float fZ = pPosition.GetPropertyValue( "Z" ); - - const char* szRotationOrder = mono_string_to_utf8( msRotationOrder ); - - return CLuaFunctionDefinitions::SetElementRotation( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ), szRotationOrder, bNewWay ); - } - - return false; -} - -bool CMonoFunctions::Element::SetVelocity( DWORD pUserData, MonoObject* pVelocity ) -{ - if( RESOURCE ) - { - CMonoObject pPosition( pVelocity ); - - float fX = pPosition.GetPropertyValue( "X" ); - float fY = pPosition.GetPropertyValue( "Y" ); - float fZ = pPosition.GetPropertyValue( "Z" ); - - return CLuaFunctionDefinitions::SetElementVelocity( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ) ); - } - - return false; -} - -bool CMonoFunctions::Element::SetVisibleTo( DWORD pUserData, DWORD pTarget, bool bVisible ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementVisibleTo( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget, bVisible ); - } - - return false; -} - -bool CMonoFunctions::Element::SetInterior( DWORD pUserData, int iInterior ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementInterior( RESOURCE->GetLua(), (void*)pUserData, iInterior ); - } - - return false; -} - -bool CMonoFunctions::Element::SetDimension( DWORD pUserData, int iDimension ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementDimension( RESOURCE->GetLua(), (void*)pUserData, iDimension ); - } - - return false; -} - -bool CMonoFunctions::Element::Attach( DWORD pUserData, DWORD pTarget, MonoObject* pMonoPosition, MonoObject* pMonoRotation ) -{ - if( RESOURCE ) - { - Vector3 - vecPosition, vecRotation; - - CMonoObject - pPosition( pMonoPosition ), pRotation( pMonoRotation ); - - vecPosition.fX = pPosition.GetPropertyValue( "X" ); - vecPosition.fY = pPosition.GetPropertyValue( "Y" ); - vecPosition.fZ = pPosition.GetPropertyValue( "Z" ); - - vecRotation.fX = pRotation.GetPropertyValue( "X" ); - vecRotation.fY = pRotation.GetPropertyValue( "Y" ); - vecRotation.fZ = pRotation.GetPropertyValue( "Z" ); - - return CLuaFunctionDefinitions::AttachElements( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget, vecPosition, vecRotation ); - } - - return false; -} - -bool CMonoFunctions::Element::Detach( DWORD pUserData, DWORD pTarget ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::DetachElements( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget ); - } - - return false; -} - -bool CMonoFunctions::Element::SetAlpha( DWORD pUserData, int iAlpha ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementAlpha( RESOURCE->GetLua(), (void*)pUserData, iAlpha ); - } - - return false; -} - -bool CMonoFunctions::Element::SetDoubleSided( DWORD pUserData, bool bDoubleSided ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementDoubleSided( RESOURCE->GetLua(), (void*)pUserData, bDoubleSided ); - } - - return false; -} - -bool CMonoFunctions::Element::SetHealth( DWORD pUserData, float fHealth ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementHealth( RESOURCE->GetLua(), (void*)pUserData, fHealth ); - } - - return false; -} - -bool CMonoFunctions::Element::SetModel( DWORD pUserData, int iModel ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementModel( RESOURCE->GetLua(), (void*)pUserData, iModel ); - } - - return false; -} - -bool CMonoFunctions::Element::SetAttachedOffsets( DWORD pUserData, MonoObject* pMonoPosition, MonoObject* pMonoRotation ) -{ - if( RESOURCE ) - { - Vector3 - vecPosition, vecRotation; - - CMonoObject - pPosition( pMonoPosition ), pRotation( pMonoRotation ); - - vecPosition.fX = pPosition.GetPropertyValue( "X" ); - vecPosition.fY = pPosition.GetPropertyValue( "Y" ); - vecPosition.fZ = pPosition.GetPropertyValue( "Z" ); - - vecRotation.fX = pRotation.GetPropertyValue( "X" ); - vecRotation.fY = pRotation.GetPropertyValue( "Y" ); - vecRotation.fZ = pRotation.GetPropertyValue( "Z" ); - - return CLuaFunctionDefinitions::SetElementAttachedOffsets( RESOURCE->GetLua(), (void*)pUserData, vecPosition, vecRotation ); - } - - return false; -} - -bool CMonoFunctions::Element::SetSyncer( DWORD pUserData, DWORD pPlayer ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementSyncer( RESOURCE->GetLua(), (void*)pUserData, (void*)pPlayer ); - } - - return false; -} - -bool CMonoFunctions::Element::SetCollisionsEnabled( DWORD pUserData, bool bEnabled ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementCollisionsEnabled( RESOURCE->GetLua(), (void*)pUserData, bEnabled ); - } - - return false; -} - -bool CMonoFunctions::Element::SetFrozen( DWORD pUserData, bool bFrozen ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetElementFrozen( RESOURCE->GetLua(), (void*)pUserData, bFrozen ); - } - - return false; -} - -bool CMonoFunctions::Element::SetLowLod( DWORD pUserData, bool bEnabled ) -{ - if( RESOURCE ) - { - return CLuaFunctionDefinitions::SetLowLodElement( RESOURCE->GetLua(), (void*)pUserData, bEnabled ); - } - - return false; -} - - -// Vehicle create/destroy functions - -DWORD CMonoFunctions::Vehicle::Create( int model, MonoObject* position, MonoObject* rotation, MonoString* numberplate, bool direction, int variant1, int variant2 ) -{ - if( RESOURCE ) - { - CMonoObject pPosition( position ); - - float fX = pPosition.GetPropertyValue( "X" ); - float fY = pPosition.GetPropertyValue( "Y" ); - float fZ = pPosition.GetPropertyValue( "Z" ); - - CMonoObject pRotation( rotation ); - - float fRX = pRotation.GetPropertyValue( "X" ); - float fRY = pRotation.GetPropertyValue( "Y" ); - float fRZ = pRotation.GetPropertyValue( "Z" ); - - string sNumberplate = ""; - - if( numberplate && mono_string_length( numberplate ) > 0 ) - { - sNumberplate = mono_string_to_utf8( numberplate ); - } - - return (DWORD)CLuaFunctionDefinitions::CreateVehicle( RESOURCE->GetLua(), model, fX, fY, fZ, fRX, fRY, fRZ, sNumberplate, direction, variant1, variant2 ); - } - - return NULL; -} - diff --git a/mta-mono/src/CMonoFunctions.h b/mta-mono/src/CMonoFunctions.h index 6f431a0..9894208 100644 --- a/mta-mono/src/CMonoFunctions.h +++ b/mta-mono/src/CMonoFunctions.h @@ -10,6 +10,9 @@ * *********************************************************/ +#include "CResource.h" +#include "CResourceManager.h" + class CMonoFunctions; #ifndef __CMONOFUNCTIONS_H @@ -18,6 +21,15 @@ class CMonoFunctions; #include "Common.h" #include "lua/CLuaFunctionDefinitions.h" +#include "CMonoObject.h" + +extern ILuaModuleManager10 *g_pModuleManager; +extern CResourceManager *g_pResourceManager; + +#define RESOURCE g_pResourceManager->GetFromList( mono_domain_get() ) + +#define MONO_DECLARE(a,b) mono_add_internal_call("MultiTheftAuto.Native."#a"::"#b,CMonoFunctions::a::b) + class CMonoFunctions { public: @@ -38,6 +50,17 @@ public: static bool Set ( MonoString *msKey, MonoString *msValue ); }; + class Server + { + public: + static unsigned int GetMaxPlayers ( void ); + static bool SetMaxPlayers ( unsigned int uiMax ); + static bool OutputChatBox ( MonoString* szText, DWORD pElement, MonoObject* pColor, bool bColorCoded ); + static bool OutputConsole ( MonoString* szText, DWORD pElement ); + static bool SetPassword ( MonoString* msPassword, bool bSave ); + static MonoObject* GetVersion ( void ); + }; + class Element { public: @@ -47,6 +70,8 @@ public: static DWORD Clone ( DWORD pUserData, MonoObject* vecPosition, bool bCloneElement ); // Element get funcs + static MonoArray* GetByType ( MonoString* msType, DWORD pStartElement ); + static bool IsElement ( DWORD pUserData ); static MonoString* GetType ( DWORD pUserData ); static DWORD GetByID ( MonoString* msID, unsigned int uiIndex ); @@ -54,8 +79,8 @@ public: static DWORD GetChild ( DWORD pUserData, int iIndex ); static int GetChildrenCount ( DWORD pUserData ); static MonoString* GetID ( DWORD pUserData ); -// static MonoObject* GetData ( DWORD pUserData, MonoString* sKey, bool bInherit = true ); -// static ?* GetAllData ( DWORD pUserData ); + static MonoObject* GetData ( DWORD pUserData, MonoString* sKey, bool bInherit = true ); + static MonoArray* GetAllData ( DWORD pUserData ); static unsigned int GetParent ( DWORD pUserData ); static MonoObject* GetPosition ( DWORD pUserData ); static MonoObject* GetRotation ( DWORD pUserData ); @@ -106,10 +131,575 @@ public: static bool SetLowLod ( DWORD pUserData, bool bEnabled ); }; + class Player + { + public: + // Player get functions + static unsigned int GetCount ( void ); + static DWORD GetFromName ( MonoString* msNick ); + static unsigned int GetPing ( DWORD pUserData ); + static long GetMoney ( DWORD pUserData ); + static DWORD GetRandom ( void ); + static bool IsMuted ( DWORD pUserData ); + static DWORD GetTeam ( DWORD pUserData ); + static unsigned int GetWantedLevel ( DWORD pUserData ); + static MonoArray* GetAlivePlayers ( void ); + static MonoArray* GetDeadPlayers ( void ); + static unsigned int GetIdleTime ( DWORD pUserData ); + static bool IsMapForced ( DWORD pUserData ); + static MonoString* GetNametagText ( DWORD pUserData ); + static MonoObject* GetNametagColor ( DWORD pUserData ); + static bool IsNametagShowing ( DWORD pUserData ); + static MonoString* GetSerial ( DWORD pUserData ); + static MonoString* GetUserName ( DWORD pUserData ); + static unsigned char GetBlurLevel ( DWORD pUserData ); + static MonoString* GetName ( DWORD pUserData ); + static MonoString* GetIP ( DWORD pUserData ); + static DWORD GetAccount ( DWORD pUserData ); + static MonoString* GetVersion ( DWORD pUserData ); + static MonoObject* GetACInfo ( DWORD pUserData ); + + // Player set functions + static bool SetMoney ( DWORD pUserData, int iAmount, bool bInstant ); + static bool GiveMoney ( DWORD pUserData, int iAmount ); + static bool TakeMoney ( DWORD pUserData, int iAmount ); + static bool Spawn ( DWORD pUserData, MonoObject* vecPosition, int iRotation, int iSkinID, int iInterior, int iDimension, DWORD pTeam ); + static bool ShowHudComponent ( DWORD pUserData, MonoString* sComponent, bool bShow ); + static bool SetWantedLevel ( DWORD pUserData, int iLevel ); + static bool ForceMap ( DWORD pUserData, bool bForceOn ); + static bool SetNametagText ( DWORD pUserData, MonoString* sText ); + static bool SetNametagColor ( DWORD pUserData, int iRed, int iGreen, int iBlue ); + static bool SetNametagShowing ( DWORD pUserData, bool bShowing ); + static bool SetMuted ( DWORD pUserData, bool bMuted ); + static bool SetBlurLevel ( DWORD pUserData, int iLevel ); + static bool Redirect ( DWORD pUserData, MonoString* sServerIP, int iServerPort, MonoString* sServerPassword ); + static bool SetName ( DWORD pUserData, MonoString* sName ); + static bool DetonateSatchels ( DWORD pUserData ); + static bool TakeScreenShot ( DWORD pUserData, int iWidth, int iHeight, MonoString* sTag, int iQuality, int iMaxBandwith ); + static bool SetTeam ( DWORD pUserData, DWORD pTeam ); + + // Input funcs + static bool BindKey ( DWORD pUserData, MonoString* msKey, MonoString* msHitState, MonoString* msCommandName, MonoString* msArguments ); + static bool UnbindKey ( DWORD pUserData, MonoString* msKey, MonoString* msHitState, MonoString* msCommandName ); + static bool GetControlState ( DWORD pUserData, MonoString* msControl ); + static bool IsControlEnabled ( DWORD pUserData, MonoString* msControl ); + + static bool SetControlState ( DWORD pUserData, MonoString* msControl, bool bState ); + static bool ToggleControl ( DWORD pUserData, MonoString* msControl, bool bEnabled ); + static bool ToggleAllControls ( DWORD pUserData, bool bGTAControls, bool bMTAControls, bool bEnabled ); + + // Log in/out funcs + static bool LogIn ( DWORD pPlayer, DWORD pAccount, MonoString* msPassword ); + static bool LogOut ( DWORD pPlayer ); + + // Admin funcs + static bool Kick ( DWORD pPlayer, MonoString* msResponsible, MonoString* msReason ); + static DWORD Ban ( DWORD pPlayer, bool bIP, bool bUsername, bool bSerial, DWORD pResponsible, MonoString* msResponsible, MonoString* msReason, int iUnban ); + + // Cursor get funcs + static bool IsCursorShowing ( DWORD pPlayer ); + + // Cursor set funcs + static bool ShowCursor ( DWORD pPlayer, bool bShow, bool bToggleControls ); + + // Chat funcs + static bool ShowChat ( DWORD pPlayer, bool bShow ); + + // Camera get functions + static MonoObject* GetCameraMatrix ( DWORD pPlayer ); + static DWORD GetCameraTarget ( DWORD pPlayer ); + static unsigned char GetCameraInterior ( DWORD pPlayer ); + + // Camera set functions + static bool SetCameraMatrix ( DWORD pPlayer, MonoObject* pCameraMatrix ); + static bool SetCameraTarget ( DWORD pPlayer, DWORD pTarget ); + static bool SetCameraInterior ( DWORD pPlayer, unsigned char ucInterior ); + static bool FadeCamera ( DWORD pPlayer, bool bFadeIn, float fFadeTime, MonoObject* pColor ); + }; + + class Ped + { + public: + // Ped get functions + static DWORD Create ( int iModelid, MonoObject* pMonoPosition, float fRot, bool bSynced ); + static float GetArmor ( DWORD pUserData ); + static bool IsChoking ( DWORD pUserData ); + static bool IsDead ( DWORD pUserData ); + static bool IsDucked ( DWORD pUserData ); + static float GetStat ( DWORD pUserData, unsigned short usStat ); + static DWORD GetTarget ( DWORD pUserData ); + static int GetWeapon ( DWORD pUserData, int iWeaponSlot ); + static MonoString* GetClothesTexture ( DWORD pUserData, unsigned char ucType ); + static MonoString* GetClothesModel ( DWORD pUserData, unsigned char ucType ); + static bool DoesHaveJetPack ( DWORD pUserData ); + static bool IsOnGround ( DWORD pUserData ); + static unsigned char GetFightingStyle ( DWORD pUserData ); + static unsigned int GetMoveAnim ( DWORD pUserData ); + static float GetGravity ( DWORD pUserData ); + static DWORD GetContactElement ( DWORD pUserData ); + static unsigned char GetWeaponSlot ( DWORD pUserData ); + static bool IsDoingGangDriveby ( DWORD pUserData ); + static bool IsOnFire ( DWORD pUserData ); + static bool IsHeadless ( DWORD pUserData ); + static bool IsFrozen ( DWORD pUserData ); + static DWORD GetOccupiedVehicle ( DWORD pUserData ); + static unsigned int GetOccupiedVehicleSeat ( DWORD pUserData ); + static bool IsInVehicle ( DWORD pUserData ); + static short GetWeaponProperty ( unsigned char ucWeaponID, MonoString *msWeaponSkill, MonoString* msProperty ); + static short GetOriginalWeaponProperty ( unsigned char ucWeaponID, MonoString *msWeaponSkill, MonoString* msProperty ); + + // Ped set functions + static bool SetArmor ( DWORD pUserData, float fArmor ); + static bool Kill ( DWORD pUserData, DWORD pKiller, unsigned char ucKillerWeapon, unsigned char ucBodyPart, bool bStealth ); + static bool SetStat ( DWORD pUserData, unsigned short usStat, float fValue ); + static bool AddClothes ( DWORD pUserData, MonoString* msTexture, MonoString* msModel, unsigned char ucType ); + static bool RemoveClothes ( DWORD pUserData, unsigned char ucType, MonoString* msTexture, MonoString* msModel ); + static bool GiveJetPack ( DWORD pUserData ); + static bool RemoveJetPack ( DWORD pUserData ); + static bool SetFightingStyle ( DWORD pUserData, unsigned char ucStyle ); + static bool SetMoveAnim ( DWORD pUserData, unsigned int iMoveAnim ); + static bool SetGravity ( DWORD pUserData, float fGravity ); + static bool SetChoking ( DWORD pUserData, bool bChoking ); + static bool SetWeaponSlot ( DWORD pUserData, unsigned char ucWeaponSlot ); + static bool WarpIntoVehicle ( DWORD pUserData, DWORD pVehicle, unsigned int uiSeat ); + static bool RemoveFromVehicle ( DWORD pUserData ); + static bool SetDoingGangDriveby ( DWORD pUserData, bool bGangDriveby ); + static bool SetAnimation ( DWORD pUserData, MonoString* msBlockName, MonoString* msAnimName, int iTime, bool bLoop, bool bUpdatePosition, bool bInterruptable, bool bFreezeLastFrame ); + static bool SetAnimationProgress ( DWORD pUserData, MonoString* msAnimName, float fProgress ); + static bool SetOnFire ( DWORD pUserData, bool bIsOnFire ); + static bool SetHeadless ( DWORD pUserData, bool bIsHeadless ); + static bool SetFrozen ( DWORD pUserData, bool bIsFrozen ); + static bool ReloadWeapon ( DWORD pUserData ); + static bool SetWeaponProperty ( unsigned char ucWeaponID, MonoString *msWeaponSkill, MonoString* msProperty, short uData ); + + // Ped body? + static MonoString* GetBodyPartName ( unsigned char ucID ); + static MonoArray* GetClothesByTypeIndex ( unsigned char ucType, unsigned char ucIndex ); + static MonoArray* GetTypeIndexFromClothes ( MonoString* msTexture, MonoString* msModel ); + static MonoString* GetClothesTypeName ( unsigned char ucType ); + + // Weapon give/take functions + static bool GiveWeapon ( DWORD pPed, unsigned char ucWeaponID, unsigned short usAmmo, bool bSetAsCurrent = false ); + static bool TakeWeapon ( DWORD pPed, unsigned char ucWeaponID, unsigned short usAmmo = 9999 ); + static bool TakeAllWeapons ( DWORD pPed ); + static bool SetWeaponAmmo ( DWORD pPed, unsigned char ucWeaponID, unsigned short usAmmo, unsigned short usAmmoInClip ); + }; + class Vehicle { public: - static DWORD Create ( int model, MonoObject* position, MonoObject* rotation, MonoString* numberplate, bool direction = false, int variant1 = 255, int variant2 = 255 ); + // Vehicle create/destroy functions + static DWORD Create ( int model, MonoObject* position, MonoObject* rotation, MonoString* numberplate, bool direction = false, int variant1 = 255, int variant2 = 255 ); + + // Vehicle get functions + static MonoString* GetType ( DWORD pUserData ); + static MonoArray* GetVariant ( DWORD pUserData ); + static MonoObject* GetColor ( DWORD pUserData ); + static unsigned short GetModelFromName ( MonoString* msName ); + static bool GetLandingGearDown ( DWORD pUserData ); + static unsigned char GetMaxPassengers ( DWORD pUserData ); + static MonoString* GetName ( DWORD pUserData ); + static MonoString* GetNameFromModel ( unsigned short usModel ); + static DWORD GetOccupant ( DWORD pUserData, unsigned int uiSeat ); + static MonoArray* GetOccupants ( DWORD pUserData ); + static DWORD GetController ( DWORD pUserData ); + static bool GetSirensOn ( DWORD pUserData ); + static MonoObject* GetTurnVelocity ( DWORD pUserData ); + static MonoObject* GetTurretPosition ( DWORD pUserData ); + static bool IsLocked ( DWORD pUserData ); + static MonoArray* GetOfType ( unsigned int uiModel ); + static unsigned short GetUpgradeOnSlot ( DWORD pUserData, unsigned char ucSlot ); + static MonoArray* GetUpgrades ( DWORD pUserData ); +// static MonoString* GetUpgradeSlotName ( unsigned char ucSlot ); + static MonoString* GetUpgradeSlotName ( unsigned short usUpgrade ); + static MonoArray* GetCompatibleUpgrades ( DWORD pUserData ); + static unsigned char GetDoorState ( DWORD pUserData, unsigned char ucDoor ); + static MonoObject* GetWheelStates ( DWORD pUserData ); + static unsigned char GetLightState ( DWORD pUserData, unsigned char ucLight ); + static unsigned char GetPanelState ( DWORD pUserData, unsigned char ucPanel ); + static unsigned char GetOverrideLights ( DWORD pUserData ); + static DWORD GetTowedByVehicle ( DWORD pUserData ); + static DWORD GetTowingVehicle ( DWORD pUserData ); + static unsigned char GetPaintjob ( DWORD pUserData ); + static MonoString* GetPlateText ( DWORD pUserData ); + static bool IsDamageProof ( DWORD pUserData ); + static bool IsFuelTankExplodable ( DWORD pUserData ); + static bool IsFrozen ( DWORD pUserData ); + static bool IsOnGround ( DWORD pUserData ); + static bool GetEngineState ( DWORD pUserData ); + static bool IsTrainDerailed ( DWORD pUserData ); + static bool IsTrainDerailable ( DWORD pUserData ); + static bool GetTrainDirection ( DWORD pUserData ); + static float GetTrainSpeed ( DWORD pUserData ); + static bool IsBlown ( DWORD pUserData ); + static MonoObject* GetHeadLightColor ( DWORD pUserData ); + static float GetDoorOpenRatio ( DWORD pUserData, unsigned char ucDoor ); + static bool IsTaxiLightOn ( DWORD pUserData ); + + // Vehicle set functions + static bool Fix ( DWORD pUserData ); + static bool Blow ( DWORD pUserData, bool bExplode ); + static bool SetTurnVelocity ( DWORD pUserData, MonoObject* pVelocity ); + static bool SetColor ( DWORD pUserData, MonoObject* pColor1, MonoObject* pColor2, MonoObject* pColor3, MonoObject* pColor4 ); + static bool SetLandingGearDown ( DWORD pUserData, bool bLandingGearDown ); + static bool SetLocked ( DWORD pUserData, bool bLocked ); + static bool SetDoorsUndamageable ( DWORD pUserData, bool bDoorsUndamageable ); + static bool SetSirensOn ( DWORD pUserData, bool bSirensOn ); + static bool SetTaxiLightOn ( DWORD pUserData, bool bTaxiLightState ); + static bool AddUpgrade ( DWORD pUserData, unsigned short usUpgrade ); + static bool RemoveUpgrade ( DWORD pUserData, unsigned short usUpgrade ); + static bool SetDoorState ( DWORD pUserData, unsigned char ucDoor, unsigned char ucState ); + static bool SetWheelStates ( DWORD pUserData, int iFrontLeft, int iRearLeft, int iFrontRight, int iRearRight ); + static bool SetLightState ( DWORD pUserData, unsigned char ucLight, unsigned char ucState ); + static bool SetPanelState ( DWORD pUserData, unsigned char ucPanel, unsigned char ucState ); + static bool SetIdleRespawnDelay ( DWORD pUserData, unsigned long ulTime ); + static bool SetRespawnDelay ( DWORD pUserData, unsigned long ulTime ); + static bool SetRespawnPosition ( DWORD pUserData, MonoObject* pPosition, MonoObject* pRotation ); + static bool ToggleRespawn ( DWORD pUserData, bool bRespawn ); + static bool ResetExplosionTime ( DWORD pUserData ); + static bool ResetIdleTime ( DWORD pUserData ); + static bool Spawn ( DWORD pUserData, MonoObject* pPosition, MonoObject* pRotation ); + static bool Respawn ( DWORD pUserData ); + static bool SetOverrideLights ( DWORD pUserData, unsigned char ucLights ); + static bool AttachTrailer ( DWORD pUserData, DWORD pTrailer ); + static bool DetachTrailer ( DWORD pUserData, DWORD pTrailer ); + static bool SetEngineState ( DWORD pUserData, bool bState ); + static bool SetDirtLevel ( DWORD pUserData, float fDirtLevel ); + static bool SetDamageProof ( DWORD pUserData, bool bDamageProof ); + static bool SetPaintjob ( DWORD pUserData, unsigned char ucPaintjob ); + static bool SetFuelTankExplodable ( DWORD pUserData, bool bExplodable ); + static bool SetTrainDerailed ( DWORD pUserData, bool bDerailed ); + static bool SetTrainDerailable ( DWORD pUserData, bool bDerailable ); + static bool SetTrainDirection ( DWORD pUserData, bool bDireciton ); + static bool SetTrainSpeed ( DWORD pUserData, float fSpeed ); + static bool SetHeadLightColor ( DWORD pUserData, MonoObject* pColor ); + static bool SetTurretPosition ( DWORD pUserData, MonoObject* pPosition ); + static bool SetDoorOpenRatio ( DWORD pUserData, unsigned char ucDoor, float fRatio, unsigned long ulTime ); + static bool SetVariant ( DWORD pUserData, unsigned char ucVariant, unsigned char ucVariant2 ); + static bool GiveSirens ( DWORD pUserData, unsigned char ucSirenType, unsigned char ucSirenCount, bool bFlag360 = false, bool bCheckLosFlag = true, bool bUseRandomiserFlag = true, bool bSilentFlag = false ); + static bool RemoveSirens ( DWORD pUserData ); + static bool SetSirens ( DWORD pUserData, unsigned char ucSirenID, MonoObject* pPosition, MonoObject* pColor, float fMinAlpha ); + static MonoArray* GetSirens ( DWORD pUserData ); + static MonoObject* GetSirenParams ( DWORD pUserData ); + static bool SetPlateText ( DWORD pUserData, MonoString* msName ); + }; + + class Marker + { + public: + // Marker create/destroy functions + static DWORD Create ( MonoObject* pPosition, MonoString* szType, float fSize, MonoObject* color, DWORD pVisibleTo ); + + // Marker get functions + static unsigned int GetCount (); + static MonoString* GetType ( DWORD pUserData ); + static float GetSize ( DWORD pUserData ); + static MonoObject* GetColor ( DWORD pUserData ); + static MonoObject* GetTarget ( DWORD pUserData ); + static MonoString* GetIcon ( DWORD pUserData ); + + // Marker set functions + static bool SetType ( DWORD pUserData, MonoString* szType ); + static bool SetSize ( DWORD pUserData, float fSize ); + static bool SetColor ( DWORD pUserData, MonoObject* color ); + static bool SetTarget ( DWORD pUserData, MonoObject* pTarget ); + static bool SetIcon ( DWORD pUserData, MonoString* szIcon ); + }; + + class Blip + { + public: + // Blip create/destroy functions + static DWORD Create ( MonoObject* vecPosition, unsigned char ucIcon, unsigned char ucSize, MonoObject* color, short sOrdering, unsigned short usVisibleDistance, DWORD pVisibleTo ); + static DWORD CreateAttachedTo ( DWORD pTarget, unsigned char ucIcon, unsigned char ucSize, MonoObject* color, short sOrdering, unsigned short usVisibleDistance, DWORD pVisibleTo ); + + // Blip get functions + static unsigned char GetIcon ( DWORD pUserData ); + static unsigned char GetSize ( DWORD pUserData ); + static MonoObject* GetColor ( DWORD pUserData ); + static short GetOrdering ( DWORD pUserData ); + static unsigned short GetVisibleDistance ( DWORD pUserData ); + + // Blip set functions + static bool SetIcon ( DWORD pUserData, unsigned char ucIcon ); + static bool SetSize ( DWORD pUserData, unsigned char ucSize ); + static bool SetColor ( DWORD pUserData, MonoObject* color ); + static bool SetOrdering ( DWORD pUserData, short sOrdering ); + static bool SetVisibleDistance ( DWORD pUserData, unsigned short usVisibleDistance ); + }; + + class Object + { + public: + // Object create/destroy functions + static DWORD Create ( unsigned short usModelID, MonoObject* pPosition, MonoObject* pRotation, bool bIsLowLod ); + + // Object get functions + static MonoObject* GetScale ( DWORD pUserData ); + + // Object set functions + static bool SetScale ( DWORD pUserData, MonoObject* pScale ); + static bool Move ( DWORD pUserData, unsigned long ulTime, MonoObject* pPosition, MonoObject* pRotation, MonoString* msEasingType, float fEasingPeriod, float fEasingAmplitude, float fEasingOvershoot ); + static bool Stop ( DWORD pUserData ); + }; + + class RadarArea + { + public: + // Radar area create/destroy funcs + static DWORD Create ( MonoObject* pPosition, MonoObject* pSize, MonoObject* pColor, DWORD pVisibleTo ); + + // Radar area get funcs + static MonoObject* GetSize ( DWORD pUserData ); + static MonoObject* GetColor ( DWORD pUserData ); + static bool IsFlashing ( DWORD pUserData ); + static bool IsInside ( DWORD pUserData, MonoObject* pPosition ); + + // Radar area set funcs + static bool SetSize ( DWORD pUserData, MonoObject* pSize ); + static bool SetColor ( DWORD pUserData, MonoObject* pColor ); + static bool SetFlashing ( DWORD pUserData, bool bFlashing ); + }; + + class Pickup + { + public: + // Pickup create/destroy funcs + static DWORD Create ( MonoObject* pPosition, unsigned char ucType, double dFive, unsigned long ulRespawnInterval, double dSix ); + + // Pickup get funcs + static unsigned char GetType ( DWORD pUserData ); + static unsigned char GetWeapon ( DWORD pUserData ); + static float GetAmount ( DWORD pUserData ); + static unsigned short GetAmmo ( DWORD pUserData ); + static unsigned long GetRespawnInterval ( DWORD pUserData ); + static bool IsSpawned ( DWORD pUserData ); + + // Pickup set funcs + static bool SetType ( DWORD pUserData, unsigned char ucType, double dThree, double dFour ); + static bool SetRespawnInterval ( DWORD pUserData, unsigned long ulInterval ); + static bool Use ( DWORD pUserData, DWORD pPlayer ); + }; + + class Shape + { + public: + // Shape create funcs + static DWORD CreateCircle ( MonoObject* pPosition, float fRadius ); + static DWORD CreateCuboid ( MonoObject* pPosition, MonoObject* vecSize ); + static DWORD CreateSphere ( MonoObject* pPosition, float fRadius ); + static DWORD CreateRectangle ( MonoObject* pPosition, MonoObject* vecSize ); + static DWORD CreatePolygon ( MonoArray* vecPointList ); + static DWORD CreateTube ( MonoObject* pPosition, float fRadius, float fHeight ); + }; + + class Explosion + { + public: + // Explosion funcs + static bool Create ( MonoObject* pPosition, unsigned char ucType, DWORD pCreator ); + }; + + class Audio + { + public: + // Audio funcs + static bool PlayFrontEnd ( DWORD pUserData, unsigned char ucSound ); + static bool PlayMission ( DWORD pUserData, MonoObject* vecPosition, unsigned short usSlot ); + }; + + class Team + { + public: + // Team get funcs + static DWORD Create ( MonoString* msTeamName, MonoObject* pColor ); + static DWORD GetFromName ( MonoString* msTeamName ); + static MonoString* GetName ( DWORD pUserData ); + static MonoObject* GetColor ( DWORD pUserData ); + static unsigned int CountPlayers ( DWORD pUserData ); + static bool GetFriendlyFire ( DWORD pUserData ); + + // Team set funcs + static bool SetName ( DWORD pUserData, MonoString* msTeamName ); + static bool SetColor ( DWORD pUserData, MonoObject* pColor ); + static bool SetFriendlyFire ( DWORD pUserData, bool bFriendlyFire ); + }; + + class Water + { + public: + // Water funcs + static DWORD Create ( MonoObject* pV1, MonoObject* pV2, MonoObject* pV3, MonoObject* pV4, bool bShallow ); + static bool SetLevel ( DWORD pUserData, float fLevel ); + static bool SetLevelAll ( float fLevel ); + static bool SetLevelWorld ( float fLevel, bool bIncludeWorldNonSeaLevel ); + static bool ResetLevelWorld ( void ); + static MonoObject* GetVertexPosition ( DWORD pUserData, int iVertexIndex ); + static bool SetVertexPosition ( DWORD pUserData, int iVertexIndex, MonoObject* vecPosition ); + static MonoObject* GetColor ( void ); + static bool SetColor ( MonoObject* pColor ); + static bool ResetColor ( void ); + }; + + class World + { + public: + // General world get funcs + static MonoArray* GetTime ( void ); + static MonoArray* GetWeather ( void ); + static MonoString* GetZoneName ( MonoObject* vecPosition, bool bCitiesOnly ); + static float GetGravity ( void ); + static float GetGameSpeed ( void ); + static float GetWaveHeight ( void ); + static unsigned short GetFPSLimit ( void ); + static unsigned long GetMinuteDuration ( void ); + static bool IsGarageOpen ( unsigned char ucGarageID ); + static unsigned char GetTrafficLightState ( void ); + static bool GetTrafficLightsLocked ( void ); + static float GetJetpackMaxHeight ( void ); + static float GetAircraftMaxVelocity ( void ); + static bool GetInteriorSoundsEnabled ( void ); + static float GetRainLevel ( void ); + static float GetSunSize ( void ); + static MonoArray* GetSunColor ( void ); + static MonoObject* GetWindVelocity ( void ); + static float GetFarClipDistance ( void ); + static float GetFogDistance ( void ); + static float GetAircraftMaxHeight ( void ); + static bool GetOcclusionsEnabled ( void ); + static int GetMoonSize ( void ); + static MonoArray* GetSkyGradient ( void ); + static MonoObject* GetHeatHaze ( void ); + static bool GetJetpackWeaponEnabled ( unsigned int uiWeaponType ); + static bool GetCloudsEnabled ( void ); + + // General world set funcs + static bool SetTime ( unsigned char ucHour, unsigned char ucMinute ); + static bool SetWeather ( unsigned char ucWeather ); + static bool SetWeatherBlended ( unsigned char ucWeather ); + static bool SetGravity ( float fGravity ); + static bool SetGameSpeed ( float fSpeed ); + static bool SetWaveHeight ( float fHeight ); + static bool SetSkyGradient ( MonoObject* pTopColor, MonoObject* pBottomColor ); + static bool ResetSkyGradient ( void ); + static bool SetHeatHaze ( MonoObject* heatHazeSettings ); + static bool ResetHeatHaze ( void ); + static bool SetFPSLimit ( unsigned short usLimit, bool bSave ); + static bool SetMinuteDuration ( unsigned long ulDuration ); + static bool SetGarageOpen ( unsigned char ucGarageID, bool bIsOpen ); + static bool SetGlitchEnabled ( MonoString* msGlitchName, bool bEnabled ); + static bool IsGlitchEnabled ( MonoString* msGlitchName ); + static bool SetJetpackWeaponEnabled ( unsigned int uiWeaponType, bool bEnabled ); + static bool SetCloudsEnabled ( bool bEnabled ); + static bool SetTrafficLightState ( unsigned char ucState, bool bForced = false ); + static bool SetTrafficLightsLocked ( bool bLocked ); + static bool SetJetpackMaxHeight ( float fMaxHeight ); + static bool SetInteriorSoundsEnabled ( bool bEnable ); + static bool SetRainLevel ( float fRainLevel ); + static bool SetSunSize ( float fSunSize ); + static bool SetSunColor ( MonoObject* pCoreColor, MonoObject* pCoronaColor ); + static bool SetWindVelocity ( MonoObject* pVelocity ); + static bool SetFarClipDistance ( float fFarClip ); + static bool SetFogDistance ( float fFogDist ); + static bool SetAircraftMaxHeight ( float fMaxHeight ); + static bool SetAircraftMaxVelocity ( float fVelocity ); + static bool SetOcclusionsEnabled ( bool bEnabled ); + static bool ResetRainLevel ( void ); + static bool ResetSunSize ( void ); + static bool ResetSunColor ( void ); + static bool ResetWindVelocity ( void ); + static bool ResetFarClipDistance ( void ); + static bool ResetFogDistance ( void ); + static bool RemoveWorldModel ( unsigned short usModel, float fRadius, MonoObject* vecPosition, char cInterior ); + static bool RestoreWorldModel ( unsigned short usModel, float fRadius, MonoObject* vecPosition, char cInterior ); + static bool RestoreAllWorldModels ( void ); + static bool SetMoonSize ( int iMoonSize ); + static bool ResetMoonSize ( void ); + }; + + class Account + { + public: + // Account get funcs + static DWORD Get ( MonoString* msName, MonoString* msPassword ); + static MonoArray* GetAll ( void ); + static DWORD GetPlayer ( DWORD pAccount ); + static bool IsGuest ( DWORD pAccount ); + // static CLuaArgument* GetData ( DWORD pAccount, MonoString* szKey ); + // static MonoArray* GetAllData ( DWORD pAccount ); + static MonoString* GetSerial ( DWORD pAccount ); + // static MonoArray* GetBySerial ( MonoString* msSerial ); + + // Account set funcs + static DWORD Add ( MonoString* msName, MonoString* msPassword ); + static bool Remove ( DWORD pAccount ); + static bool SetPassword ( DWORD pAccount, MonoString* msPassword ); + // static bool SetData ( DWORD pAccount, MonoString* msKey, CLuaArgument* pArgument ); + static bool CopyData ( DWORD pAccount, DWORD pFromAccount ); + }; + + class Ban + { + public: + static DWORD Add ( MonoString* msIP, MonoString* msUsername, MonoString* msSerial, DWORD pResponsible, MonoString* msResponsible, MonoString* msReason, int iUnban ); + static bool Remove ( DWORD pBan, DWORD pResponsible ); + + // static MonoArray* GetBans ( void ); + static bool Reload ( void ); + + static MonoString* GetIP ( DWORD pBan ); + static MonoString* GetSerial ( DWORD pBan ); + static MonoString* GetUsername ( DWORD pBan ); + static MonoString* GetNick ( DWORD pBan ); + static MonoString* GetReason ( DWORD pBan ); + static MonoString* GetAdmin ( DWORD pBan ); + + static int GetBanTime ( DWORD pBan ); + static int GetUnbanTime ( DWORD pBan ); + + static bool SetUnbanTime ( DWORD pBan, int time ); + static bool SetReason ( DWORD pBan, MonoString* msReason ); + static bool SetAdmin ( DWORD pBan, MonoString* msAdminName ); + }; + + class Resource + { + public: + // Resource funcs + static DWORD Create ( MonoString* msResourceName, MonoString* msOrganizationalDir ); + static DWORD Copy ( DWORD pResource, MonoString* msNewResourceName, MonoString* msOrganizationalDir ); + static DWORD GetRootElement ( DWORD pResource = NULL ); + static DWORD GetMapRootElement ( MonoString* msMap ); + static DWORD GetDynamicElementRoot ( DWORD pResource ); + // static CXMLNode* AddMap ( MonoString* msFilePath, MonoString* msMapName, int iDimension ); + // static CXMLNode* AddConfig ( MonoString* msFilePath, MonoString* msConfigName, int iType ); + static bool RemoveFile ( MonoString* msFilename ); + // static CXMLNode AddConfig ( MonoString* msFilePath, MonoString* msFileType ); + // static CXMLNode AddMap ( MonoString* msFilePath, unsigned int uiDimension = 0 ); + // static CXMLNode GetConfig ( MonoString* msFilePath ); + // static CLuaArguments* GetExportedFunctions ( DWORD pResource ); + static DWORD GetFromName ( MonoString* msResourceName ); + static MonoString* GetInfo ( DWORD pResource, MonoString* msAttribute ); + static unsigned int GetLastStartTime ( DWORD pResource ); + static MonoString* GetLoadFailureReason ( DWORD pResource ); + static unsigned int GetLoadTime ( DWORD pResource ); + static MonoString* GetName ( DWORD pResource ); + static MonoArray* GetResources ( void ); + static MonoString* GetState ( DWORD pResource ); + static DWORD GetCurrent ( void ); + static bool Refresh ( bool refreshAll = false ); + static bool RemoveDefaultSetting ( DWORD pResource, MonoString* msSettingName ); + static bool Start ( DWORD pResource, bool persistent = false, bool startIncludedResources = true, bool loadServerConfigs = true, bool loadMaps = true, bool loadServerScripts = true, bool loadHTML = true, bool loadClientConfigs = true, bool loadClientScripts = true, bool loadFiles = true ); + static bool Restart ( DWORD pResource ); + static bool Stop ( DWORD pResource ); + static bool SetDefaultSetting ( DWORD pResource, MonoString* msSettingName, MonoString* msSettingValue ); + // static bool SetDefaultSetting ( DWORD pResource, MonoString* msSettingName, int iSettingValue ); + // static bool SetDefaultSetting ( DWORD pResource, MonoString* msSettingName, float fSettingValue ); + static bool SetInfo ( DWORD pResource, MonoString* msAttribute, MonoString* msValue ); + static bool Rename ( MonoString* msResourceName, MonoString* msNewResourceName, MonoString* msOrganizationalPath ); + static bool Delete ( MonoString* msResourceName ); + // static CLuaArguments* GetACLRequests ( DWORD pResource ); + static bool UpdateACLRequest ( DWORD pResource, MonoString* msRightName, bool bAccess, MonoString* msByWho ); }; }; diff --git a/mta-mono/src/CMonoFunctions_Account.cpp b/mta-mono/src/CMonoFunctions_Account.cpp new file mode 100644 index 0000000..5857dd0 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Account.cpp @@ -0,0 +1,125 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Account get funcs +DWORD CMonoFunctions::Account::Get( MonoString* msName, MonoString* msPassword ) +{ + if( RESOURCE ) + { + const char* szName = mono_string_to_utf8( msName ); + const char* szPassword = mono_string_to_utf8( msPassword ); + + return (DWORD)CLuaFunctionDefinitions::GetAccount( RESOURCE->GetLua(), szName, szPassword ); + } + + return NULL; +} + +MonoArray* CMonoFunctions::Account::GetAll( void ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaTable = CLuaFunctionDefinitions::GetAccounts( RESOURCE->GetLua() ); + + return RESOURCE->NewArray( mono_get_uint32_class(), pLuaTable ); + } + + return NULL; +} + +DWORD CMonoFunctions::Account::GetPlayer( DWORD pAccount ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetAccountPlayer( RESOURCE->GetLua(), (void*)pAccount ); + } + + return NULL; +} + +bool CMonoFunctions::Account::IsGuest( DWORD pAccount ) +{ + if( RESOURCE ) + { + bool bIsGuest; + + if( CLuaFunctionDefinitions::IsGuestAccount( RESOURCE->GetLua(), (void*)pAccount, bIsGuest ) ) + { + return bIsGuest; + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Account::GetSerial( DWORD pAccount ) +{ + if( RESOURCE ) + { + string strSerial; + + if( CLuaFunctionDefinitions::GetAccountSerial( RESOURCE->GetLua(), (void*)pAccount, strSerial ) ) + { + return RESOURCE->NewString( strSerial ); + } + } + + return NULL; +} + +// Account set funcs +DWORD CMonoFunctions::Account::Add( MonoString* msName, MonoString* msPassword ) +{ + if( RESOURCE ) + { + const char* szName = mono_string_to_utf8( msName ); + const char* szPassword = mono_string_to_utf8( msPassword ); + + return (DWORD)CLuaFunctionDefinitions::AddAccount( RESOURCE->GetLua(), szName, szPassword ); + } + + return NULL; +} + +bool CMonoFunctions::Account::Remove( DWORD pAccount ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RemoveAccount( RESOURCE->GetLua(), (void*)pAccount ); + } + + return NULL; +} + +bool CMonoFunctions::Account::SetPassword( DWORD pAccount, MonoString* msPassword ) +{ + if( RESOURCE ) + { + const char* szPassword = mono_string_to_utf8( msPassword ); + + return CLuaFunctionDefinitions::SetAccountPassword( RESOURCE->GetLua(), (void*)pAccount, szPassword ); + } + + return NULL; +} + +bool CMonoFunctions::Account::CopyData( DWORD pAccount, DWORD pFromAccount ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::CopyAccountData( RESOURCE->GetLua(), (void*)pAccount, (void*)pFromAccount ); + } + + return NULL; +} diff --git a/mta-mono/src/CMonoFunctions_Audio.cpp b/mta-mono/src/CMonoFunctions_Audio.cpp new file mode 100644 index 0000000..ea3cd44 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Audio.cpp @@ -0,0 +1,36 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Audio funcs +bool CMonoFunctions::Audio::PlayFrontEnd( DWORD pUserData, unsigned char ucSound ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::PlaySoundFrontEnd( RESOURCE->GetLua(), (void*)pUserData, ucSound ); + } + + return false; +} + +bool CMonoFunctions::Audio::PlayMission( DWORD pUserData, MonoObject* pPosition, unsigned short usSlot ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + + return CLuaFunctionDefinitions::PlayMissionAudio( RESOURCE->GetLua(), (void*)pUserData, vecPosition, usSlot ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Ban.cpp b/mta-mono/src/CMonoFunctions_Ban.cpp new file mode 100644 index 0000000..a9b4638 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Ban.cpp @@ -0,0 +1,208 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +DWORD CMonoFunctions::Ban::Add( MonoString* msIP, MonoString* msUsername, MonoString* msSerial, DWORD pResponsible, MonoString* msResponsible, MonoString* msReason, int iUnban ) +{ + if( RESOURCE ) + { + string + strIP( mono_string_to_utf8( msIP ) ), + strUsername( mono_string_to_utf8( msUsername ) ), + strSerial( mono_string_to_utf8( msSerial ) ), + strResponsible( mono_string_to_utf8( msResponsible ) ), + strReason( mono_string_to_utf8( msReason ) ); + + return (DWORD)CLuaFunctionDefinitions::AddBan( RESOURCE->GetLua(), strIP, strUsername, strSerial, (void*)pResponsible, strResponsible, strReason, iUnban ); + } + + return NULL; +} + +bool CMonoFunctions::Ban::Remove( DWORD pBan, DWORD pResponsible ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::RemoveBan( RESOURCE->GetLua(), (void*)pBan, (void*)pResponsible ); + } + + return false; +} + + +bool CMonoFunctions::Ban::Reload( void ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::ReloadBanList( RESOURCE->GetLua() ); + } + + return false; +} + + +MonoString* CMonoFunctions::Ban::GetIP( DWORD pBan ) +{ + if( RESOURCE ) + { + string strIP; + + if( CLuaFunctionDefinitions::GetBanIP( RESOURCE->GetLua(), (void*)pBan, strIP ) ) + { + return RESOURCE->NewString( strIP ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Ban::GetSerial( DWORD pBan ) +{ + if( RESOURCE ) + { + string strSerial; + + if( CLuaFunctionDefinitions::GetBanSerial( RESOURCE->GetLua(), (void*)pBan, strSerial ) ) + { + return RESOURCE->NewString( strSerial ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Ban::GetUsername( DWORD pBan ) +{ + if( RESOURCE ) + { + string strUsername; + + if( CLuaFunctionDefinitions::GetBanUsername( RESOURCE->GetLua(), (void*)pBan, strUsername ) ) + { + return RESOURCE->NewString( strUsername ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Ban::GetNick( DWORD pBan ) +{ + if( RESOURCE ) + { + string strNick; + + if( CLuaFunctionDefinitions::GetBanNick( RESOURCE->GetLua(), (void*)pBan, strNick ) ) + { + return RESOURCE->NewString( strNick ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Ban::GetReason( DWORD pBan ) +{ + if( RESOURCE ) + { + string strReason; + + if( CLuaFunctionDefinitions::GetBanReason( RESOURCE->GetLua(), (void*)pBan, strReason ) ) + { + return RESOURCE->NewString( strReason ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Ban::GetAdmin( DWORD pBan ) +{ + if( RESOURCE ) + { + string strAdmin; + + if( CLuaFunctionDefinitions::GetBanAdmin( RESOURCE->GetLua(), (void*)pBan, strAdmin ) ) + { + return RESOURCE->NewString( strAdmin ); + } + } + + return NULL; +} + + +int CMonoFunctions::Ban::GetBanTime( DWORD pBan ) +{ + if( RESOURCE ) + { + time_t tTime; + + if( CLuaFunctionDefinitions::GetBanTime( RESOURCE->GetLua(), (void*)pBan, tTime ) ) + { + return (int)tTime; + } + } + + return 0; +} + +int CMonoFunctions::Ban::GetUnbanTime( DWORD pBan ) +{ + if( RESOURCE ) + { + time_t tTime; + + if( CLuaFunctionDefinitions::GetUnbanTime( RESOURCE->GetLua(), (void*)pBan, tTime ) ) + { + return (int)tTime; + } + } + + return 0; +} + + +bool CMonoFunctions::Ban::SetUnbanTime( DWORD pBan, int time ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetUnbanTime( RESOURCE->GetLua(), (void*)pBan, time ); + } + + return false; +} + +bool CMonoFunctions::Ban::SetReason( DWORD pBan, MonoString* msReason ) +{ + if( RESOURCE ) + { + string strReason( mono_string_to_utf8( msReason ) ); + + return CLuaFunctionDefinitions::SetBanReason( RESOURCE->GetLua(), (void*)pBan, strReason ); + } + + return false; +} + +bool CMonoFunctions::Ban::SetAdmin( DWORD pBan, MonoString* msAdminName ) +{ + if( RESOURCE ) + { + string strAdmin( mono_string_to_utf8( msAdminName ) ); + + return CLuaFunctionDefinitions::SetBanAdmin( RESOURCE->GetLua(), (void*)pBan, strAdmin ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Blip.cpp b/mta-mono/src/CMonoFunctions_Blip.cpp new file mode 100644 index 0000000..13027c1 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Blip.cpp @@ -0,0 +1,176 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Blip create/destroy functions +DWORD CMonoFunctions::Blip::Create( MonoObject* pPosition, unsigned char ucIcon, unsigned char ucSize, MonoObject* color, short sOrdering, unsigned short usVisibleDistance, DWORD pVisibleTo ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + + SColor pColor = CMonoObject( color ).GetColor(); + + return (DWORD)CLuaFunctionDefinitions::CreateBlip( RESOURCE->GetLua(), vecPosition, ucIcon, ucSize, pColor, sOrdering, usVisibleDistance, (void*)pVisibleTo ); + } + + return NULL; +} + +DWORD CMonoFunctions::Blip::CreateAttachedTo( DWORD pTarget, unsigned char ucIcon, unsigned char ucSize, MonoObject* color, short sOrdering, unsigned short usVisibleDistance, DWORD pVisibleTo ) +{ + if( RESOURCE ) + { + SColor pColor = CMonoObject( color ).GetColor(); + + return (DWORD)CLuaFunctionDefinitions::CreateBlipAttachedTo( RESOURCE->GetLua(), (void*)pTarget, ucIcon, ucSize, pColor, sOrdering, usVisibleDistance, (void*)pVisibleTo ); + } + + return NULL; +} + + +// Blip get functions +unsigned char CMonoFunctions::Blip::GetIcon( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucIcon; + + if( CLuaFunctionDefinitions::GetBlipIcon( RESOURCE->GetLua(), (void*)pUserData, ucIcon ) ) + { + return ucIcon; + } + } + + return 0; +} + +unsigned char CMonoFunctions::Blip::GetSize( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucSize; + + if( CLuaFunctionDefinitions::GetBlipSize( RESOURCE->GetLua(), (void*)pUserData, ucSize ) ) + { + return ucSize; + } + } + + return 0; +} + +MonoObject* CMonoFunctions::Blip::GetColor( DWORD pUserData ) +{ + if( RESOURCE ) + { + SColor outColor; + + if( CLuaFunctionDefinitions::GetBlipColor( RESOURCE->GetLua(), (void*)pUserData, outColor ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( outColor ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +short CMonoFunctions::Blip::GetOrdering( DWORD pUserData ) +{ + if( RESOURCE ) + { + short sOrdering; + + if( CLuaFunctionDefinitions::GetBlipOrdering( RESOURCE->GetLua(), (void*)pUserData, sOrdering ) ) + { + return sOrdering; + } + } + + return 0; +} + +unsigned short CMonoFunctions::Blip::GetVisibleDistance( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned short usVisibleDistance; + + if( CLuaFunctionDefinitions::GetBlipVisibleDistance( RESOURCE->GetLua(), (void*)pUserData, usVisibleDistance ) ) + { + return usVisibleDistance; + } + } + + return 0; +} + + +// Blip set functions +bool CMonoFunctions::Blip::SetIcon( DWORD pUserData, unsigned char ucIcon ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetBlipIcon( RESOURCE->GetLua(), (void*)pUserData, ucIcon ); + } + + return false; +} + +bool CMonoFunctions::Blip::SetSize( DWORD pUserData, unsigned char ucSize ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetBlipSize( RESOURCE->GetLua(), (void*)pUserData, ucSize ); + } + + return false; +} + +bool CMonoFunctions::Blip::SetColor( DWORD pUserData, MonoObject* color ) +{ + if( RESOURCE ) + { + SColor pColor = CMonoObject( color ).GetColor(); + + return CLuaFunctionDefinitions::SetBlipColor( RESOURCE->GetLua(), (void*)pUserData, pColor ); + } + + return false; +} + +bool CMonoFunctions::Blip::SetOrdering( DWORD pUserData, short sOrdering ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetBlipOrdering( RESOURCE->GetLua(), (void*)pUserData, sOrdering ); + } + + return false; +} + +bool CMonoFunctions::Blip::SetVisibleDistance( DWORD pUserData, unsigned short usVisibleDistance ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetBlipVisibleDistance( RESOURCE->GetLua(), (void*)pUserData, usVisibleDistance ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Element.cpp b/mta-mono/src/CMonoFunctions_Element.cpp new file mode 100644 index 0000000..025bbdf --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Element.cpp @@ -0,0 +1,775 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Element create/destroy + +DWORD CMonoFunctions::Element::Create( MonoString* msTypeName, MonoString* msID ) +{ + if( RESOURCE ) + { + const char* szTypeName = mono_string_to_utf8( msTypeName ); + const char* szID = mono_string_to_utf8( msID ); + + return (DWORD)CLuaFunctionDefinitions::CreateElement( RESOURCE->GetLua(), szTypeName, szID ); + } + + return NULL; +} + +bool CMonoFunctions::Element::Destroy( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::DestroyElement( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +DWORD CMonoFunctions::Element::Clone( DWORD pUserData, MonoObject* vecPosition, bool bCloneElement ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( vecPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + return (DWORD)CLuaFunctionDefinitions::CloneElement( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ), bCloneElement ); + } + + return false; +} + +// Element get funcs + +MonoArray* CMonoFunctions::Element::GetByType( MonoString* msType, DWORD pStartElement ) +{ + if( RESOURCE ) + { + const char* szType = mono_string_to_utf8( msType ); + + CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetElementsByType( RESOURCE->GetLua(), szType, (void*)pStartElement ); + + return RESOURCE->NewArray( mono_get_uint32_class(), pLuaArguments ); + } + + return NULL; +} + +bool CMonoFunctions::Element::IsElement( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (unsigned int)CLuaFunctionDefinitions::IsElement( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +MonoString* CMonoFunctions::Element::GetType( DWORD pUserData ) +{ + if( RESOURCE ) + { + const string strType = CLuaFunctionDefinitions::GetElementType( RESOURCE->GetLua(), (void*)pUserData ); + + return mono_string_new( mono_domain_get(), strType.c_str() ); + } + + return mono_string_new( mono_domain_get(), "" ); +} + +DWORD CMonoFunctions::Element::GetByID( MonoString* msID, unsigned int uiIndex ) +{ + if( RESOURCE ) + { + const char* szID = mono_string_to_utf8( msID ); + + return (DWORD)CLuaFunctionDefinitions::GetElementByID( RESOURCE->GetLua(), szID, uiIndex ); + } + + return NULL; +} + +DWORD CMonoFunctions::Element::GetByIndex( int iIndex ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetElementByIndex( RESOURCE->GetLua(), iIndex ); + } + + return NULL; +} + +DWORD CMonoFunctions::Element::GetChild( DWORD pUserData, int iIndex ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetElementChild( RESOURCE->GetLua(), (void*)pUserData, iIndex ); + } + + return NULL; +} + +int CMonoFunctions::Element::GetChildrenCount( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GetElementChildrenCount( RESOURCE->GetLua(), (void*)pUserData ); + } + + return 0; +} + +MonoString* CMonoFunctions::Element::GetID( DWORD pUserData ) +{ + if( RESOURCE ) + { + const string strID = CLuaFunctionDefinitions::GetElementID( RESOURCE->GetLua(), (void*)pUserData ); + + return mono_string_new( mono_domain_get(), strID.c_str() ); + } + + return mono_string_new( mono_domain_get(), "" ); +} + +unsigned int CMonoFunctions::Element::GetParent( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (unsigned int)CLuaFunctionDefinitions::GetElementParent( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +MonoObject* CMonoFunctions::Element::GetPosition( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecPosition; + + if( CLuaFunctionDefinitions::GetElementPosition( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecPosition ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Element::GetRotation( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecPosition; + + if( CLuaFunctionDefinitions::GetElementRotation( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecPosition ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Element::GetVelocity( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecPosition; + + if( CLuaFunctionDefinitions::GetElementVelocity( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecPosition ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +unsigned char CMonoFunctions::Element::GetInterior( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucInterior; + + if( CLuaFunctionDefinitions::GetElementInterior( RESOURCE->GetLua(), (void*)pUserData, ucInterior ) ) + { + return ucInterior; + } + } + + return 0; +} + +bool CMonoFunctions::Element::IsWithinColShape( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bWithin; + + if( CLuaFunctionDefinitions::IsElementWithinColShape( RESOURCE->GetLua(), (void*)pUserData, bWithin ) ) + { + return bWithin; + } + } + + return false; +} + +bool CMonoFunctions::Element::IsWithinMarker( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bWithin; + + if( CLuaFunctionDefinitions::IsElementWithinMarker( RESOURCE->GetLua(), (void*)pUserData, bWithin ) ) + { + return bWithin; + } + } + + return false; +} + +unsigned short CMonoFunctions::Element::GetDimension( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned short usDimension; + + if( CLuaFunctionDefinitions::GetElementDimension( RESOURCE->GetLua(), (void*)pUserData, usDimension ) ) + { + return usDimension; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Element::GetZoneName( DWORD pUserData, bool bCitiesOnly ) +{ + if( RESOURCE ) + { + string strOutName; + + if( CLuaFunctionDefinitions::GetElementZoneName( RESOURCE->GetLua(), (void*)pUserData, strOutName, bCitiesOnly ) ) + { + return RESOURCE->NewString( strOutName ); + } + } + + return NULL; +} + +bool CMonoFunctions::Element::IsAttached( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::IsElementAttached( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +DWORD CMonoFunctions::Element::GetAttachedTo( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetElementAttachedTo( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +DWORD CMonoFunctions::Element::GetColShape( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetElementColShape( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +unsigned char CMonoFunctions::Element::GetAlpha( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucAlpha; + + if( CLuaFunctionDefinitions::GetElementAlpha( RESOURCE->GetLua(), (void*)pUserData, ucAlpha ) ) + { + return ucAlpha; + } + } + + return 0; +} + +bool CMonoFunctions::Element::IsDoubleSided( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDoubleSided; + + if( CLuaFunctionDefinitions::IsElementDoubleSided( RESOURCE->GetLua(), (void*)pUserData, bDoubleSided ) ) + { + return bDoubleSided; + } + } + + return false; +} + +float CMonoFunctions::Element::GetHealth( DWORD pUserData ) +{ + if( RESOURCE ) + { + float fHealth; + + if( CLuaFunctionDefinitions::GetElementHealth( RESOURCE->GetLua(), (void*)pUserData, fHealth ) ) + { + return fHealth; + } + } + + return false; +} + +unsigned short CMonoFunctions::Element::GetModel( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned short usModel; + + if( CLuaFunctionDefinitions::GetElementModel( RESOURCE->GetLua(), (void*)pUserData, usModel ) ) + { + return usModel; + } + } + + return false; +} + +bool CMonoFunctions::Element::IsInWater( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bInWater; + + if( CLuaFunctionDefinitions::IsElementInWater( RESOURCE->GetLua(), (void*)pUserData, bInWater ) ) + { + return bInWater; + } + } + + return false; +} + +MonoObject* CMonoFunctions::Element::GetAttachedOffsetPosition( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecPosition, vecRotation; + + if( CLuaFunctionDefinitions::GetElementAttachedOffsets( RESOURCE->GetLua(), (void*)pUserData, vecPosition, vecRotation ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecPosition ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Element::GetAttachedOffsetRotation( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecPosition, vecRotation; + + if( CLuaFunctionDefinitions::GetElementAttachedOffsets( RESOURCE->GetLua(), (void*)pUserData, vecPosition, vecRotation ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecRotation ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +DWORD CMonoFunctions::Element::GetSyncer( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetElementSyncer( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +bool CMonoFunctions::Element::GetCollisionsEnabled( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GetElementCollisionsEnabled( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Element::IsFrozen( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bFrozen; + + if( CLuaFunctionDefinitions::IsElementFrozen( RESOURCE->GetLua(), (void*)pUserData, bFrozen ) ) + { + return bFrozen; + } + } + + return false; +} + +DWORD CMonoFunctions::Element::GetLowLod( DWORD pUserData ) +{ + if( RESOURCE ) + { + void* pUserData; + + if( CLuaFunctionDefinitions::GetLowLodElement( RESOURCE->GetLua(), (void*)pUserData, pUserData ) ) + { + return (DWORD)pUserData; + } + } + + return NULL; +} + +bool CMonoFunctions::Element::IsLowLod( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bIsLowLod; + + if( CLuaFunctionDefinitions::IsElementLowLod( RESOURCE->GetLua(), (void*)pUserData, bIsLowLod ) ) + { + return bIsLowLod; + } + } + + return false; +} + +// Element set funcs + +bool CMonoFunctions::Element::ClearVisibleTo( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ClearElementVisibleTo( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Element::SetID( DWORD pUserData, MonoString* msID ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementID( RESOURCE->GetLua(), (void*)pUserData, string( mono_string_to_utf8( msID ) ) ); + } + + return false; +} + +bool CMonoFunctions::Element::SetData( DWORD pUserData, MonoString* msKey, CLuaArgument& Variable ) +{ + if( RESOURCE ) + { + string strKey( mono_string_to_utf8( msKey ) ); + + return CLuaFunctionDefinitions::SetElementData( RESOURCE->GetLua(), (void*)pUserData, strKey, Variable ); + } + + return false; +} + +bool CMonoFunctions::Element::RemoveData( DWORD pUserData, MonoString* msKey ) +{ + if( RESOURCE ) + { + string strKey( mono_string_to_utf8( msKey ) ); + + return CLuaFunctionDefinitions::RemoveElementData( RESOURCE->GetLua(), (void*)pUserData, strKey ); + } + + return false; +} + +bool CMonoFunctions::Element::SetParent( DWORD pUserData, DWORD pTarget ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementParent( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget ); + } + + return false; +} + +bool CMonoFunctions::Element::SetPosition( DWORD pUserData, MonoObject* pPosition, bool bWarp ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + return CLuaFunctionDefinitions::SetElementPosition( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ), bWarp ); + } + + return false; +} + +bool CMonoFunctions::Element::SetRotation( DWORD pUserData, MonoObject* pRotation, MonoString* msRotationOrder, bool bNewWay ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pRotation ); + + float fX = pPosition.GetPropertyValue( "X" ); + float fY = pPosition.GetPropertyValue( "Y" ); + float fZ = pPosition.GetPropertyValue( "Z" ); + + const char* szRotationOrder = mono_string_to_utf8( msRotationOrder ); + + return CLuaFunctionDefinitions::SetElementRotation( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ), szRotationOrder, bNewWay ); + } + + return false; +} + +bool CMonoFunctions::Element::SetVelocity( DWORD pUserData, MonoObject* pVelocity ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pVelocity ); + + float fX = pPosition.GetPropertyValue( "X" ); + float fY = pPosition.GetPropertyValue( "Y" ); + float fZ = pPosition.GetPropertyValue( "Z" ); + + return CLuaFunctionDefinitions::SetElementVelocity( RESOURCE->GetLua(), (void*)pUserData, Vector3( fX, fY, fZ ) ); + } + + return false; +} + +bool CMonoFunctions::Element::SetVisibleTo( DWORD pUserData, DWORD pTarget, bool bVisible ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementVisibleTo( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget, bVisible ); + } + + return false; +} + +bool CMonoFunctions::Element::SetInterior( DWORD pUserData, int iInterior ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementInterior( RESOURCE->GetLua(), (void*)pUserData, iInterior ); + } + + return false; +} + +bool CMonoFunctions::Element::SetDimension( DWORD pUserData, int iDimension ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementDimension( RESOURCE->GetLua(), (void*)pUserData, iDimension ); + } + + return false; +} + +bool CMonoFunctions::Element::Attach( DWORD pUserData, DWORD pTarget, MonoObject* pMonoPosition, MonoObject* pMonoRotation ) +{ + if( RESOURCE ) + { + Vector3 + vecPosition, vecRotation; + + CMonoObject + pPosition( pMonoPosition ), pRotation( pMonoRotation ); + + vecPosition.fX = pPosition.GetPropertyValue( "X" ); + vecPosition.fY = pPosition.GetPropertyValue( "Y" ); + vecPosition.fZ = pPosition.GetPropertyValue( "Z" ); + + vecRotation.fX = pRotation.GetPropertyValue( "X" ); + vecRotation.fY = pRotation.GetPropertyValue( "Y" ); + vecRotation.fZ = pRotation.GetPropertyValue( "Z" ); + + return CLuaFunctionDefinitions::AttachElements( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget, vecPosition, vecRotation ); + } + + return false; +} + +bool CMonoFunctions::Element::Detach( DWORD pUserData, DWORD pTarget ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::DetachElements( RESOURCE->GetLua(), (void*)pUserData, (void*)pTarget ); + } + + return false; +} + +bool CMonoFunctions::Element::SetAlpha( DWORD pUserData, int iAlpha ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementAlpha( RESOURCE->GetLua(), (void*)pUserData, iAlpha ); + } + + return false; +} + +bool CMonoFunctions::Element::SetDoubleSided( DWORD pUserData, bool bDoubleSided ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementDoubleSided( RESOURCE->GetLua(), (void*)pUserData, bDoubleSided ); + } + + return false; +} + +bool CMonoFunctions::Element::SetHealth( DWORD pUserData, float fHealth ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementHealth( RESOURCE->GetLua(), (void*)pUserData, fHealth ); + } + + return false; +} + +bool CMonoFunctions::Element::SetModel( DWORD pUserData, int iModel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementModel( RESOURCE->GetLua(), (void*)pUserData, iModel ); + } + + return false; +} + +bool CMonoFunctions::Element::SetAttachedOffsets( DWORD pUserData, MonoObject* pMonoPosition, MonoObject* pMonoRotation ) +{ + if( RESOURCE ) + { + Vector3 + vecPosition, vecRotation; + + CMonoObject + pPosition( pMonoPosition ), pRotation( pMonoRotation ); + + vecPosition.fX = pPosition.GetPropertyValue( "X" ); + vecPosition.fY = pPosition.GetPropertyValue( "Y" ); + vecPosition.fZ = pPosition.GetPropertyValue( "Z" ); + + vecRotation.fX = pRotation.GetPropertyValue( "X" ); + vecRotation.fY = pRotation.GetPropertyValue( "Y" ); + vecRotation.fZ = pRotation.GetPropertyValue( "Z" ); + + return CLuaFunctionDefinitions::SetElementAttachedOffsets( RESOURCE->GetLua(), (void*)pUserData, vecPosition, vecRotation ); + } + + return false; +} + +bool CMonoFunctions::Element::SetSyncer( DWORD pUserData, DWORD pPlayer ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementSyncer( RESOURCE->GetLua(), (void*)pUserData, (void*)pPlayer ); + } + + return false; +} + +bool CMonoFunctions::Element::SetCollisionsEnabled( DWORD pUserData, bool bEnabled ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementCollisionsEnabled( RESOURCE->GetLua(), (void*)pUserData, bEnabled ); + } + + return false; +} + +bool CMonoFunctions::Element::SetFrozen( DWORD pUserData, bool bFrozen ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementFrozen( RESOURCE->GetLua(), (void*)pUserData, bFrozen ); + } + + return false; +} + +bool CMonoFunctions::Element::SetLowLod( DWORD pUserData, bool bEnabled ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetLowLodElement( RESOURCE->GetLua(), (void*)pUserData, bEnabled ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Explosion.cpp b/mta-mono/src/CMonoFunctions_Explosion.cpp new file mode 100644 index 0000000..add3477 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Explosion.cpp @@ -0,0 +1,26 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Explosion funcs +bool CMonoFunctions::Explosion::Create( MonoObject* pPosition, unsigned char ucType, DWORD pCreator ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + + return (DWORD)CLuaFunctionDefinitions::CreateExplosion( RESOURCE->GetLua(), vecPosition, ucType, (void*)pCreator ); + } + + return NULL; +} \ No newline at end of file diff --git a/mta-mono/src/CMonoFunctions_Marker.cpp b/mta-mono/src/CMonoFunctions_Marker.cpp new file mode 100644 index 0000000..cb02003 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Marker.cpp @@ -0,0 +1,218 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Marker create/destroy functions +DWORD CMonoFunctions::Marker::Create( MonoObject* pPosition, MonoString* msType, float fSize, MonoObject* pColor, DWORD pVisibleTo ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + Vector3 vecPosition( fX, fY, fZ ); + + const char* szType = mono_string_to_utf8( msType ); + + CMonoObject pMonoColor( pColor ); + + SColor pColor; + + pColor.R = pMonoColor.GetPropertyValue< unsigned char >( "R" ); + pColor.G = pMonoColor.GetPropertyValue< unsigned char >( "G" ); + pColor.B = pMonoColor.GetPropertyValue< unsigned char >( "B" ); + pColor.A = pMonoColor.GetPropertyValue< unsigned char >( "A" ); + + return (DWORD)CLuaFunctionDefinitions::CreateMarker( RESOURCE->GetLua(), vecPosition, szType, fSize, pColor, (void*)pVisibleTo ); + } + + return NULL; +} + + +// Marker get functions +unsigned int CMonoFunctions::Marker::GetCount() +{ + if( RESOURCE ) + { + unsigned int uiCount; + + if( CLuaFunctionDefinitions::GetMarkerCount( RESOURCE->GetLua(), uiCount ) ) + { + return uiCount; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Marker::GetType( DWORD pUserData ) +{ + if( RESOURCE ) + { + char* szType = NULL; + + if( CLuaFunctionDefinitions::GetMarkerType( RESOURCE->GetLua(), (void*)pUserData, szType ) ) + { + return RESOURCE->NewString( szType ); + } + } + + return NULL; +} + +float CMonoFunctions::Marker::GetSize( DWORD pUserData ) +{ + if( RESOURCE ) + { + float fSize; + + if( CLuaFunctionDefinitions::GetMarkerSize( RESOURCE->GetLua(), (void*)pUserData, fSize ) ) + { + return fSize; + } + } + + return 0.0f; +} + +MonoObject* CMonoFunctions::Marker::GetColor( DWORD pUserData ) +{ + if( RESOURCE ) + { + SColor outColor; + + if( CLuaFunctionDefinitions::GetMarkerColor( RESOURCE->GetLua(), (void*)pUserData, outColor ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( outColor ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Marker::GetTarget( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecPosition; + + if( CLuaFunctionDefinitions::GetMarkerTarget( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecPosition ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Marker::GetIcon( DWORD pUserData ) +{ + if( RESOURCE ) + { + char* szIcon = NULL; + + if( CLuaFunctionDefinitions::GetMarkerIcon( RESOURCE->GetLua(), (void*)pUserData, szIcon ) ) + { + return RESOURCE->NewString( szIcon ); + } + } + + return NULL; +} + + +// Marker set functions +bool CMonoFunctions::Marker::SetType( DWORD pUserData, MonoString* msType ) +{ + if( RESOURCE ) + { + const char* szType = mono_string_to_utf8( msType ); + + return CLuaFunctionDefinitions::SetMarkerType( RESOURCE->GetLua(), (void*)pUserData, szType ); + } + + return false; +} + +bool CMonoFunctions::Marker::SetSize( DWORD pUserData, float fSize ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetMarkerSize( RESOURCE->GetLua(), (void*)pUserData, fSize ); + } + + return false; +} + +bool CMonoFunctions::Marker::SetColor( DWORD pUserData, MonoObject* color ) +{ + if( RESOURCE ) + { + SColor pColor; + + CMonoObject pMonoColor( color ); + + pColor.R = pMonoColor.GetPropertyValue< unsigned char >( "R" ); + pColor.G = pMonoColor.GetPropertyValue< unsigned char >( "G" ); + pColor.B = pMonoColor.GetPropertyValue< unsigned char >( "B" ); + pColor.A = pMonoColor.GetPropertyValue< unsigned char >( "A" ); + + return CLuaFunctionDefinitions::SetMarkerColor( RESOURCE->GetLua(), (void*)pUserData, pColor ); + } + + return false; +} + +bool CMonoFunctions::Marker::SetTarget( DWORD pUserData, MonoObject* pTarget ) +{ + if( RESOURCE ) + { + Vector3* vecPosition = new Vector3; + + CMonoObject pTarget( pTarget ); + + vecPosition->fX = pTarget.GetPropertyValue< float >( "X" ); + vecPosition->fY = pTarget.GetPropertyValue< float >( "Y" ); + vecPosition->fZ = pTarget.GetPropertyValue< float >( "Z" ); + + return CLuaFunctionDefinitions::SetMarkerTarget( RESOURCE->GetLua(), (void*)pUserData, vecPosition ); + } + + return false; +} + +bool CMonoFunctions::Marker::SetIcon( DWORD pUserData, MonoString* msIcon ) +{ + if( RESOURCE ) + { + const char* szIcon = mono_string_to_utf8( msIcon ); + + return CLuaFunctionDefinitions::SetMarkerType( RESOURCE->GetLua(), (void*)pUserData, szIcon ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Object.cpp b/mta-mono/src/CMonoFunctions_Object.cpp new file mode 100644 index 0000000..cb774da --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Object.cpp @@ -0,0 +1,118 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Object create/destroy functions +DWORD CMonoFunctions::Object::Create( unsigned short usModelID, MonoObject* pPosition, MonoObject* pRotation, bool bIsLowLod ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + Vector3 vecPosition( fX, fY, fZ ); + + CMonoObject pRotation( pRotation ); + + float fRX = pRotation.GetPropertyValue< float >( "X" ); + float fRY = pRotation.GetPropertyValue< float >( "Y" ); + float fRZ = pRotation.GetPropertyValue< float >( "Z" ); + + Vector3 vecRotation( fRX, fRY, fRZ ); + + return (DWORD)CLuaFunctionDefinitions::CreateObject( RESOURCE->GetLua(), usModelID, vecPosition, vecRotation, bIsLowLod ); + } + + return NULL; +} + + +// Object get functions +MonoObject* CMonoFunctions::Object::GetScale( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecScale; + + if( CLuaFunctionDefinitions::GetObjectScale( RESOURCE->GetLua(), (void*)pUserData, vecScale ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecScale ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + + +// Object set functions +bool CMonoFunctions::Object::SetScale( DWORD pUserData, MonoObject* pScale ) +{ + if( RESOURCE ) + { + Vector3 vecScale; + + CMonoObject pScale( pScale ); + + vecScale.fX = pScale.GetPropertyValue< float >( "X" ); + vecScale.fY = pScale.GetPropertyValue< float >( "Y" ); + vecScale.fZ = pScale.GetPropertyValue< float >( "Z" ); + + return CLuaFunctionDefinitions::SetObjectScale( RESOURCE->GetLua(), (void*)pUserData, vecScale ); + } + + return false; +} + +bool CMonoFunctions::Object::Move( DWORD pUserData, unsigned long ulTime, MonoObject* pPosition, MonoObject* pRotation, MonoString* msEasingType, float fEasingPeriod, float fEasingAmplitude, float fEasingOvershoot ) +{ + if( RESOURCE ) + { + Vector3 vecPosition, vecRotation; + + CMonoObject pPosition( pPosition ); + + vecPosition.fX = pPosition.GetPropertyValue< float >( "X" ); + vecPosition.fY = pPosition.GetPropertyValue< float >( "Y" ); + vecPosition.fZ = pPosition.GetPropertyValue< float >( "Z" ); + + CMonoObject pRotation( pRotation ); + + vecRotation.fX = pRotation.GetPropertyValue< float >( "X" ); + vecRotation.fY = pRotation.GetPropertyValue< float >( "Y" ); + vecRotation.fZ = pRotation.GetPropertyValue< float >( "Z" ); + + const char* szEasingType = mono_string_to_utf8( msEasingType ); + + return CLuaFunctionDefinitions::MoveObject( RESOURCE->GetLua(), (void*)pUserData, ulTime, vecPosition, vecRotation, szEasingType, fEasingPeriod, fEasingAmplitude, fEasingOvershoot ); + } + + return false; +} + +bool CMonoFunctions::Object::Stop( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::StopObject( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Ped.cpp b/mta-mono/src/CMonoFunctions_Ped.cpp new file mode 100644 index 0000000..3848652 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Ped.cpp @@ -0,0 +1,758 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#ifndef _CMONO_FUNCS_PED +#define _CMONO_FUNCS_PED + +#include "CMonoFunctions.h" + +// Ped get functions +DWORD CMonoFunctions::Ped::Create( int iModelid, MonoObject* pMonoPosition, float fRot, bool bSynced ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pMonoPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + Vector3 vecPosition( fX, fY, fZ ); + + return (DWORD)CLuaFunctionDefinitions::CreatePed( RESOURCE->GetLua(), iModelid, vecPosition, fRot, bSynced ); + } + + return NULL; +} + +float CMonoFunctions::Ped::GetArmor( DWORD pUserData ) +{ + if( RESOURCE ) + { + float fArmor; + + if( CLuaFunctionDefinitions::GetPedArmor( RESOURCE->GetLua(), (void*)pUserData, fArmor ) ) + { + return fArmor; + } + } + + return 0.0f; +} + +bool CMonoFunctions::Ped::IsChoking( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bChoking; + + if( CLuaFunctionDefinitions::IsPedChoking( RESOURCE->GetLua(), (void*)pUserData, bChoking ) ) + { + return bChoking; + } + } + + return false; +} + +bool CMonoFunctions::Ped::IsDead( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDead; + + if( CLuaFunctionDefinitions::IsPedDead( RESOURCE->GetLua(), (void*)pUserData, bDead ) ) + { + return bDead; + } + } + + return false; +} + +bool CMonoFunctions::Ped::IsDucked( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDucked; + + if( CLuaFunctionDefinitions::IsPedDucked( RESOURCE->GetLua(), (void*)pUserData, bDucked ) ) + { + return bDucked; + } + } + + return false; +} + +float CMonoFunctions::Ped::GetStat( DWORD pUserData, unsigned short usStat ) +{ + if( RESOURCE ) + { + float fStat; + + if( CLuaFunctionDefinitions::GetPedStat( RESOURCE->GetLua(), (void*)pUserData, usStat, fStat ) ) + { + return fStat; + } + } + + return 0.0f; +} + +DWORD CMonoFunctions::Ped::GetTarget( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetPedTarget( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +int CMonoFunctions::Ped::GetWeapon( DWORD pUserData, int iWeaponSlot ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GetPedWeapon( RESOURCE->GetLua(), (void*)pUserData, iWeaponSlot ); + } + + return NULL; +} + +MonoString* CMonoFunctions::Ped::GetClothesTexture( DWORD pUserData, unsigned char ucType ) +{ + if( RESOURCE ) + { + string strOutTexture, strOutModel; + + if( CLuaFunctionDefinitions::GetPedClothes( RESOURCE->GetLua(), (void*)pUserData, ucType, strOutTexture, strOutModel ) ) + { + return RESOURCE->NewString( strOutTexture ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Ped::GetClothesModel( DWORD pUserData, unsigned char ucType ) +{ + if( RESOURCE ) + { + string strOutTexture, strOutModel; + + if( CLuaFunctionDefinitions::GetPedClothes( RESOURCE->GetLua(), (void*)pUserData, ucType, strOutTexture, strOutModel ) ) + { + return RESOURCE->NewString( strOutModel ); + } + } + + return NULL; +} + +bool CMonoFunctions::Ped::DoesHaveJetPack( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bHasJetPack; + + if( CLuaFunctionDefinitions::DoesPedHaveJetPack( RESOURCE->GetLua(), (void*)pUserData, bHasJetPack ) ) + { + return bHasJetPack; + } + } + + return false; +} + +bool CMonoFunctions::Ped::IsOnGround( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bOnGround; + + if( CLuaFunctionDefinitions::IsPedOnGround( RESOURCE->GetLua(), (void*)pUserData, bOnGround ) ) + { + return bOnGround; + } + } + + return false; +} + +unsigned char CMonoFunctions::Ped::GetFightingStyle( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucStyle; + + if( CLuaFunctionDefinitions::GetPedFightingStyle( RESOURCE->GetLua(), (void*)pUserData, ucStyle ) ) + { + return ucStyle; + } + } + + return 0; +} + +unsigned int CMonoFunctions::Ped::GetMoveAnim( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned int uiMoveAnim; + + if( CLuaFunctionDefinitions::GetPedMoveAnim( RESOURCE->GetLua(), (void*)pUserData, uiMoveAnim ) ) + { + return uiMoveAnim; + } + } + + return 0; +} + +float CMonoFunctions::Ped::GetGravity( DWORD pUserData ) +{ + if( RESOURCE ) + { + float fGravity; + + if( CLuaFunctionDefinitions::GetPedGravity( RESOURCE->GetLua(), (void*)pUserData, fGravity ) ) + { + return fGravity; + } + } + + return 0.0f; +} + +DWORD CMonoFunctions::Ped::GetContactElement( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetPedContactElement( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +unsigned char CMonoFunctions::Ped::GetWeaponSlot( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucWeaponSlot; + + if( CLuaFunctionDefinitions::GetPedWeaponSlot( RESOURCE->GetLua(), (void*)pUserData, ucWeaponSlot ) ) + { + return ucWeaponSlot; + } + } + + return 0; +} + +bool CMonoFunctions::Ped::IsDoingGangDriveby( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDoingGangDriveby; + + if( CLuaFunctionDefinitions::IsPedDoingGangDriveby( RESOURCE->GetLua(), (void*)pUserData, bDoingGangDriveby ) ) + { + return bDoingGangDriveby; + } + } + + return false; +} + +bool CMonoFunctions::Ped::IsOnFire( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bOnFire; + + if( CLuaFunctionDefinitions::IsPedOnFire( RESOURCE->GetLua(), (void*)pUserData, bOnFire ) ) + { + return bOnFire; + } + } + + return false; +} + +bool CMonoFunctions::Ped::IsHeadless( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bHeadless; + + if( CLuaFunctionDefinitions::IsPedHeadless( RESOURCE->GetLua(), (void*)pUserData, bHeadless ) ) + { + return bHeadless; + } + } + + return false; +} + +bool CMonoFunctions::Ped::IsFrozen( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bFrozen; + + if( CLuaFunctionDefinitions::IsPedFrozen( RESOURCE->GetLua(), (void*)pUserData, bFrozen ) ) + { + return bFrozen; + } + } + + return false; +} + +DWORD CMonoFunctions::Ped::GetOccupiedVehicle( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetPedOccupiedVehicle( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +unsigned int CMonoFunctions::Ped::GetOccupiedVehicleSeat( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned int uiSeat; + + if( CLuaFunctionDefinitions::GetPedOccupiedVehicleSeat( RESOURCE->GetLua(), (void*)pUserData, uiSeat ) ) + { + return uiSeat; + } + } + + return 0; +} + +bool CMonoFunctions::Ped::IsInVehicle( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bInVehicle; + + if( CLuaFunctionDefinitions::IsPedInVehicle( RESOURCE->GetLua(), (void*)pUserData, bInVehicle ) ) + { + return bInVehicle; + } + } + + return false; +} + +short CMonoFunctions::Ped::GetWeaponProperty( unsigned char ucWeaponID, MonoString *msWeaponSkill, MonoString* msProperty ) +{ + if( RESOURCE ) + { + short uData; + + const char* szWeaponSkill = mono_string_to_utf8( msWeaponSkill ); + const char* szProperty = mono_string_to_utf8( msProperty ); + + if( CLuaFunctionDefinitions::GetWeaponProperty( RESOURCE->GetLua(), ucWeaponID, szWeaponSkill, szProperty, uData ) ) + { + return uData; + } + } + + return 0; +} + +short CMonoFunctions::Ped::GetOriginalWeaponProperty( unsigned char ucWeaponID, MonoString *msWeaponSkill, MonoString* msProperty ) +{ + if( RESOURCE ) + { + short uData; + + const char* szWeaponSkill = mono_string_to_utf8( msWeaponSkill ); + const char* szProperty = mono_string_to_utf8( msProperty ); + + if( CLuaFunctionDefinitions::GetOriginalWeaponProperty( RESOURCE->GetLua(), ucWeaponID, szWeaponSkill, szProperty, uData ) ) + { + return uData; + } + } + + return 0; +} + + +// Ped set functions +bool CMonoFunctions::Ped::SetArmor( DWORD pUserData, float fArmor ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedArmor( RESOURCE->GetLua(), (void*)pUserData, fArmor ); + } + + return false; +} + +bool CMonoFunctions::Ped::Kill( DWORD pUserData, DWORD pKiller, unsigned char ucKillerWeapon, unsigned char ucBodyPart, bool bStealth ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::KillPed( RESOURCE->GetLua(), (void*)pUserData, (void*)pKiller, ucKillerWeapon, ucBodyPart, bStealth ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetStat( DWORD pUserData, unsigned short usStat, float fValue ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedStat( RESOURCE->GetLua(), (void*)pUserData, usStat, fValue ); + } + + return false; +} + +bool CMonoFunctions::Ped::AddClothes( DWORD pUserData, MonoString* msTexture, MonoString* msModel, unsigned char ucType ) +{ + if( RESOURCE ) + { + const char* szTexture = mono_string_to_utf8( msTexture ); + const char* szModel = mono_string_to_utf8( msModel ); + + return CLuaFunctionDefinitions::AddPedClothes( RESOURCE->GetLua(), (void*)pUserData, szTexture, szModel, ucType ); + } + + return false; +} + +bool CMonoFunctions::Ped::RemoveClothes( DWORD pUserData, unsigned char ucType, MonoString* msTexture, MonoString* msModel ) +{ + if( RESOURCE ) + { + const char* szTexture = mono_string_to_utf8( msTexture ); + const char* szModel = mono_string_to_utf8( msModel ); + + return CLuaFunctionDefinitions::RemovePedClothes( RESOURCE->GetLua(), (void*)pUserData, ucType, szTexture, szModel ); + } + + return false; +} + +bool CMonoFunctions::Ped::GiveJetPack( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GivePedJetPack( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Ped::RemoveJetPack( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RemovePedJetPack( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetFightingStyle( DWORD pUserData, unsigned char ucStyle ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedFightingStyle( RESOURCE->GetLua(), (void*)pUserData, ucStyle ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetMoveAnim( DWORD pUserData, unsigned int iMoveAnim ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedMoveAnim( RESOURCE->GetLua(), (void*)pUserData, iMoveAnim ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetGravity( DWORD pUserData, float fGravity ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedGravity( RESOURCE->GetLua(), (void*)pUserData, fGravity ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetChoking( DWORD pUserData, bool bChoking ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedChoking( RESOURCE->GetLua(), (void*)pUserData, bChoking ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetWeaponSlot( DWORD pUserData, unsigned char ucWeaponSlot ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedWeaponSlot( RESOURCE->GetLua(), (void*)pUserData, ucWeaponSlot ); + } + + return false; +} + +bool CMonoFunctions::Ped::WarpIntoVehicle( DWORD pUserData, DWORD pVehicle, unsigned int uiSeat ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::WarpPedIntoVehicle( RESOURCE->GetLua(), (void*)pUserData, (void*)pVehicle, uiSeat ); + } + + return false; +} + +bool CMonoFunctions::Ped::RemoveFromVehicle( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RemovePedFromVehicle( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetDoingGangDriveby( DWORD pUserData, bool bGangDriveby ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedDoingGangDriveby( RESOURCE->GetLua(), (void*)pUserData, bGangDriveby ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetAnimation( DWORD pUserData, MonoString* msBlockName, MonoString* msAnimName, int iTime, bool bLoop, bool bUpdatePosition, bool bInterruptable, bool bFreezeLastFrame ) +{ + if( RESOURCE ) + { + const char* szBlockName = mono_string_to_utf8( msBlockName ); + const char* szAnimName = mono_string_to_utf8( msAnimName ); + + return CLuaFunctionDefinitions::SetPedAnimation( RESOURCE->GetLua(), (void*)pUserData, szBlockName, szAnimName, iTime, bLoop, bUpdatePosition, bInterruptable, bFreezeLastFrame ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetAnimationProgress( DWORD pUserData, MonoString* msAnimName, float fProgress ) +{ + if( RESOURCE ) + { + const char* szAnimName = mono_string_to_utf8( msAnimName ); + + return CLuaFunctionDefinitions::SetPedAnimationProgress( RESOURCE->GetLua(), (void*)pUserData, szAnimName, fProgress ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetOnFire( DWORD pUserData, bool bIsOnFire ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedOnFire( RESOURCE->GetLua(), (void*)pUserData, bIsOnFire ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetHeadless( DWORD pUserData, bool bIsHeadless ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedHeadless( RESOURCE->GetLua(), (void*)pUserData, bIsHeadless ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetFrozen( DWORD pUserData, bool bIsFrozen ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPedFrozen( RESOURCE->GetLua(), (void*)pUserData, bIsFrozen ); + } + + return false; +} + +bool CMonoFunctions::Ped::ReloadWeapon( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ReloadPedWeapon( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetWeaponProperty( unsigned char ucWeaponID, MonoString* msWeaponSkill, MonoString* msProperty, short uData ) +{ + if( RESOURCE ) + { + const char* szWeaponSkill = mono_string_to_utf8( msWeaponSkill ); + const char* szProperty = mono_string_to_utf8( msProperty ); + + return CLuaFunctionDefinitions::SetWeaponProperty( RESOURCE->GetLua(), ucWeaponID, szWeaponSkill, szProperty, uData ); + } + + return false; +} + + +// Ped body? +MonoString* CMonoFunctions::Ped::GetBodyPartName( unsigned char ucID ) +{ + if( RESOURCE ) + { + char* szName = NULL; + + if( CLuaFunctionDefinitions::GetBodyPartName( RESOURCE->GetLua(), ucID, szName ) ) + { + return RESOURCE->NewString( szName ); + } + } + + return NULL; +} + +MonoArray* CMonoFunctions::Ped::GetClothesByTypeIndex( unsigned char ucType, unsigned char ucIndex ) +{ + if( RESOURCE ) + { + char* szTexture = NULL; + char* szModel = NULL; + + if( CLuaFunctionDefinitions::GetClothesByTypeIndex( RESOURCE->GetLua(), ucType, ucIndex, szTexture, szModel ) ) + { + MonoArray* pArray = mono_array_new( RESOURCE->m_pMonoDomain, mono_get_string_class(), 2 ); + + if( pArray ) + { + mono_array_set( pArray, MonoString*, 0, RESOURCE->NewString( szTexture ) ); + mono_array_set( pArray, MonoString*, 1, RESOURCE->NewString( szModel ) ); + + return pArray; + } + } + } + + return NULL; +} + +MonoArray* CMonoFunctions::Ped::GetTypeIndexFromClothes( MonoString* msTexture, MonoString* msModel ) +{ + if( RESOURCE ) + { + const char* szTexture = mono_string_to_utf8( msTexture ); + const char* szModel = mono_string_to_utf8( msModel ); + + unsigned char ucType, ucIndex; + + if( CLuaFunctionDefinitions::GetTypeIndexFromClothes( RESOURCE->GetLua(), szTexture, szModel, ucType, ucIndex ) ) + { + MonoArray* pArray = mono_array_new( RESOURCE->m_pMonoDomain, mono_get_char_class(), 2 ); + + if( pArray ) + { + mono_array_set( pArray, unsigned char, 0, ucType ); + mono_array_set( pArray, unsigned char, 1, ucIndex ); + + return pArray; + } + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Ped::GetClothesTypeName( unsigned char ucType ) +{ + if( RESOURCE ) + { + char* szName = NULL; + + if( CLuaFunctionDefinitions::GetClothesTypeName( RESOURCE->GetLua(), ucType, szName ) ) + { + return RESOURCE->NewString( szName ); + } + } + + return NULL; +} + + +// Weapon give/take functions +bool CMonoFunctions::Ped::GiveWeapon( DWORD pPed, unsigned char ucWeaponID, unsigned short usAmmo, bool bSetAsCurrent ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GiveWeapon( RESOURCE->GetLua(), (void*)pPed, ucWeaponID, usAmmo, bSetAsCurrent ); + } + + return false; +} + +bool CMonoFunctions::Ped::TakeWeapon( DWORD pPed, unsigned char ucWeaponID, unsigned short usAmmo ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::TakeWeapon( RESOURCE->GetLua(), (void*)pPed, ucWeaponID, usAmmo ); + } + + return false; +} + +bool CMonoFunctions::Ped::TakeAllWeapons( DWORD pPed ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::TakeAllWeapons( RESOURCE->GetLua(), (void*)pPed ); + } + + return false; +} + +bool CMonoFunctions::Ped::SetWeaponAmmo( DWORD pPed, unsigned char ucWeaponID, unsigned short usAmmo, unsigned short usAmmoInClip ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetWeaponAmmo( RESOURCE->GetLua(), (void*)pPed, ucWeaponID, usAmmo, usAmmoInClip ); + } + + return false; +} + +#endif \ No newline at end of file diff --git a/mta-mono/src/CMonoFunctions_Pickup.cpp b/mta-mono/src/CMonoFunctions_Pickup.cpp new file mode 100644 index 0000000..8d2ee76 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Pickup.cpp @@ -0,0 +1,156 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Pickup create/destroy funcs +DWORD CMonoFunctions::Pickup::Create( MonoObject* pPosition, unsigned char ucType, double dFive, unsigned long ulRespawnInterval, double dSix ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + Vector3 vecPosition( fX, fY, fZ ); + + return (DWORD)CLuaFunctionDefinitions::CreatePickup( RESOURCE->GetLua(), vecPosition, ucType, dFive, ulRespawnInterval, dSix ); + } + + return NULL; +} + + +// Pickup get funcs +unsigned char CMonoFunctions::Pickup::GetType( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucType; + + if( CLuaFunctionDefinitions::GetPickupType( RESOURCE->GetLua(), (void*)pUserData, ucType ) ) + { + return ucType; + } + } + + return 0; +} + +unsigned char CMonoFunctions::Pickup::GetWeapon( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucWeapon; + + if( CLuaFunctionDefinitions::GetPickupWeapon( RESOURCE->GetLua(), (void*)pUserData, ucWeapon ) ) + { + return ucWeapon; + } + } + + return 0; +} + +float CMonoFunctions::Pickup::GetAmount( DWORD pUserData ) +{ + if( RESOURCE ) + { + float fAmount; + + if( CLuaFunctionDefinitions::GetPickupAmount( RESOURCE->GetLua(), (void*)pUserData, fAmount ) ) + { + return fAmount; + } + } + + return 0; +} + +unsigned short CMonoFunctions::Pickup::GetAmmo( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned short usAmmo; + + if( CLuaFunctionDefinitions::GetPickupAmmo( RESOURCE->GetLua(), (void*)pUserData, usAmmo ) ) + { + return usAmmo; + } + } + + return 0; +} + +unsigned long CMonoFunctions::Pickup::GetRespawnInterval( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned long ulInterval; + + if( CLuaFunctionDefinitions::GetPickupRespawnInterval( RESOURCE->GetLua(), (void*)pUserData, ulInterval ) ) + { + return ulInterval; + } + } + + return 0; +} + +bool CMonoFunctions::Pickup::IsSpawned( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bSpawned; + + if( CLuaFunctionDefinitions::IsPickupSpawned( RESOURCE->GetLua(), (void*)pUserData, bSpawned ) ) + { + return bSpawned; + } + } + + return false; +} + + +// Pickup set funcs +bool CMonoFunctions::Pickup::SetType( DWORD pUserData, unsigned char ucType, double dThree, double dFour ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPickupType( RESOURCE->GetLua(), (void*)pUserData, ucType, dThree, dFour ); + } + + return false; +} + +bool CMonoFunctions::Pickup::SetRespawnInterval( DWORD pUserData, unsigned long ulInterval ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPickupRespawnInterval( RESOURCE->GetLua(), (void*)pUserData, ulInterval ); + } + + return false; +} + +bool CMonoFunctions::Pickup::Use( DWORD pUserData, DWORD pPlayer ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::UsePickup( RESOURCE->GetLua(), (void*)pUserData, (void*)pPlayer ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Player.cpp b/mta-mono/src/CMonoFunctions_Player.cpp new file mode 100644 index 0000000..9090582 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Player.cpp @@ -0,0 +1,880 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#ifndef _CMONO_FUNCS_PLAYER +#define _CMONO_FUNCS_PLAYER + +#include "CMonoFunctions.h" + +// Player get functions +unsigned int CMonoFunctions::Player::GetCount( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GetPlayerCount( RESOURCE->GetLua() ); + } + + return 0; +} + +DWORD CMonoFunctions::Player::GetFromName( MonoString* msNick ) +{ + if( RESOURCE ) + { + const char* szNick = mono_string_to_utf8( msNick ); + + return (DWORD)CLuaFunctionDefinitions::GetPlayerFromName( RESOURCE->GetLua(), szNick ); + } + + return NULL; +} + +unsigned int CMonoFunctions::Player::GetPing( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned int uiPing; + + if( CLuaFunctionDefinitions::GetPlayerPing( RESOURCE->GetLua(), (void*)pUserData, uiPing ) ) + { + return uiPing; + } + } + + return 0; +} + +long CMonoFunctions::Player::GetMoney( DWORD pUserData ) +{ + if( RESOURCE ) + { + long lMoney; + + if( CLuaFunctionDefinitions::GetPlayerMoney( RESOURCE->GetLua(), (void*)pUserData, lMoney ) ) + { + return lMoney; + } + } + + return 0; +} + +DWORD CMonoFunctions::Player::GetRandom( void ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetRandomPlayer( RESOURCE->GetLua() ); + } + + return 0; +} + +bool CMonoFunctions::Player::IsMuted( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bMuted; + + if( CLuaFunctionDefinitions::IsPlayerMuted( RESOURCE->GetLua(), (void*)pUserData, bMuted ) ) + { + return bMuted; + } + } + + return 0; +} + +DWORD CMonoFunctions::Player::GetTeam( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetPlayerTeam( RESOURCE->GetLua(), (void*)pUserData ); + } + + return 0; +} + +unsigned int CMonoFunctions::Player::GetWantedLevel( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned int uiWantedLevel; + + if( CLuaFunctionDefinitions::GetPlayerWantedLevel( RESOURCE->GetLua(), (void*)pUserData, uiWantedLevel ) ) + { + return uiWantedLevel; + } + } + + return 0; +} + +MonoArray* CMonoFunctions::Player::GetAlivePlayers( void ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetAlivePlayers( RESOURCE->GetLua() ); + + if( pLuaArguments ) + { + MonoArray* pArray = mono_array_new( RESOURCE->m_pMonoDomain, mono_get_uint32_class(), pLuaArguments->Count() ); + + vector< CLuaArgument* >::const_iterator iter = pLuaArguments->IterBegin(); + + for( unsigned int i = 0; iter != pLuaArguments->IterEnd(); iter++, i++ ) + { + mono_array_set( pArray, DWORD, i, (DWORD)( *iter )->GetLightUserData() ); + } + + return pArray; + } + } + + return NULL; +} + +MonoArray* CMonoFunctions::Player::GetDeadPlayers( void ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetDeadPlayers( RESOURCE->GetLua() ); + + if( pLuaArguments ) + { + MonoArray* pArray = mono_array_new( RESOURCE->m_pMonoDomain, mono_get_uint32_class(), pLuaArguments->Count() ); + + vector< CLuaArgument* >::const_iterator iter = pLuaArguments->IterBegin(); + + for( unsigned int i = 0; iter != pLuaArguments->IterEnd(); iter++, i++ ) + { + mono_array_set( pArray, DWORD, i, (DWORD)( *iter )->GetLightUserData() ); + } + + return pArray; + } + } + + return NULL; +} + +unsigned int CMonoFunctions::Player::GetIdleTime( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned int uiIdleTime; + + if( CLuaFunctionDefinitions::GetPlayerIdleTime( RESOURCE->GetLua(), (void*)pUserData, uiIdleTime ) ) + { + return uiIdleTime; + } + } + + return 0; +} + +bool CMonoFunctions::Player::IsMapForced( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bForced; + + if( CLuaFunctionDefinitions::IsPlayerMapForced( RESOURCE->GetLua(), (void*)pUserData, bForced ) ) + { + return bForced; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Player::GetNametagText( DWORD pUserData ) +{ + if( RESOURCE ) + { + string strOutText; + + if( CLuaFunctionDefinitions::GetPlayerNametagText( RESOURCE->GetLua(), (void*)pUserData, strOutText ) ) + { + return RESOURCE->NewString( strOutText ); + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Player::GetNametagColor( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucR, ucG, ucB; + + if( CLuaFunctionDefinitions::GetPlayerNametagColor( RESOURCE->GetLua(), (void*)pUserData, ucR, ucG, ucB ) ) + { + void *args[] = + { + &ucR, &ucG, &ucB + }; + + CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "Color", args, 3 ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +bool CMonoFunctions::Player::IsNametagShowing( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bShowing; + + if( CLuaFunctionDefinitions::IsPlayerNametagShowing( RESOURCE->GetLua(), (void*)pUserData, bShowing ) ) + { + return bShowing; + } + } + + return false; +} + +MonoString* CMonoFunctions::Player::GetSerial( DWORD pUserData ) +{ + if( RESOURCE ) + { + return RESOURCE->NewString( CLuaFunctionDefinitions::GetPlayerSerial( RESOURCE->GetLua(), (void*)pUserData ) ); + } + + return NULL; +} + +MonoString* CMonoFunctions::Player::GetUserName( DWORD pUserData ) +{ + if( RESOURCE ) + { + return RESOURCE->NewString( CLuaFunctionDefinitions::GetPlayerUserName( RESOURCE->GetLua(), (void*)pUserData ) ); + } + + return NULL; +} + +unsigned char CMonoFunctions::Player::GetBlurLevel( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucBlurLevel; + + if( CLuaFunctionDefinitions::GetPlayerBlurLevel( RESOURCE->GetLua(), (void*)pUserData, ucBlurLevel ) ) + { + return ucBlurLevel; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Player::GetName( DWORD pUserData ) +{ + if( RESOURCE ) + { + string strOutName; + + if( CLuaFunctionDefinitions::GetPlayerName( RESOURCE->GetLua(), (void*)pUserData, strOutName ) ) + { + return RESOURCE->NewString( strOutName ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Player::GetIP( DWORD pUserData ) +{ + if( RESOURCE ) + { + string strIP; + + if( CLuaFunctionDefinitions::GetPlayerIP( RESOURCE->GetLua(), (void*)pUserData, strIP ) ) + { + return RESOURCE->NewString( strIP ); + } + } + + return NULL; +} + +DWORD CMonoFunctions::Player::GetAccount( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetPlayerAccount( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +MonoString* CMonoFunctions::Player::GetVersion( DWORD pUserData ) +{ + if( RESOURCE ) + { + return RESOURCE->NewString( CLuaFunctionDefinitions::GetPlayerVersion( RESOURCE->GetLua(), (void*)pUserData ) ); + } + + return NULL; +} + +MonoObject* CMonoFunctions::Player::GetACInfo( DWORD pUserData ) +{ + if( RESOURCE ) + { + LuaTable pLuaTable = CLuaFunctionDefinitions::GetPlayerACInfo( RESOURCE->GetLua(), (void*)pUserData ); + + if( !pLuaTable.empty() ) + { + MonoString* msDetectedAC = RESOURCE->NewString( pLuaTable[ "DetectedAC" ]->GetString() ); + MonoString* msD3D9MD5 = RESOURCE->NewString( pLuaTable[ "d3d9MD5" ]->GetString() ); + MonoString* msD3D9SHA256 = RESOURCE->NewString( pLuaTable[ "d3d9SHA256" ]->GetString() ); + + unsigned int iD3D9Size = pLuaTable[ "d3d9Size" ]->GetNumber< unsigned int >(); + + void *args[] = + { + &msDetectedAC, + &iD3D9Size, + &msD3D9MD5, + &msD3D9SHA256 + }; + + CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "ServerVersion", args, 8 ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + return NULL; +} + + +// Player set functions +bool CMonoFunctions::Player::SetMoney( DWORD pUserData, int iAmount, bool bInstant ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerMoney( RESOURCE->GetLua(), (void*)pUserData, iAmount, bInstant ); + } + + return false; +} + +bool CMonoFunctions::Player::GiveMoney( DWORD pUserData, int iAmount ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GivePlayerMoney( RESOURCE->GetLua(), (void*)pUserData, iAmount ); + } + + return false; +} + +bool CMonoFunctions::Player::TakeMoney( DWORD pUserData, int iAmount ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::TakePlayerMoney( RESOURCE->GetLua(), (void*)pUserData, iAmount ); + } + + return false; +} + +bool CMonoFunctions::Player::Spawn( DWORD pUserData, MonoObject* pPosition, int iRotation, int iSkinID, int iInterior, int iDimension, DWORD pTeam ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + Vector3 vecPosition( fX, fY, fZ ); + + return CLuaFunctionDefinitions::SpawnPlayer( RESOURCE->GetLua(), (void*)pUserData, vecPosition, iRotation, iSkinID, iInterior, iDimension, (void*)pTeam ); + } + + return false; +} + +bool CMonoFunctions::Player::ShowHudComponent( DWORD pUserData, MonoString* msComponent, bool bShow ) +{ + if( RESOURCE ) + { + string strComponent( mono_string_to_utf8( msComponent ) ); + + return CLuaFunctionDefinitions::ShowPlayerHudComponent( RESOURCE->GetLua(), (void*)pUserData, strComponent, bShow ); + } + + return false; +} + +bool CMonoFunctions::Player::SetWantedLevel( DWORD pUserData, int iLevel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerWantedLevel( RESOURCE->GetLua(), (void*)pUserData, iLevel ); + } + + return false; +} + +bool CMonoFunctions::Player::ForceMap( DWORD pUserData, bool bForceOn ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ForcePlayerMap( RESOURCE->GetLua(), (void*)pUserData, bForceOn ); + } + + return false; +} + +bool CMonoFunctions::Player::SetNametagText( DWORD pUserData, MonoString* sText ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerNametagText( RESOURCE->GetLua(), (void*)pUserData, string( mono_string_to_utf8( sText ) ) ); + } + + return false; +} + +bool CMonoFunctions::Player::SetNametagColor( DWORD pUserData, int iRed, int iGreen, int iBlue ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerNametagColor( RESOURCE->GetLua(), (void*)pUserData, iRed, iGreen, iBlue ); + } + + return false; +} + +bool CMonoFunctions::Player::SetNametagShowing( DWORD pUserData, bool bShowing ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerNametagShowing( RESOURCE->GetLua(), (void*)pUserData, bShowing ); + } + + return false; +} + +bool CMonoFunctions::Player::SetMuted( DWORD pUserData, bool bMuted ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerMuted( RESOURCE->GetLua(), (void*)pUserData, bMuted ); + } + + return false; +} + +bool CMonoFunctions::Player::SetBlurLevel( DWORD pUserData, int iLevel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerBlurLevel( RESOURCE->GetLua(), (void*)pUserData, iLevel ); + } + + return false; +} + +bool CMonoFunctions::Player::Redirect( DWORD pUserData, MonoString* sServerIP, int iServerPort, MonoString* sServerPassword ) +{ + if( RESOURCE ) + { + const char* szServerIP = mono_string_to_utf8( sServerIP ); + const char* szServerPassword = mono_string_to_utf8( sServerPassword ); + + return CLuaFunctionDefinitions::RedirectPlayer( RESOURCE->GetLua(), (void*)pUserData, szServerIP, iServerPort, szServerPassword ); + } + + return false; +} + +bool CMonoFunctions::Player::SetName( DWORD pUserData, MonoString* sName ) +{ + if( RESOURCE ) + { + const char* szName = mono_string_to_utf8( sName ); + + return CLuaFunctionDefinitions::SetPlayerName( RESOURCE->GetLua(), (void*)pUserData, szName ); + } + + return false; +} + +bool CMonoFunctions::Player::DetonateSatchels( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::DetonateSatchels( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Player::TakeScreenShot( DWORD pUserData, int iWidth, int iHeight, MonoString* sTag, int iQuality, int iMaxBandwith ) +{ + if( RESOURCE ) + { + string strTag( mono_string_to_utf8( sTag ) ); + + return CLuaFunctionDefinitions::TakePlayerScreenShot( RESOURCE->GetLua(), (void*)pUserData, iWidth, iHeight, strTag, iQuality, iMaxBandwith ); + } + + return false; +} + +bool CMonoFunctions::Player::SetTeam( DWORD pUserData, DWORD pTeam ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetPlayerTeam( RESOURCE->GetLua(), (void*)pUserData, (void*)pTeam ); + } + + return false; +} + +// Input funcs + +bool CMonoFunctions::Player::BindKey( DWORD pUserData, MonoString* msKey, MonoString* msHitState, MonoString* msCommandName, MonoString* msArguments ) +{ + if( RESOURCE ) + { + const char* szKey = mono_string_to_utf8( msKey ); + const char* szHitState = mono_string_to_utf8( msHitState ); + const char* szCommandName = mono_string_to_utf8( msCommandName ); + const char* szArguments = mono_string_to_utf8( msArguments ); + + return CLuaFunctionDefinitions::BindKey( RESOURCE->GetLua(), (void*)pUserData, szKey, szHitState, szCommandName, szArguments ); + } + + return false; +} + +bool CMonoFunctions::Player::UnbindKey( DWORD pUserData, MonoString* msKey, MonoString* msHitState, MonoString* msCommandName ) +{ + if( RESOURCE ) + { + const char* szKey = mono_string_to_utf8( msKey ); + const char* szHitState = mono_string_to_utf8( msHitState ); + const char* szCommandName = mono_string_to_utf8( msCommandName ); + + return CLuaFunctionDefinitions::UnbindKey( RESOURCE->GetLua(), (void*)pUserData, szKey, szHitState, szCommandName ); + } + + return false; +} + +bool CMonoFunctions::Player::GetControlState( DWORD pUserData, MonoString* msControl ) +{ + if( RESOURCE ) + { + const char* szControl = mono_string_to_utf8( msControl ); + + bool bState; + + if( CLuaFunctionDefinitions::GetControlState( RESOURCE->GetLua(), (void*)pUserData, szControl, bState ) ) + { + return bState; + } + } + + return false; +} + +bool CMonoFunctions::Player::IsControlEnabled( DWORD pUserData, MonoString* msControl ) +{ + if( RESOURCE ) + { + const char* szControl = mono_string_to_utf8( msControl ); + + bool bEnabled; + + if( CLuaFunctionDefinitions::IsControlEnabled( RESOURCE->GetLua(), (void*)pUserData, szControl, bEnabled ) ) + { + return bEnabled; + } + } + + return false; +} + + +bool CMonoFunctions::Player::SetControlState( DWORD pUserData, MonoString* msControl, bool bState ) +{ + if( RESOURCE ) + { + const char* szControl = mono_string_to_utf8( msControl ); + + return CLuaFunctionDefinitions::SetControlState( RESOURCE->GetLua(), (void*)pUserData, szControl, bState ); + } + + return false; +} + +bool CMonoFunctions::Player::ToggleControl( DWORD pUserData, MonoString* msControl, bool bEnabled ) +{ + if( RESOURCE ) + { + const char* szControl = mono_string_to_utf8( msControl ); + + return CLuaFunctionDefinitions::ToggleControl( RESOURCE->GetLua(), (void*)pUserData, szControl, bEnabled ); + } + + return false; +} + +bool CMonoFunctions::Player::ToggleAllControls( DWORD pUserData, bool bGTAControls, bool bMTAControls, bool bEnabled ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ToggleAllControls( RESOURCE->GetLua(), (void*)pUserData, bGTAControls, bMTAControls, bEnabled ); + } + + return false; +} + + +// Log in/out funcs +bool CMonoFunctions::Player::LogIn( DWORD pPlayer, DWORD pAccount, MonoString* msPassword ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::LogIn( RESOURCE->GetLua(), (void*)pPlayer, (void*)pAccount, mono_string_to_utf8( msPassword ) ); + } + + return false; +} + +bool CMonoFunctions::Player::LogOut( DWORD pPlayer ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::LogOut( RESOURCE->GetLua(), (void*)pPlayer ); + } + + return false; +} + + +// Admin funcs +bool CMonoFunctions::Player::Kick( DWORD pPlayer, MonoString* msResponsible, MonoString* msReason ) +{ + if( RESOURCE ) + { + string + strResponsible( mono_string_to_utf8( msResponsible ) ), + strReason( mono_string_to_utf8( msReason ) ); + + return CLuaFunctionDefinitions::KickPlayer( RESOURCE->GetLua(), (void*)pPlayer, strResponsible, strReason ); + } + + return false; +} + +DWORD CMonoFunctions::Player::Ban( DWORD pPlayer, bool bIP, bool bUsername, bool bSerial, DWORD pResponsible, MonoString* msResponsible, MonoString* msReason, int iUnban ) +{ + if( RESOURCE ) + { + string + strResponsible( mono_string_to_utf8( msResponsible ) ), + strReason( mono_string_to_utf8( msReason ) ); + + return (DWORD)CLuaFunctionDefinitions::BanPlayer( RESOURCE->GetLua(), (void*)pPlayer, bIP, bUsername, bSerial, (void*)pResponsible, strResponsible, strReason, iUnban ); + } + + return false; +} + + +// Cursor get funcs +bool CMonoFunctions::Player::IsCursorShowing( DWORD pPlayer ) +{ + if( RESOURCE ) + { + bool bShowing; + + if( CLuaFunctionDefinitions::IsCursorShowing( RESOURCE->GetLua(), (void*)pPlayer, bShowing ) ) + { + return bShowing; + } + } + + return false; +} + + +// Cursor set funcs +bool CMonoFunctions::Player::ShowCursor( DWORD pPlayer, bool bShow, bool bToggleControls ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ShowCursor( RESOURCE->GetLua(), (void*)pPlayer, bShow, bToggleControls ); + } + + return false; +} + + +// Chat funcs +bool CMonoFunctions::Player::ShowChat( DWORD pPlayer, bool bShow ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ShowChat( RESOURCE->GetLua(), (void*)pPlayer, bShow ); + } + + return false; +} + + +// Camera get functions +MonoObject* CMonoFunctions::Player::GetCameraMatrix( DWORD pPlayer ) +{ + if( RESOURCE ) + { + Vector3 vecPosition, vecLookAt; + + float fRoll, fFOV; + + if( CLuaFunctionDefinitions::GetCameraMatrix( RESOURCE->GetLua(), (void*)pPlayer, vecPosition, vecLookAt, fRoll, fFOV ) ) + { + void *args[] = + { + &vecPosition.fX, + &vecPosition.fY, + &vecPosition.fZ, + &vecLookAt.fX, + &vecLookAt.fY, + &vecLookAt.fZ, + &fRoll, + &fFOV + }; + + CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "CameraMatrix", args, 8 ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +DWORD CMonoFunctions::Player::GetCameraTarget( DWORD pPlayer ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetCameraTarget( RESOURCE->GetLua(), (void*)pPlayer ); + } + + return false; +} + +unsigned char CMonoFunctions::Player::GetCameraInterior( DWORD pPlayer ) +{ + if( RESOURCE ) + { + unsigned char ucInterior; + + if( CLuaFunctionDefinitions::GetCameraInterior( RESOURCE->GetLua(), (void*)pPlayer, ucInterior ) ) + { + return ucInterior; + } + } + + return 0; +} + + +// Camera set functions +bool CMonoFunctions::Player::SetCameraMatrix( DWORD pPlayer, MonoObject* pCameraMatrix ) +{ + if( RESOURCE ) + { + CMonoObject pCameraMatrix( pCameraMatrix ); + + float fX = pCameraMatrix.GetPropertyValue< float >( "X" ); + float fY = pCameraMatrix.GetPropertyValue< float >( "Y" ); + float fZ = pCameraMatrix.GetPropertyValue< float >( "Z" ); + + Vector3 vecPosition( fX, fY, fZ ); + + float fLookAtX = pCameraMatrix.GetPropertyValue< float >( "LookAtX" ); + float fLookAtY = pCameraMatrix.GetPropertyValue< float >( "LookAtY" ); + float fLookAtZ = pCameraMatrix.GetPropertyValue< float >( "LookAtZ" ); + + Vector3* vecLookAt = new Vector3( fLookAtX, fLookAtY, fLookAtZ ); + + float fRoll = pCameraMatrix.GetPropertyValue< float >( "Roll" ); + float fFOV = pCameraMatrix.GetPropertyValue< float >( "FOV" ); + + return CLuaFunctionDefinitions::SetCameraMatrix( RESOURCE->GetLua(), (void*)pPlayer, vecPosition, vecLookAt, fRoll, fFOV ); + } + + return false; +} + +bool CMonoFunctions::Player::SetCameraTarget( DWORD pPlayer, DWORD pTarget ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetCameraTarget( RESOURCE->GetLua(), (void*)pPlayer, (void*)pTarget ); + } + + return false; +} + +bool CMonoFunctions::Player::SetCameraInterior( DWORD pPlayer, unsigned char ucInterior ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetCameraInterior( RESOURCE->GetLua(), (void*)pPlayer, ucInterior ); + } + + return false; +} + +bool CMonoFunctions::Player::FadeCamera( DWORD pPlayer, bool bFadeIn, float fFadeTime, MonoObject* pColor ) +{ + if( RESOURCE ) + { + CMonoObject pColor( pColor ); + + unsigned char ucReed = pColor.GetPropertyValue< unsigned char >( "R" ); + unsigned char ucGreen = pColor.GetPropertyValue< unsigned char >( "G" ); + unsigned char ucBlue = pColor.GetPropertyValue< unsigned char >( "B" ); + + return CLuaFunctionDefinitions::FadeCamera( RESOURCE->GetLua(), (void*)pPlayer, bFadeIn, fFadeTime, ucReed, ucGreen, ucBlue ); + } + + return false; +} + +#endif \ No newline at end of file diff --git a/mta-mono/src/CMonoFunctions_RadarArea.cpp b/mta-mono/src/CMonoFunctions_RadarArea.cpp new file mode 100644 index 0000000..6f0bcb6 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_RadarArea.cpp @@ -0,0 +1,167 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Radar area create/destroy funcs +DWORD CMonoFunctions::RadarArea::Create( MonoObject* pPosition, MonoObject* pSize, MonoObject* color, DWORD pVisibleTo ) +{ + if( RESOURCE ) + { + Vector2 vecPosition, vecSize; + + CMonoObject pPosition( pPosition ); + + vecPosition.fX = pPosition.GetPropertyValue< float >( "X" ); + vecPosition.fY = pPosition.GetPropertyValue< float >( "Y" ); + + CMonoObject pSize( pSize ); + + vecSize.fX = pSize.GetPropertyValue< float >( "X" ); + vecSize.fY = pSize.GetPropertyValue< float >( "Y" ); + + CMonoObject pMonoColor( color ); + + SColor pColor; + + pColor.R = pMonoColor.GetPropertyValue< unsigned char >( "R" ); + pColor.G = pMonoColor.GetPropertyValue< unsigned char >( "G" ); + pColor.B = pMonoColor.GetPropertyValue< unsigned char >( "B" ); + pColor.A = pMonoColor.GetPropertyValue< unsigned char >( "A" ); + + return (DWORD)CLuaFunctionDefinitions::CreateRadarArea( RESOURCE->GetLua(), vecPosition, vecSize, pColor, (void*)pVisibleTo ); + } + + return NULL; +} + + +// Radar area get funcs +MonoObject* CMonoFunctions::RadarArea::GetSize( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector2 vecSize; + + if( CLuaFunctionDefinitions::GetRadarAreaSize( RESOURCE->GetLua(), (void*)pUserData, vecSize ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecSize ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::RadarArea::GetColor( DWORD pUserData ) +{ + if( RESOURCE ) + { + SColor outColor; + + if( CLuaFunctionDefinitions::GetRadarAreaColor( RESOURCE->GetLua(), (void*)pUserData, outColor ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( outColor ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +bool CMonoFunctions::RadarArea::IsFlashing( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::IsRadarAreaFlashing( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::RadarArea::IsInside( DWORD pUserData, MonoObject* pPosition ) +{ + if( RESOURCE ) + { + bool bInside; + + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + + Vector2 vecPosition( fX, fY ); + + if( CLuaFunctionDefinitions::IsInsideRadarArea( RESOURCE->GetLua(), (void*)pUserData, vecPosition, bInside ) ) + { + return bInside; + } + } + + return false; +} + + +// Radar area set funcs +bool CMonoFunctions::RadarArea::SetSize( DWORD pUserData, MonoObject* pSize ) +{ + if( RESOURCE ) + { + CMonoObject pSize( pSize ); + + float fX = pSize.GetPropertyValue< float >( "X" ); + float fY = pSize.GetPropertyValue< float >( "Y" ); + + Vector2 vecPosition( fX, fY ); + + return CLuaFunctionDefinitions::SetRadarAreaSize( RESOURCE->GetLua(), (void*)pUserData, vecPosition ); + } + + return false; +} + +bool CMonoFunctions::RadarArea::SetColor( DWORD pUserData, MonoObject* color ) +{ + if( RESOURCE ) + { + SColor pColor; + + CMonoObject pObject( color ); + + pColor.R = pObject.GetPropertyValue< unsigned char >( "R" ); + pColor.G = pObject.GetPropertyValue< unsigned char >( "G" ); + pColor.B = pObject.GetPropertyValue< unsigned char >( "B" ); + pColor.A = pObject.GetPropertyValue< unsigned char >( "A" ); + + return CLuaFunctionDefinitions::SetRadarAreaColor( RESOURCE->GetLua(), (void*)pUserData, pColor ); + } + + return false; +} + +bool CMonoFunctions::RadarArea::SetFlashing( DWORD pUserData, bool bFlashing ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetRadarAreaFlashing( RESOURCE->GetLua(), (void*)pUserData, bFlashing ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Resource.cpp b/mta-mono/src/CMonoFunctions_Resource.cpp new file mode 100644 index 0000000..5919f9c --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Resource.cpp @@ -0,0 +1,327 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Resource funcs +DWORD CMonoFunctions::Resource::Create( MonoString* msResourceName, MonoString* msOrganizationalDir ) +{ + if( RESOURCE ) + { + const char* szResourceName = mono_string_to_utf8( msResourceName ); + const char* szOrganizationalDir = mono_string_to_utf8( msOrganizationalDir ); + + return (DWORD)CLuaFunctionDefinitions::CreateResource( RESOURCE->GetLua(), szResourceName, szOrganizationalDir ); + } + + return NULL; +} + +DWORD CMonoFunctions::Resource::Copy( DWORD pResource, MonoString* msNewResourceName, MonoString* msOrganizationalDir ) +{ + if( RESOURCE ) + { + const char* szResourceName = mono_string_to_utf8( msNewResourceName ); + const char* szOrganizationalDir = mono_string_to_utf8( msOrganizationalDir ); + + return (DWORD)CLuaFunctionDefinitions::CopyResource( RESOURCE->GetLua(), (void*)pResource, szResourceName, szOrganizationalDir ); + } + + return NULL; +} + +DWORD CMonoFunctions::Resource::GetRootElement( DWORD pResource ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetResourceRootElement( RESOURCE->GetLua(), (void*)pResource ); + } + + return NULL; +} + +DWORD CMonoFunctions::Resource::GetMapRootElement( MonoString* msMap ) +{ + if( RESOURCE ) + { + const char* szMap = mono_string_to_utf8( msMap ); + + return (DWORD)CLuaFunctionDefinitions::GetResourceMapRootElement( RESOURCE->GetLua(), szMap ); + } + + return NULL; +} + +DWORD CMonoFunctions::Resource::GetDynamicElementRoot( DWORD pResource ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetResourceDynamicElementRoot( RESOURCE->GetLua(), (void*)pResource ); + } + + return NULL; +} + +bool CMonoFunctions::Resource::RemoveFile( MonoString* msFilename ) +{ + if( RESOURCE ) + { + const char* szFileName = mono_string_to_utf8( msFilename ); + + return CLuaFunctionDefinitions::RemoveResourceFile( RESOURCE->GetLua(), szFileName ); + } + + return false; +} + +DWORD CMonoFunctions::Resource::GetFromName( MonoString* msResourceName ) +{ + if( RESOURCE ) + { + const char* szResourceName = mono_string_to_utf8( msResourceName ); + + return (DWORD)CLuaFunctionDefinitions::RemoveResourceFile( RESOURCE->GetLua(), szResourceName ); + } + + return false; +} + +MonoString* CMonoFunctions::Resource::GetInfo( DWORD pResource, MonoString* msAttribute ) +{ + if( RESOURCE ) + { + const char* szAttribute = mono_string_to_utf8( msAttribute ); + + string strOutInfo; + + if( CLuaFunctionDefinitions::GetResourceInfo( RESOURCE->GetLua(), (void*)pResource, szAttribute, strOutInfo ) ) + { + return RESOURCE->NewString( strOutInfo ); + } + } + + return NULL; +} + +unsigned int CMonoFunctions::Resource::GetLastStartTime( DWORD pResource ) +{ + if( RESOURCE ) + { + unsigned int uiTime; + + if( CLuaFunctionDefinitions::GetResourceLastStartTime( RESOURCE->GetLua(), (void*)pResource, uiTime ) ) + { + return uiTime; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Resource::GetLoadFailureReason( DWORD pResource ) +{ + if( RESOURCE ) + { + string strOutReason; + + if( CLuaFunctionDefinitions::GetResourceLoadFailureReason( RESOURCE->GetLua(), (void*)pResource, strOutReason ) ) + { + return RESOURCE->NewString( strOutReason ); + } + } + + return NULL; +} + +unsigned int CMonoFunctions::Resource::GetLoadTime( DWORD pResource ) +{ + if( RESOURCE ) + { + unsigned int uiTime; + + if( CLuaFunctionDefinitions::GetResourceLoadTime( RESOURCE->GetLua(), (void*)pResource, uiTime ) ) + { + return uiTime; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Resource::GetName( DWORD pResource ) +{ + if( RESOURCE ) + { + string strOut; + + if( CLuaFunctionDefinitions::GetResourceName( RESOURCE->GetLua(), (void*)pResource, strOut ) ) + { + return RESOURCE->NewString( strOut ); + } + } + + return NULL; +} + +MonoArray* CMonoFunctions::Resource::GetResources( void ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaTable = CLuaFunctionDefinitions::GetResources( RESOURCE->GetLua() ); + + return RESOURCE->NewArray( mono_get_uint32_class(), pLuaTable ); + } + + return NULL; +} + +MonoString* CMonoFunctions::Resource::GetState( DWORD pResource ) +{ + if( RESOURCE ) + { + string strOut; + + if( CLuaFunctionDefinitions::GetResourceState( RESOURCE->GetLua(), (void*)pResource, strOut ) ) + { + return RESOURCE->NewString( strOut ); + } + } + + return NULL; +} + +DWORD CMonoFunctions::Resource::GetCurrent( void ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetThisResource( RESOURCE->GetLua() ); + } + + return NULL; +} + +bool CMonoFunctions::Resource::Refresh( bool refreshAll ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RefreshResources( RESOURCE->GetLua(), refreshAll ); + } + + return NULL; +} + +bool CMonoFunctions::Resource::RemoveDefaultSetting( DWORD pResource, MonoString* msSettingName ) +{ + if( RESOURCE ) + { + const char* szSettingName = mono_string_to_utf8( msSettingName ); + + return CLuaFunctionDefinitions::RemoveResourceDefaultSetting( RESOURCE->GetLua(), (void*)pResource, szSettingName ); + } + + return false; +} + +bool CMonoFunctions::Resource::Start( DWORD pResource, bool persistent, bool startIncludedResources, bool loadServerConfigs, bool loadMaps, bool loadServerScripts, bool loadHTML, bool loadClientConfigs, bool loadClientScripts, bool loadFiles ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::StartResource( RESOURCE->GetLua(), (void*)pResource, persistent, startIncludedResources, loadServerConfigs, loadMaps, loadServerScripts, loadHTML, loadClientConfigs, loadClientScripts, loadFiles ); + } + + return false; +} + +bool CMonoFunctions::Resource::Restart( DWORD pResource ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RestartResource( RESOURCE->GetLua(), (void*)pResource ); + } + + return false; +} + +bool CMonoFunctions::Resource::Stop( DWORD pResource ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::StopResource( RESOURCE->GetLua(), (void*)pResource ); + } + + return false; +} + +bool CMonoFunctions::Resource::SetDefaultSetting( DWORD pResource, MonoString* msSettingName, MonoString* msSettingValue ) +{ + if( RESOURCE ) + { + const char* szSettingName = mono_string_to_utf8( msSettingName ); + const char* szSettingValue = mono_string_to_utf8( msSettingValue ); + + return CLuaFunctionDefinitions::SetResourceDefaultSetting( RESOURCE->GetLua(), (void*)pResource, szSettingName, szSettingValue ); + } + + return false; +} + +bool CMonoFunctions::Resource::SetInfo( DWORD pResource, MonoString* msAttribute, MonoString* msValue ) +{ + if( RESOURCE ) + { + const char* szAttribute = mono_string_to_utf8( msAttribute ); + const char* szValue = mono_string_to_utf8( msValue ); + + return CLuaFunctionDefinitions::SetResourceInfo( RESOURCE->GetLua(), (void*)pResource, szAttribute, szValue ); + } + + return false; +} + +bool CMonoFunctions::Resource::Rename( MonoString* msResourceName, MonoString* msNewResourceName, MonoString* msOrganizationalPath ) +{ + if( RESOURCE ) + { + const char* szResourceName = mono_string_to_utf8( msResourceName ); + const char* szNewResourceName = mono_string_to_utf8( msNewResourceName ); + const char* szOrganizationalPath = mono_string_to_utf8( msOrganizationalPath ); + + return CLuaFunctionDefinitions::RenameResource( RESOURCE->GetLua(), szResourceName, szNewResourceName, szOrganizationalPath ); + } + + return false; +} + +bool CMonoFunctions::Resource::Delete( MonoString* msResourceName ) +{ + if( RESOURCE ) + { + const char* szResourceName = mono_string_to_utf8( msResourceName ); + + return CLuaFunctionDefinitions::DeleteResource( RESOURCE->GetLua(), szResourceName ); + } + + return false; +} + +bool CMonoFunctions::Resource::UpdateACLRequest( DWORD pResource, MonoString* msRightName, bool bAccess, MonoString* msByWho ) +{ + if( RESOURCE ) + { + const char* szRightName = mono_string_to_utf8( msRightName ); + const char* szByWho = mono_string_to_utf8( msByWho ); + + return CLuaFunctionDefinitions::UpdateResourceACLRequest( RESOURCE->GetLua(), (void*)pResource, szRightName, bAccess, szByWho ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Shape.cpp b/mta-mono/src/CMonoFunctions_Shape.cpp new file mode 100644 index 0000000..d76277a --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Shape.cpp @@ -0,0 +1,100 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Shape create funcs +DWORD CMonoFunctions::Shape::CreateCircle( MonoObject* pPosition, float fRadius ) +{ + if( RESOURCE ) + { + Vector2 vecPosition = CMonoObject( pPosition ).GetVector2(); + + return (DWORD)CLuaFunctionDefinitions::CreateColCircle( RESOURCE->GetLua(), vecPosition, fRadius ); + } + + return NULL; +} + +DWORD CMonoFunctions::Shape::CreateCuboid( MonoObject* pPosition, MonoObject* pSize ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + Vector3 vecSize = CMonoObject( pSize ).GetVector3(); + + return (DWORD)CLuaFunctionDefinitions::CreateColCuboid( RESOURCE->GetLua(), vecPosition, vecSize ); + } + + return NULL; +} + +DWORD CMonoFunctions::Shape::CreateSphere( MonoObject* pPosition, float fRadius ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + + return (DWORD)CLuaFunctionDefinitions::CreateColSphere( RESOURCE->GetLua(), vecPosition, fRadius ); + } + + return NULL; +} + +DWORD CMonoFunctions::Shape::CreateRectangle( MonoObject* pPosition, MonoObject* pSize ) +{ + if( RESOURCE ) + { + Vector2 vecPosition = CMonoObject( pPosition ).GetVector2(); + Vector2 vecSize = CMonoObject( pSize ).GetVector2(); + + return (DWORD)CLuaFunctionDefinitions::CreateColRectangle( RESOURCE->GetLua(), vecPosition, vecSize ); + } + + return NULL; +} + +DWORD CMonoFunctions::Shape::CreatePolygon( MonoArray* pPointList ) +{ + if( RESOURCE ) + { + vector< Vector2 > vecPointList; + + for( unsigned int i = 0; i < mono_array_length( pPointList ); i++ ) + { + MonoObject* pObject = mono_array_get( pPointList, MonoObject*, i ); + + if( pObject ) + { + Vector2 vecPosition = CMonoObject( pObject ).GetVector2(); + + vecPointList.push_back( vecPosition ); + } + } + + return (DWORD)CLuaFunctionDefinitions::CreateColPolygon( RESOURCE->GetLua(), vecPointList ); + } + + return NULL; +} + +DWORD CMonoFunctions::Shape::CreateTube( MonoObject* pPosition, float fRadius, float fHeight ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + + return (DWORD)CLuaFunctionDefinitions::CreateColTube( RESOURCE->GetLua(), vecPosition, fRadius, fHeight ); + } + + return NULL; +} diff --git a/mta-mono/src/CMonoFunctions_Team.cpp b/mta-mono/src/CMonoFunctions_Team.cpp new file mode 100644 index 0000000..ebdcfb6 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Team.cpp @@ -0,0 +1,140 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Team get funcs +DWORD CMonoFunctions::Team::Create( MonoString* msTeamName, MonoObject* mColor ) +{ + if( RESOURCE ) + { + const char* szTeamName = mono_string_to_utf8( msTeamName ); + SColor pColor = CMonoObject( mColor ).GetColor(); + + return (DWORD)CLuaFunctionDefinitions::CreateTeam( RESOURCE->GetLua(), szTeamName, pColor.R, pColor.G, pColor.B ); + } + + return NULL; +} + +DWORD CMonoFunctions::Team::GetFromName( MonoString* msTeamName ) +{ + if( RESOURCE ) + { + const char* szTeamName = mono_string_to_utf8( msTeamName ); + + return (DWORD)CLuaFunctionDefinitions::GetTeamFromName( RESOURCE->GetLua(), szTeamName ); + } + + return NULL; +} + +MonoString* CMonoFunctions::Team::GetName( DWORD pUserData ) +{ + if( RESOURCE ) + { + string strOutName; + + if( CLuaFunctionDefinitions::GetTeamName( RESOURCE->GetLua(), (void*)pUserData, strOutName ) ) + { + return RESOURCE->NewString( strOutName ); + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Team::GetColor( DWORD pUserData ) +{ + if( RESOURCE ) + { + SColor pColor; + + if( CLuaFunctionDefinitions::GetTeamColor( RESOURCE->GetLua(), (void*)pUserData, pColor.R, pColor.G, pColor.B ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( pColor ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +unsigned int CMonoFunctions::Team::CountPlayers( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned int uiCount; + + if( CLuaFunctionDefinitions::CountPlayersInTeam( RESOURCE->GetLua(), (void*)pUserData, uiCount ) ) + { + return uiCount; + } + } + + return 0; +} + +bool CMonoFunctions::Team::GetFriendlyFire( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bFriendlyFire; + + if( CLuaFunctionDefinitions::GetTeamFriendlyFire( RESOURCE->GetLua(), (void*)pUserData, bFriendlyFire ) ) + { + return bFriendlyFire; + } + } + + return false; +} + + +// Team set funcs +bool CMonoFunctions::Team::SetName( DWORD pUserData, MonoString* msTeamName ) +{ + if( RESOURCE ) + { + const char* szTeamName = mono_string_to_utf8( msTeamName ); + + return CLuaFunctionDefinitions::SetTeamName( RESOURCE->GetLua(), (void*)pUserData, szTeamName ); + } + + return false; +} + +bool CMonoFunctions::Team::SetColor( DWORD pUserData, MonoObject* mColor ) +{ + if( RESOURCE ) + { + SColor pColor = CMonoObject( mColor ).GetColor(); + + return CLuaFunctionDefinitions::SetTeamColor( RESOURCE->GetLua(), (void*)pUserData, pColor.R, pColor.G, pColor.B ); + } + + return false; +} + +bool CMonoFunctions::Team::SetFriendlyFire( DWORD pUserData, bool bFriendlyFire ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTeamFriendlyFire( RESOURCE->GetLua(), (void*)pUserData, bFriendlyFire ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Vehicle.cpp b/mta-mono/src/CMonoFunctions_Vehicle.cpp new file mode 100644 index 0000000..086e586 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Vehicle.cpp @@ -0,0 +1,1213 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Vehicle create/destroy functions +DWORD CMonoFunctions::Vehicle::Create( int model, MonoObject* position, MonoObject* rotation, MonoString* numberplate, bool direction, int variant1, int variant2 ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( position ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + CMonoObject pRotation( rotation ); + + float fRX = pRotation.GetPropertyValue< float >( "X" ); + float fRY = pRotation.GetPropertyValue< float >( "Y" ); + float fRZ = pRotation.GetPropertyValue< float >( "Z" ); + + string sNumberplate = ""; + + if( numberplate && mono_string_length( numberplate ) > 0 ) + { + sNumberplate = string( mono_string_to_utf8( numberplate ) ); + } + + return (DWORD)CLuaFunctionDefinitions::CreateVehicle( RESOURCE->GetLua(), model, fX, fY, fZ, fRX, fRY, fRZ, sNumberplate, direction, variant1, variant2 ); + } + + return NULL; +} + +// Vehicle get functions +MonoString* CMonoFunctions::Vehicle::GetType( DWORD pUserData ) +{ + if( RESOURCE ) + { + string strType; + + if( CLuaFunctionDefinitions::GetVehicleType( RESOURCE->GetLua(), (void*)pUserData, strType ) ) + { + return RESOURCE->NewString( strType ); + } + } + + return NULL; +} + +MonoArray* CMonoFunctions::Vehicle::GetVariant( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucVariant; + unsigned char ucVariant2; + + if( CLuaFunctionDefinitions::GetVehicleVariant( RESOURCE->GetLua(), (void*)pUserData, ucVariant, ucVariant2 ) ) + { + MonoArray* pArray = mono_array_new( RESOURCE->m_pMonoDomain, mono_get_char_class(), 2 ); + + if( pArray ) + { + mono_array_set( pArray, unsigned char, 0, ucVariant ); + mono_array_set( pArray, unsigned char, 1, ucVariant2 ); + + return pArray; + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Vehicle::GetColor( DWORD pUserData ) +{ + if( RESOURCE ) + { + CVehicleColor pColor; + + if( CLuaFunctionDefinitions::GetVehicleColor( RESOURCE->GetLua(), (void*)pUserData, pColor ) ) + { + SColor pColor1 = pColor.GetRGBColor( 0 ); + SColor pColor2 = pColor.GetRGBColor( 1 ); + SColor pColor3 = pColor.GetRGBColor( 2 ); + SColor pColor4 = pColor.GetRGBColor( 3 ); + + void* args[] = + { + &pColor1, + &pColor2, + &pColor3, + &pColor4 + }; + + CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "VehicleColor", args, 4 ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +unsigned short CMonoFunctions::Vehicle::GetModelFromName( MonoString* msName ) +{ + if( RESOURCE ) + { + const char* szName = mono_string_to_utf8( msName ); + + unsigned short usModel; + + if( CLuaFunctionDefinitions::GetVehicleModelFromName( RESOURCE->GetLua(), szName, usModel ) ) + { + return usModel; + } + } + + return 0; +} + +bool CMonoFunctions::Vehicle::GetLandingGearDown( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bGearDown; + + if( CLuaFunctionDefinitions::GetVehicleLandingGearDown( RESOURCE->GetLua(), (void*)pUserData, bGearDown ) ) + { + return bGearDown; + } + } + + return false; +} + +unsigned char CMonoFunctions::Vehicle::GetMaxPassengers( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucPassengers; + + if( CLuaFunctionDefinitions::GetVehicleMaxPassengers( RESOURCE->GetLua(), (void*)pUserData, ucPassengers ) ) + { + return ucPassengers; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Vehicle::GetName( DWORD pUserData ) +{ + if( RESOURCE ) + { + string strOutName; + + if( CLuaFunctionDefinitions::GetVehicleName( RESOURCE->GetLua(), (void*)pUserData, strOutName ) ) + { + return RESOURCE->NewString( strOutName ); + } + } + + return NULL; +} + +MonoString* CMonoFunctions::Vehicle::GetNameFromModel( unsigned short usModel ) +{ + if( RESOURCE ) + { + string strOutName; + + if( CLuaFunctionDefinitions::GetVehicleNameFromModel( RESOURCE->GetLua(), usModel, strOutName ) ) + { + return RESOURCE->NewString( strOutName ); + } + } + + return NULL; +} + +DWORD CMonoFunctions::Vehicle::GetOccupant( DWORD pUserData, unsigned int uiSeat ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetVehicleOccupant( RESOURCE->GetLua(), (void*)pUserData, uiSeat ); + } + + return NULL; +} + +MonoArray* CMonoFunctions::Vehicle::GetOccupants( DWORD pUserData ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehicleOccupants( RESOURCE->GetLua(), (void*)pUserData ); + + return RESOURCE->NewArray( mono_get_uint32_class(), pLuaArguments ); + } + + return NULL; +} + +DWORD CMonoFunctions::Vehicle::GetController( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetVehicleController( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +bool CMonoFunctions::Vehicle::GetSirensOn( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bSirensOn; + + if( CLuaFunctionDefinitions::GetVehicleSirensOn( RESOURCE->GetLua(), (void*)pUserData, bSirensOn ) ) + { + return bSirensOn; + } + } + + return false; +} + +MonoObject* CMonoFunctions::Vehicle::GetTurnVelocity( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector3 vecVelocity; + + if( CLuaFunctionDefinitions::GetVehicleTurnVelocity( RESOURCE->GetLua(), (void*)pUserData, vecVelocity ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecVelocity ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::Vehicle::GetTurretPosition( DWORD pUserData ) +{ + if( RESOURCE ) + { + Vector2 vecPosition; + + if( CLuaFunctionDefinitions::GetVehicleTurretPosition( RESOURCE->GetLua(), (void*)pUserData, vecPosition ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecPosition ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +bool CMonoFunctions::Vehicle::IsLocked( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bLocked; + + if( CLuaFunctionDefinitions::IsVehicleLocked( RESOURCE->GetLua(), (void*)pUserData, bLocked ) ) + { + return bLocked; + } + } + + return false; +} + +MonoArray* CMonoFunctions::Vehicle::GetOfType( unsigned int uiModel ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehiclesOfType( RESOURCE->GetLua(), uiModel ); + + return RESOURCE->NewArray( mono_get_uint32_class(), pLuaArguments ); + } + + return NULL; +} + +unsigned short CMonoFunctions::Vehicle::GetUpgradeOnSlot( DWORD pUserData, unsigned char ucSlot ) +{ + if( RESOURCE ) + { + unsigned short ucUpgrade; + + if( CLuaFunctionDefinitions::GetVehicleUpgradeOnSlot( RESOURCE->GetLua(), (void*)pUserData, ucSlot, ucUpgrade ) ) + { + return ucUpgrade; + } + } + + return 0; +} + +MonoArray* CMonoFunctions::Vehicle::GetUpgrades( DWORD pUserData ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehicleUpgrades( RESOURCE->GetLua(), (void*)pUserData ); + + return RESOURCE->NewArray( mono_get_uint32_class(), pLuaArguments ); + } + + return NULL; +} + +MonoString* CMonoFunctions::Vehicle::GetUpgradeSlotName( unsigned short usUpgrade ) +{ + if( RESOURCE ) + { + string strOutName; + + if( CLuaFunctionDefinitions::GetVehicleUpgradeSlotName( RESOURCE->GetLua(), usUpgrade, strOutName ) ) + { + return RESOURCE->NewString( strOutName ); + } + } + + return NULL; +} + +MonoArray* CMonoFunctions::Vehicle::GetCompatibleUpgrades( DWORD pUserData ) +{ + if( RESOURCE ) + { + CLuaArguments* pLuaArguments = CLuaFunctionDefinitions::GetVehicleCompatibleUpgrades( RESOURCE->GetLua(), (void*)pUserData ); + + return RESOURCE->NewArray( mono_get_uint32_class(), pLuaArguments ); + } + + return NULL; +} + +unsigned char CMonoFunctions::Vehicle::GetDoorState( DWORD pUserData, unsigned char ucDoor ) +{ + if( RESOURCE ) + { + unsigned char ucState; + + if( CLuaFunctionDefinitions::GetVehicleDoorState( RESOURCE->GetLua(), (void*)pUserData, ucDoor, ucState ) ) + { + return ucState; + } + } + + return 0; +} + +MonoObject* CMonoFunctions::Vehicle::GetWheelStates( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucFrontLeft, ucRearLeft, ucFrontRight, ucRearRight; + + if( CLuaFunctionDefinitions::GetVehicleWheelStates( RESOURCE->GetLua(), (void*)pUserData, ucFrontLeft, ucRearLeft, ucFrontRight, ucRearRight ) ) + { + void *args[] = + { + &ucFrontLeft, &ucRearLeft, &ucFrontRight, &ucRearRight + }; + + CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto.Vehicle", "VehicleWheelsState", args, 4 ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +unsigned char CMonoFunctions::Vehicle::GetLightState( DWORD pUserData, unsigned char ucLight ) +{ + if( RESOURCE ) + { + unsigned char ucState; + + if( CLuaFunctionDefinitions::GetVehicleLightState( RESOURCE->GetLua(), (void*)pUserData, ucLight, ucState ) ) + { + return ucState; + } + } + + return 0; +} + +unsigned char CMonoFunctions::Vehicle::GetPanelState( DWORD pUserData, unsigned char ucPanel ) +{ + if( RESOURCE ) + { + unsigned char ucState; + + if( CLuaFunctionDefinitions::GetVehiclePanelState( RESOURCE->GetLua(), (void*)pUserData, ucPanel, ucState ) ) + { + return ucState; + } + } + + return 0; +} + +unsigned char CMonoFunctions::Vehicle::GetOverrideLights( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucLights; + + if( CLuaFunctionDefinitions::GetVehicleOverrideLights( RESOURCE->GetLua(), (void*)pUserData, ucLights ) ) + { + return ucLights; + } + } + + return 0; +} + +DWORD CMonoFunctions::Vehicle::GetTowedByVehicle( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetVehicleTowedByVehicle( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +DWORD CMonoFunctions::Vehicle::GetTowingVehicle( DWORD pUserData ) +{ + if( RESOURCE ) + { + return (DWORD)CLuaFunctionDefinitions::GetVehicleTowingVehicle( RESOURCE->GetLua(), (void*)pUserData ); + } + + return NULL; +} + +unsigned char CMonoFunctions::Vehicle::GetPaintjob( DWORD pUserData ) +{ + if( RESOURCE ) + { + unsigned char ucPaintjob; + + if( CLuaFunctionDefinitions::GetVehiclePaintjob( RESOURCE->GetLua(), (void*)pUserData, ucPaintjob ) ) + { + return ucPaintjob; + } + } + + return 0; +} + +MonoString* CMonoFunctions::Vehicle::GetPlateText( DWORD pUserData ) +{ + if( RESOURCE ) + { + char* szPlateText = NULL; + + if( CLuaFunctionDefinitions::GetVehiclePlateText( RESOURCE->GetLua(), (void*)pUserData, szPlateText ) ) + { + return RESOURCE->NewString( szPlateText ); + } + } + + return NULL; +} + +bool CMonoFunctions::Vehicle::IsDamageProof( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDamageProof; + + if( CLuaFunctionDefinitions::IsVehicleDamageProof( RESOURCE->GetLua(), (void*)pUserData, bDamageProof ) ) + { + return bDamageProof; + } + } + + return false; +} + +bool CMonoFunctions::Vehicle::IsFuelTankExplodable( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bExplodable; + + if( CLuaFunctionDefinitions::IsVehicleFuelTankExplodable( RESOURCE->GetLua(), (void*)pUserData, bExplodable ) ) + { + return bExplodable; + } + } + + return false; +} + +bool CMonoFunctions::Vehicle::IsFrozen( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bFrozen; + + if( CLuaFunctionDefinitions::IsVehicleFrozen( RESOURCE->GetLua(), (void*)pUserData, bFrozen ) ) + { + return bFrozen; + } + } + + return false; +} + +bool CMonoFunctions::Vehicle::IsOnGround( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bOnGround; + + if( CLuaFunctionDefinitions::IsVehicleOnGround( RESOURCE->GetLua(), (void*)pUserData, bOnGround ) ) + { + return bOnGround; + } + } + + return false; +} + +bool CMonoFunctions::Vehicle::GetEngineState( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bState; + + if( CLuaFunctionDefinitions::GetVehicleEngineState( RESOURCE->GetLua(), (void*)pUserData, bState ) ) + { + return bState; + } + } + + return false; +} + +bool CMonoFunctions::Vehicle::IsTrainDerailed( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDerailed; + + if( CLuaFunctionDefinitions::IsTrainDerailed( RESOURCE->GetLua(), (void*)pUserData, bDerailed ) ) + { + return bDerailed; + } + } + + return false; +} + +bool CMonoFunctions::Vehicle::IsTrainDerailable( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDerailed; + + if( CLuaFunctionDefinitions::IsTrainDerailable( RESOURCE->GetLua(), (void*)pUserData, bDerailed ) ) + { + return bDerailed; + } + } + + return false; +} + +bool CMonoFunctions::Vehicle::GetTrainDirection( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bDirection; + + if( CLuaFunctionDefinitions::GetTrainDirection( RESOURCE->GetLua(), (void*)pUserData, bDirection ) ) + { + return bDirection; + } + } + + return false; +} + +float CMonoFunctions::Vehicle::GetTrainSpeed( DWORD pUserData ) +{ + if( RESOURCE ) + { + float fSpeed; + + if( CLuaFunctionDefinitions::GetTrainSpeed( RESOURCE->GetLua(), (void*)pUserData, fSpeed ) ) + { + return fSpeed; + } + } + + return 0.0f; +} + +bool CMonoFunctions::Vehicle::IsBlown( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::IsVehicleBlown( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +MonoObject* CMonoFunctions::Vehicle::GetHeadLightColor( DWORD pUserData ) +{ + if( RESOURCE ) + { + SColor outColor; + + if( CLuaFunctionDefinitions::GetVehicleHeadLightColor( RESOURCE->GetLua(), (void*)pUserData, outColor ) ) + { + CMonoObject* pMonoObject = RESOURCE->NewObject( outColor ); + + if( pMonoObject ) + { + return pMonoObject->GetObject(); + } + } + } + + return NULL; +} + +float CMonoFunctions::Vehicle::GetDoorOpenRatio( DWORD pUserData, unsigned char ucDoor ) +{ + if( RESOURCE ) + { + float fRatio; + + if( CLuaFunctionDefinitions::GetVehicleDoorOpenRatio( RESOURCE->GetLua(), (void*)pUserData, ucDoor, fRatio ) ) + { + return fRatio; + } + } + + return 0.0f; +} + +bool CMonoFunctions::Vehicle::IsTaxiLightOn( DWORD pUserData ) +{ + if( RESOURCE ) + { + bool bLightOn; + + if( CLuaFunctionDefinitions::IsVehicleTaxiLightOn( RESOURCE->GetLua(), (void*)pUserData, bLightOn ) ) + { + return bLightOn; + } + } + + return false; +} + + +// Vehicle set functions +bool CMonoFunctions::Vehicle::Fix( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::FixVehicle( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::Blow( DWORD pUserData, bool bExplode ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::BlowVehicle( RESOURCE->GetLua(), (void*)pUserData, bExplode ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetTurnVelocity( DWORD pUserData, MonoObject* pVelocity ) +{ + if( RESOURCE ) + { + CMonoObject pVelocity( pVelocity ); + + float fX = pVelocity.GetPropertyValue< float >( "X" ); + float fY = pVelocity.GetPropertyValue< float >( "Y" ); + float fZ = pVelocity.GetPropertyValue< float >( "Z" ); + + return CLuaFunctionDefinitions::SetVehicleTurnVelocity( RESOURCE->GetLua(), (void*)pUserData, fX, fY, fZ ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetColor( DWORD pUserData, MonoObject* pColor1, MonoObject* pColor2, MonoObject* pColor3, MonoObject* pColor4 ) +{ + if( RESOURCE ) + { + CMonoObject pColor1( pColor1 ); + + unsigned char ucR1 = pColor1.GetPropertyValue< unsigned char >( "R" ); + unsigned char ucG1 = pColor1.GetPropertyValue< unsigned char >( "G" ); + unsigned char ucB1 = pColor1.GetPropertyValue< unsigned char >( "B" ); + + CMonoObject pColor2( pColor2 ); + + unsigned char ucR2 = pColor2.GetPropertyValue< unsigned char >( "R" ); + unsigned char ucG2 = pColor2.GetPropertyValue< unsigned char >( "G" ); + unsigned char ucB2 = pColor2.GetPropertyValue< unsigned char >( "B" ); + + CMonoObject pColor3( pColor3 ); + + unsigned char ucR3 = pColor3.GetPropertyValue< unsigned char >( "R" ); + unsigned char ucG3 = pColor3.GetPropertyValue< unsigned char >( "G" ); + unsigned char ucB3 = pColor3.GetPropertyValue< unsigned char >( "B" ); + + CMonoObject pColor4( pColor4 ); + + unsigned char ucR4 = pColor4.GetPropertyValue< unsigned char >( "R" ); + unsigned char ucG4 = pColor4.GetPropertyValue< unsigned char >( "G" ); + unsigned char ucB4 = pColor4.GetPropertyValue< unsigned char >( "B" ); + + return CLuaFunctionDefinitions::SetVehicleColor( RESOURCE->GetLua(), (void*)pUserData, ucR1, ucG1, ucB1, ucR2, ucG2, ucB2, ucR3, ucG3, ucB3, ucR4, ucG4, ucB4 ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetLandingGearDown( DWORD pUserData, bool bLandingGearDown ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleLandingGearDown( RESOURCE->GetLua(), (void*)pUserData, bLandingGearDown ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetLocked( DWORD pUserData, bool bLocked ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleLocked( RESOURCE->GetLua(), (void*)pUserData, bLocked ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetDoorsUndamageable( DWORD pUserData, bool bDoorsUndamageable ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleDoorsUndamageable( RESOURCE->GetLua(), (void*)pUserData, bDoorsUndamageable ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetSirensOn( DWORD pUserData, bool bSirensOn ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleSirensOn( RESOURCE->GetLua(), (void*)pUserData, bSirensOn ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetTaxiLightOn( DWORD pUserData, bool bTaxiLightState ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleTaxiLightOn( RESOURCE->GetLua(), (void*)pUserData, bTaxiLightState ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::AddUpgrade( DWORD pUserData, unsigned short usUpgrade ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::AddVehicleUpgrade( RESOURCE->GetLua(), (void*)pUserData, usUpgrade ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::RemoveUpgrade( DWORD pUserData, unsigned short usUpgrade ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RemoveVehicleUpgrade( RESOURCE->GetLua(), (void*)pUserData, usUpgrade ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetDoorState( DWORD pUserData, unsigned char ucDoor, unsigned char ucState ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleDoorState( RESOURCE->GetLua(), (void*)pUserData, ucDoor, ucState ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetWheelStates( DWORD pUserData, int iFrontLeft, int iRearLeft, int iFrontRight, int iRearRight ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleWheelStates( RESOURCE->GetLua(), (void*)pUserData, iFrontLeft, iRearLeft, iFrontRight, iRearRight ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetLightState( DWORD pUserData, unsigned char ucLight, unsigned char ucState ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleLightState( RESOURCE->GetLua(), (void*)pUserData, ucLight, ucState ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetPanelState( DWORD pUserData, unsigned char ucPanel, unsigned char ucState ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehiclePanelState( RESOURCE->GetLua(), (void*)pUserData, ucPanel, ucState ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetIdleRespawnDelay( DWORD pUserData, unsigned long ulTime ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleIdleRespawnDelay( RESOURCE->GetLua(), (void*)pUserData, ulTime ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetRespawnDelay( DWORD pUserData, unsigned long ulTime ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleRespawnDelay( RESOURCE->GetLua(), (void*)pUserData, ulTime ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetRespawnPosition( DWORD pUserData, MonoObject* pPosition, MonoObject* pRotation ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "X" ); + float fZ = pPosition.GetPropertyValue< float >( "X" ); + + CMonoObject pRotation( pRotation ); + + float fRX = pRotation.GetPropertyValue< float >( "X" ); + float fRY = pRotation.GetPropertyValue< float >( "X" ); + float fRZ = pRotation.GetPropertyValue< float >( "X" ); + + return CLuaFunctionDefinitions::SetVehicleRespawnPosition( RESOURCE->GetLua(), (void*)pUserData, fX, fY, fZ, fRX, fRY, fRZ ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::ToggleRespawn( DWORD pUserData, bool bRespawn ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ToggleVehicleRespawn( RESOURCE->GetLua(), (void*)pUserData, bRespawn ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::ResetExplosionTime( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetVehicleExplosionTime( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::ResetIdleTime( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetVehicleIdleTime( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::Spawn( DWORD pUserData, MonoObject* pPosition, MonoObject* pRotation ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "X" ); + float fZ = pPosition.GetPropertyValue< float >( "X" ); + + CMonoObject pRotation( pRotation ); + + float fRX = pRotation.GetPropertyValue< float >( "X" ); + float fRY = pRotation.GetPropertyValue< float >( "X" ); + float fRZ = pRotation.GetPropertyValue< float >( "X" ); + + return CLuaFunctionDefinitions::SpawnVehicle( RESOURCE->GetLua(), (void*)pUserData, fX, fY, fZ, fRX, fRY, fRZ ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::Respawn( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RespawnVehicle( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetOverrideLights( DWORD pUserData, unsigned char ucLights ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleOverrideLights( RESOURCE->GetLua(), (void*)pUserData, ucLights ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::AttachTrailer( DWORD pUserData, DWORD pTrailer ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::AttachTrailerToVehicle( RESOURCE->GetLua(), (void*)pUserData, (void*)pTrailer ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::DetachTrailer( DWORD pUserData, DWORD pTrailer ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::DetachTrailerFromVehicle( RESOURCE->GetLua(), (void*)pUserData, (void*)pTrailer ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetEngineState( DWORD pUserData, bool bState ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleEngineState( RESOURCE->GetLua(), (void*)pUserData, bState ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetDirtLevel( DWORD pUserData, float fDirtLevel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleDirtLevel( RESOURCE->GetLua(), (void*)pUserData, fDirtLevel ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetDamageProof( DWORD pUserData, bool bDamageProof ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleDamageProof( RESOURCE->GetLua(), (void*)pUserData, bDamageProof ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetPaintjob( DWORD pUserData, unsigned char ucPaintjob ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehiclePaintjob( RESOURCE->GetLua(), (void*)pUserData, ucPaintjob ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetFuelTankExplodable( DWORD pUserData, bool bExplodable ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleFuelTankExplodable( RESOURCE->GetLua(), (void*)pUserData, bExplodable ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetTrainDerailed( DWORD pUserData, bool bDerailed ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTrainDerailed( RESOURCE->GetLua(), (void*)pUserData, bDerailed ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetTrainDerailable( DWORD pUserData, bool bDerailable ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTrainDerailable( RESOURCE->GetLua(), (void*)pUserData, bDerailable ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetTrainDirection( DWORD pUserData, bool bDireciton ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTrainDirection( RESOURCE->GetLua(), (void*)pUserData, bDireciton ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetTrainSpeed( DWORD pUserData, float fSpeed ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTrainSpeed( RESOURCE->GetLua(), (void*)pUserData, fSpeed ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetHeadLightColor( DWORD pUserData, MonoObject* pColor ) +{ + if( RESOURCE ) + { + CMonoObject pColor1( pColor ); + + unsigned char ucR1 = pColor1.GetPropertyValue< unsigned char >( "R" ); + unsigned char ucG1 = pColor1.GetPropertyValue< unsigned char >( "G" ); + unsigned char ucB1 = pColor1.GetPropertyValue< unsigned char >( "B" ); + + return CLuaFunctionDefinitions::SetVehicleHeadLightColor( RESOURCE->GetLua(), (void*)pUserData, ucR1, ucG1, ucB1 ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetTurretPosition( DWORD pUserData, MonoObject* pPosition ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + + return CLuaFunctionDefinitions::SetVehicleTurretPosition( RESOURCE->GetLua(), (void*)pUserData, fX, fY ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetDoorOpenRatio( DWORD pUserData, unsigned char ucDoor, float fRatio, unsigned long ulTime ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleDoorOpenRatio( RESOURCE->GetLua(), (void*)pUserData, ucDoor, fRatio, ulTime ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetVariant( DWORD pUserData, unsigned char ucVariant, unsigned char ucVariant2 ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetVehicleVariant( RESOURCE->GetLua(), (void*)pUserData, ucVariant, ucVariant2 ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::GiveSirens( DWORD pUserData, unsigned char ucSirenType, unsigned char ucSirenCount, bool bFlag360, bool bCheckLosFlag, bool bUseRandomiserFlag, bool bSilentFlag ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GiveVehicleSirens( RESOURCE->GetLua(), (void*)pUserData, ucSirenType, ucSirenCount, bFlag360, bCheckLosFlag, bUseRandomiserFlag, bSilentFlag ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::RemoveSirens( DWORD pUserData ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RemoveVehicleSirens( RESOURCE->GetLua(), (void*)pUserData ); + } + + return false; +} + +bool CMonoFunctions::Vehicle::SetSirens( DWORD pUserData, unsigned char ucSirenID, MonoObject* pPosition, MonoObject* pColor, float fMinAlpha ) +{ + if( RESOURCE ) + { + CMonoObject pPosition( pPosition ); + + float fX = pPosition.GetPropertyValue< float >( "X" ); + float fY = pPosition.GetPropertyValue< float >( "Y" ); + float fZ = pPosition.GetPropertyValue< float >( "Z" ); + + CMonoObject pColor( pColor ); + + float fRed = pColor.GetPropertyValue< float >( "R" ); + float fGreen = pColor.GetPropertyValue< float >( "G" ); + float fBlue = pColor.GetPropertyValue< float >( "B" ); + float fAlpha = pColor.GetPropertyValue< float >( "A" ); + + return CLuaFunctionDefinitions::SetVehicleSirens( RESOURCE->GetLua(), (void*)pUserData, ucSirenID, fX, fY, fZ, fRed, fGreen, fBlue, fAlpha, fMinAlpha ); + } + + return false; +} + +MonoArray* CMonoFunctions::Vehicle::GetSirens( DWORD pUserData ) +{ + return NULL; +} + +MonoObject* CMonoFunctions::Vehicle::GetSirenParams( DWORD pUserData ) +{ + return NULL; +} + +bool CMonoFunctions::Vehicle::SetPlateText( DWORD pUserData, MonoString* msName ) +{ + if( RESOURCE ) + { + const char* szText = mono_string_to_utf8( msName ); + + return CLuaFunctionDefinitions::SetVehiclePlateText( RESOURCE->GetLua(), (void*)pUserData, szText ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_Water.cpp b/mta-mono/src/CMonoFunctions_Water.cpp new file mode 100644 index 0000000..529bdc2 --- /dev/null +++ b/mta-mono/src/CMonoFunctions_Water.cpp @@ -0,0 +1,137 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// Water funcs +DWORD CMonoFunctions::Water::Create( MonoObject* pV1, MonoObject* pV2, MonoObject* pV3, MonoObject* pV4, bool bShallow ) +{ + if( RESOURCE ) + { + Vector3* vec1 = &CMonoObject( pV1 ).GetVector3(); + Vector3* vec2 = &CMonoObject( pV2 ).GetVector3(); + Vector3* vec3 = &CMonoObject( pV3 ).GetVector3(); + Vector3* vec4 = pV4 ? &CMonoObject( pV4 ).GetVector3() : NULL; + + return (DWORD)CLuaFunctionDefinitions::CreateWater( RESOURCE->GetLua(), vec1, vec2, vec3, vec4, bShallow ); + } + + return NULL; +} + +bool CMonoFunctions::Water::SetLevel( DWORD pUserData, float fLevel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetElementWaterLevel( RESOURCE->GetLua(), (void*)pUserData, fLevel ); + } + + return false; +} + +bool CMonoFunctions::Water::SetLevelAll( float fLevel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetAllElementWaterLevel( RESOURCE->GetLua(), fLevel ); + } + + return false; +} + +bool CMonoFunctions::Water::SetLevelWorld( float fLevel, bool bIncludeWorldNonSeaLevel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetWorldWaterLevel( RESOURCE->GetLua(), fLevel, bIncludeWorldNonSeaLevel ); + } + + return false; +} + +bool CMonoFunctions::Water::ResetLevelWorld( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetWorldWaterLevel( RESOURCE->GetLua() ); + } + + return false; +} + +MonoObject* CMonoFunctions::Water::GetVertexPosition( DWORD pUserData, int iVertexIndex ) +{ + if( RESOURCE ) + { + Vector3 vecPosition; + + if( CLuaFunctionDefinitions::GetWaterVertexPosition( RESOURCE->GetLua(), (void*)pUserData, iVertexIndex, vecPosition ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecPosition ); + + return pObject ? pObject->GetObject() : NULL; + } + } + + return NULL; +} + +bool CMonoFunctions::Water::SetVertexPosition( DWORD pUserData, int iVertexIndex, MonoObject* mPosition ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( mPosition ).GetVector3(); + + return CLuaFunctionDefinitions::SetWaterVertexPosition( RESOURCE->GetLua(), (void*)pUserData, iVertexIndex, vecPosition ); + } + + return false; +} + +MonoObject* CMonoFunctions::Water::GetColor( void ) +{ + if( RESOURCE ) + { + SColor pColor; + + if( CLuaFunctionDefinitions::GetWaterColor( RESOURCE->GetLua(), pColor.R, pColor.G, pColor.B, pColor.A ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( pColor ); + + return pObject ? pObject->GetObject() : NULL; + } + } + + return NULL; +} + +bool CMonoFunctions::Water::SetColor( MonoObject* mColor ) +{ + if( RESOURCE ) + { + SColor pColor = CMonoObject( mColor ).GetColor(); + + return CLuaFunctionDefinitions::SetWaterColor( RESOURCE->GetLua(), pColor.R, pColor.G, pColor.B, pColor.A ); + } + + return false; +} + +bool CMonoFunctions::Water::ResetColor( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetWaterColor( RESOURCE->GetLua() ); + } + + return false; +} diff --git a/mta-mono/src/CMonoFunctions_World.cpp b/mta-mono/src/CMonoFunctions_World.cpp new file mode 100644 index 0000000..23bb9cf --- /dev/null +++ b/mta-mono/src/CMonoFunctions_World.cpp @@ -0,0 +1,904 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + +#include "CMonoFunctions.h" + +// General world get funcs +MonoArray* CMonoFunctions::World::GetTime( void ) +{ + if( RESOURCE ) + { + unsigned char ucHour, ucMinute; + + if( CLuaFunctionDefinitions::GetTime( RESOURCE->GetLua(), ucHour, ucMinute ) ) + { + MonoArray* pArray = mono_array_new( RESOURCE->m_pMonoDomain, mono_get_char_class(), 2 ); + + mono_array_set( pArray, unsigned char, 0, ucHour ); + mono_array_set( pArray, unsigned char, 1, ucMinute ); + + return pArray; + } + } + + return NULL; +} + +MonoArray* CMonoFunctions::World::GetWeather( void ) +{ + if( RESOURCE ) + { + unsigned char ucWeather, ucWeatherBlending; + + if( CLuaFunctionDefinitions::GetWeather( RESOURCE->GetLua(), ucWeather, ucWeatherBlending ) ) + { + MonoArray* pArray = mono_array_new( RESOURCE->m_pMonoDomain, mono_get_char_class(), 2 ); + + mono_array_set( pArray, unsigned char, 0, ucWeather ); + mono_array_set( pArray, unsigned char, 1, ucWeatherBlending ); + + return pArray; + } + } + + return NULL; +} + +MonoString* CMonoFunctions::World::GetZoneName( MonoObject* mPosition, bool bCitiesOnly ) +{ + if( RESOURCE ) + { + string strOutName; + + Vector3 vecPosition = CMonoObject( mPosition ).GetVector3(); + + if( CLuaFunctionDefinitions::GetZoneName( RESOURCE->GetLua(), vecPosition, strOutName, bCitiesOnly ) ) + { + return RESOURCE->NewString( strOutName ); + } + } + + return NULL; +} + +float CMonoFunctions::World::GetGravity( void ) +{ + if( RESOURCE ) + { + float fGravity; + + if( CLuaFunctionDefinitions::GetGravity( RESOURCE->GetLua(), fGravity ) ) + { + return fGravity; + } + } + + return 0.0f; +} + +float CMonoFunctions::World::GetGameSpeed( void ) +{ + if( RESOURCE ) + { + float fGameSpeed; + + if( CLuaFunctionDefinitions::GetGameSpeed( RESOURCE->GetLua(), fGameSpeed ) ) + { + return fGameSpeed; + } + } + + return 0.0f; +} + +float CMonoFunctions::World::GetWaveHeight( void ) +{ + if( RESOURCE ) + { + float fHeight; + + if( CLuaFunctionDefinitions::GetWaveHeight( RESOURCE->GetLua(), fHeight ) ) + { + return fHeight; + } + } + + return 0.0f; +} + +unsigned short CMonoFunctions::World::GetFPSLimit( void ) +{ + if( RESOURCE ) + { + unsigned short usLimit; + + if( CLuaFunctionDefinitions::GetFPSLimit( RESOURCE->GetLua(), usLimit ) ) + { + return usLimit; + } + } + + return 0; +} + +unsigned long CMonoFunctions::World::GetMinuteDuration( void ) +{ + if( RESOURCE ) + { + unsigned long usDuration; + + if( CLuaFunctionDefinitions::GetMinuteDuration( RESOURCE->GetLua(), usDuration ) ) + { + return usDuration; + } + } + + return 0; +} + +bool CMonoFunctions::World::IsGarageOpen( unsigned char ucGarageID ) +{ + if( RESOURCE ) + { + bool bIsOpen; + + if( CLuaFunctionDefinitions::IsGarageOpen( RESOURCE->GetLua(), ucGarageID, bIsOpen ) ) + { + return bIsOpen; + } + } + + return false; +} + +unsigned char CMonoFunctions::World::GetTrafficLightState( void ) +{ + if( RESOURCE ) + { + unsigned char ucState; + + if( CLuaFunctionDefinitions::GetTrafficLightState( RESOURCE->GetLua(), ucState ) ) + { + return ucState; + } + } + + return 0; +} + +bool CMonoFunctions::World::GetTrafficLightsLocked( void ) +{ + if( RESOURCE ) + { + bool bIsLocked; + + if( CLuaFunctionDefinitions::GetTrafficLightsLocked( RESOURCE->GetLua(), bIsLocked ) ) + { + return bIsLocked; + } + } + + return false; +} + +float CMonoFunctions::World::GetJetpackMaxHeight( void ) +{ + if( RESOURCE ) + { + float fHeight; + + if( CLuaFunctionDefinitions::GetJetpackMaxHeight( RESOURCE->GetLua(), fHeight ) ) + { + return fHeight; + } + } + + return 0.0f; +} + +float CMonoFunctions::World::GetAircraftMaxVelocity( void ) +{ + if( RESOURCE ) + { + float fVelocity; + + if( CLuaFunctionDefinitions::GetAircraftMaxVelocity( RESOURCE->GetLua(), fVelocity ) ) + { + return fVelocity; + } + } + + return 0.0f; +} + +bool CMonoFunctions::World::GetInteriorSoundsEnabled( void ) +{ + if( RESOURCE ) + { + bool bEnabled; + + if( CLuaFunctionDefinitions::GetInteriorSoundsEnabled( RESOURCE->GetLua(), bEnabled ) ) + { + return bEnabled; + } + } + + return false; +} + +float CMonoFunctions::World::GetRainLevel( void ) +{ + if( RESOURCE ) + { + float fRainLevel; + + if( CLuaFunctionDefinitions::GetRainLevel( RESOURCE->GetLua(), fRainLevel ) ) + { + return fRainLevel; + } + } + + return 0.0f; +} + +float CMonoFunctions::World::GetSunSize( void ) +{ + if( RESOURCE ) + { + float fSunSize; + + if( CLuaFunctionDefinitions::GetSunSize( RESOURCE->GetLua(), fSunSize ) ) + { + return fSunSize; + } + } + + return 0.0f; +} + +MonoArray* CMonoFunctions::World::GetSunColor( void ) +{ + if( RESOURCE ) + { + SColor pCore, pCorona; + + if( CLuaFunctionDefinitions::GetSunColor( RESOURCE->GetLua(), pCore.R, pCore.G, pCore.B, pCorona.R, pCorona.G, pCorona.B ) ) + { + pCore.A = pCorona.A = 255; + + CMonoObject* pCoreObject = RESOURCE->NewObject( pCore ); + CMonoObject* pCoronaObject = RESOURCE->NewObject( pCorona ); + + if( pCoreObject && pCoronaObject ) + { + MonoArray* pMonoArray = mono_array_new( RESOURCE->m_pMonoDomain, pCoreObject->GetClass()->GetClass(), 2 ); + + mono_array_set( pMonoArray, MonoObject*, 0, pCoreObject->GetObject() ); + mono_array_set( pMonoArray, MonoObject*, 1, pCoronaObject->GetObject() ); + + return pMonoArray; + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::World::GetWindVelocity( void ) +{ + if( RESOURCE ) + { + Vector3 vecVelocity; + + if( CLuaFunctionDefinitions::GetWindVelocity( RESOURCE->GetLua(), vecVelocity.fX, vecVelocity.fY, vecVelocity.fZ ) ) + { + CMonoObject* pObject = RESOURCE->NewObject( vecVelocity ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +float CMonoFunctions::World::GetFarClipDistance( void ) +{ + if( RESOURCE ) + { + float fFarClip; + + if( CLuaFunctionDefinitions::GetFarClipDistance( RESOURCE->GetLua(), fFarClip ) ) + { + return fFarClip; + } + } + + return 0.0f; +} + +float CMonoFunctions::World::GetFogDistance( void ) +{ + if( RESOURCE ) + { + float fFogDist; + + if( CLuaFunctionDefinitions::GetFogDistance( RESOURCE->GetLua(), fFogDist ) ) + { + return fFogDist; + } + } + + return 0.0f; +} + +float CMonoFunctions::World::GetAircraftMaxHeight( void ) +{ + if( RESOURCE ) + { + float fMaxHeight; + + if( CLuaFunctionDefinitions::GetAircraftMaxHeight( RESOURCE->GetLua(), fMaxHeight ) ) + { + return fMaxHeight; + } + } + + return 0.0f; +} + +bool CMonoFunctions::World::GetOcclusionsEnabled( void ) +{ + if( RESOURCE ) + { + bool bEnabled; + + if( CLuaFunctionDefinitions::GetOcclusionsEnabled( RESOURCE->GetLua(), bEnabled ) ) + { + return bEnabled; + } + } + + return false; +} + +int CMonoFunctions::World::GetMoonSize( void ) +{ + if( RESOURCE ) + { + int iSize; + + if( CLuaFunctionDefinitions::GetMoonSize( RESOURCE->GetLua(), iSize ) ) + { + return iSize; + } + } + + return 0; +} + +MonoArray* CMonoFunctions::World::GetSkyGradient( void ) +{ + if( RESOURCE ) + { + SColor pCore, pCorona; + + if( CLuaFunctionDefinitions::GetSkyGradient( RESOURCE->GetLua(), pCore.R, pCore.G, pCore.B, pCorona.R, pCorona.G, pCorona.B ) ) + { + pCore.A = pCorona.A = 255; + + CMonoObject* pCoreObject = RESOURCE->NewObject( pCore ); + CMonoObject* pCoronaObject = RESOURCE->NewObject( pCorona ); + + if( pCoreObject && pCoronaObject ) + { + MonoArray* pMonoArray = mono_array_new( RESOURCE->m_pMonoDomain, pCoreObject->GetClass()->GetClass(), 2 ); + + mono_array_set( pMonoArray, MonoObject*, 0, pCoreObject->GetObject() ); + mono_array_set( pMonoArray, MonoObject*, 1, pCoronaObject->GetObject() ); + + return pMonoArray; + } + } + } + + return NULL; +} + +MonoObject* CMonoFunctions::World::GetHeatHaze( void ) +{ + if( RESOURCE ) + { + SHeatHazeSettings heatHazeSettings; + + if( CLuaFunctionDefinitions::GetHeatHaze( RESOURCE->GetLua(), heatHazeSettings ) ) + { + void* args[] = + { + &heatHazeSettings + }; + + CMonoObject* pObject = RESOURCE->NewObject( "MultiTheftAuto", "HeatHazeSettings", args, 1 ); + + if( pObject ) + { + return pObject->GetObject(); + } + } + } + + return NULL; +} + +bool CMonoFunctions::World::GetJetpackWeaponEnabled( unsigned int uiWeaponType ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GetJetpackWeaponEnabled( RESOURCE->GetLua(), (eWeaponType)uiWeaponType ); + } + + return false; +} + +bool CMonoFunctions::World::GetCloudsEnabled( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::GetCloudsEnabled( RESOURCE->GetLua() ); + } + + return false; +} + + +// General world set funcs +bool CMonoFunctions::World::SetTime( unsigned char ucHour, unsigned char ucMinute ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTime( RESOURCE->GetLua(), ucHour, ucMinute ); + } + + return false; +} + +bool CMonoFunctions::World::SetWeather( unsigned char ucWeather ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetWeather( RESOURCE->GetLua(), ucWeather ); + } + + return false; +} + +bool CMonoFunctions::World::SetWeatherBlended( unsigned char ucWeather ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetWeatherBlended( RESOURCE->GetLua(), ucWeather ); + } + + return false; +} + +bool CMonoFunctions::World::SetGravity( float fGravity ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetGravity( RESOURCE->GetLua(), fGravity ); + } + + return false; +} + +bool CMonoFunctions::World::SetGameSpeed( float fSpeed ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetGameSpeed( RESOURCE->GetLua(), fSpeed ); + } + + return false; +} + +bool CMonoFunctions::World::SetWaveHeight( float fHeight ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetWaveHeight( RESOURCE->GetLua(), fHeight ); + } + + return false; +} + +bool CMonoFunctions::World::SetSkyGradient( MonoObject* pTopColor, MonoObject* pBottomColor ) +{ + if( RESOURCE ) + { + SColor pTop = CMonoObject( pTopColor ).GetColor(); + SColor pBottom = CMonoObject( pBottomColor ).GetColor(); + + return CLuaFunctionDefinitions::SetSkyGradient( RESOURCE->GetLua(), pTop.R, pTop.G, pTop.B, pBottom.R, pBottom.G, pBottom.B ); + } + + return false; +} + +bool CMonoFunctions::World::ResetSkyGradient( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetSkyGradient( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::SetHeatHaze( MonoObject* heatHazeSettings ) +{ + if( RESOURCE ) + { + CMonoObject* pObject = new CMonoObject( heatHazeSettings ); + + SHeatHazeSettings pHeatHazeSettings; + + pHeatHazeSettings.ucIntensity = pObject->GetPropertyValue< unsigned char >( "ucIntensity" ); + pHeatHazeSettings.ucRandomShift = pObject->GetPropertyValue< unsigned char >( "ucRandomShift" ); + pHeatHazeSettings.usSpeedMin = pObject->GetPropertyValue< unsigned short >( "usSpeedMin" ); + pHeatHazeSettings.usSpeedMax = pObject->GetPropertyValue< unsigned short >( "usSpeedMax" ); + pHeatHazeSettings.sScanSizeX = pObject->GetPropertyValue< short >( "sScanSizeX" ); + pHeatHazeSettings.sScanSizeY = pObject->GetPropertyValue< short >( "sScanSizeY" ); + pHeatHazeSettings.usRenderSizeX = pObject->GetPropertyValue< unsigned short >( "usRenderSizeX" ); + pHeatHazeSettings.usRenderSizeY = pObject->GetPropertyValue< unsigned short >( "usRenderSizeY" ); + pHeatHazeSettings.bInsideBuilding = pObject->GetPropertyValue< bool >( "bInsideBuilding" ); + + return CLuaFunctionDefinitions::SetHeatHaze( RESOURCE->GetLua(), pHeatHazeSettings ); + } + + return false; +} + +bool CMonoFunctions::World::ResetHeatHaze( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetHeatHaze( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::SetFPSLimit( unsigned short usLimit, bool bSave ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetFPSLimit( RESOURCE->GetLua(), usLimit, bSave ); + } + + return false; +} + +bool CMonoFunctions::World::SetMinuteDuration( unsigned long ulDuration ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetMinuteDuration( RESOURCE->GetLua(), ulDuration ); + } + + return false; +} + +bool CMonoFunctions::World::SetGarageOpen( unsigned char ucGarageID, bool bIsOpen ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetGarageOpen( RESOURCE->GetLua(), ucGarageID, bIsOpen ); + } + + return false; +} + +bool CMonoFunctions::World::SetGlitchEnabled( MonoString* msGlitchName, bool bEnabled ) +{ + if( RESOURCE ) + { + string strGlitchName( mono_string_to_utf8( msGlitchName ) ); + + return CLuaFunctionDefinitions::SetGlitchEnabled( RESOURCE->GetLua(), strGlitchName, bEnabled ); + } + + return false; +} + +bool CMonoFunctions::World::IsGlitchEnabled( MonoString* msGlitchName ) +{ + if( RESOURCE ) + { + string strGlitchName( mono_string_to_utf8( msGlitchName ) ); + + return CLuaFunctionDefinitions::IsGlitchEnabled( RESOURCE->GetLua(), strGlitchName ); + } + + return false; +} + +bool CMonoFunctions::World::SetJetpackWeaponEnabled( unsigned int uiWeaponType, bool bEnabled ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetJetpackWeaponEnabled( RESOURCE->GetLua(), (eWeaponType)uiWeaponType, bEnabled ); + } + + return false; +} + +bool CMonoFunctions::World::SetCloudsEnabled( bool bEnabled ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetCloudsEnabled( RESOURCE->GetLua(), bEnabled ); + } + + return false; +} + +bool CMonoFunctions::World::SetTrafficLightState( unsigned char ucState, bool bForced ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTrafficLightState( RESOURCE->GetLua(), ucState, bForced ); + } + + return false; +} + +bool CMonoFunctions::World::SetTrafficLightsLocked( bool bLocked ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetTrafficLightsLocked( RESOURCE->GetLua(), bLocked ); + } + + return false; +} + +bool CMonoFunctions::World::SetJetpackMaxHeight( float fMaxHeight ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetJetpackMaxHeight( RESOURCE->GetLua(), fMaxHeight ); + } + + return false; +} + +bool CMonoFunctions::World::SetInteriorSoundsEnabled( bool bEnable ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetInteriorSoundsEnabled( RESOURCE->GetLua(), bEnable ); + } + + return false; +} + +bool CMonoFunctions::World::SetRainLevel( float fRainLevel ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetRainLevel( RESOURCE->GetLua(), fRainLevel ); + } + + return false; +} + +bool CMonoFunctions::World::SetSunSize( float fSunSize ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetSunSize( RESOURCE->GetLua(), fSunSize ); + } + + return false; +} + +bool CMonoFunctions::World::SetSunColor( MonoObject* pCoreColor, MonoObject* pCoronaColor ) +{ + if( RESOURCE ) + { + SColor pTop = CMonoObject( pCoreColor ).GetColor(); + SColor pBottom = CMonoObject( pCoronaColor ).GetColor(); + + return CLuaFunctionDefinitions::SetSunColor( RESOURCE->GetLua(), pTop.R, pTop.G, pTop.B, pBottom.R, pBottom.G, pBottom.B ); + } + + return false; +} + +bool CMonoFunctions::World::SetWindVelocity( MonoObject* pVelocity ) +{ + if( RESOURCE ) + { + Vector3 vecVelocity = CMonoObject( pVelocity ).GetVector3(); + + return CLuaFunctionDefinitions::SetWindVelocity( RESOURCE->GetLua(), vecVelocity.fX, vecVelocity.fY, vecVelocity.fZ ); + } + + return false; +} + +bool CMonoFunctions::World::SetFarClipDistance( float fFarClip ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetFarClipDistance( RESOURCE->GetLua(), fFarClip ); + } + + return false; +} + +bool CMonoFunctions::World::SetFogDistance( float fFogDist ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetFogDistance( RESOURCE->GetLua(), fFogDist ); + } + + return false; +} + +bool CMonoFunctions::World::SetAircraftMaxHeight( float fMaxHeight ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetAircraftMaxHeight( RESOURCE->GetLua(), fMaxHeight ); + } + + return false; +} + +bool CMonoFunctions::World::SetAircraftMaxVelocity( float fVelocity ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetAircraftMaxVelocity( RESOURCE->GetLua(), fVelocity ); + } + + return false; +} + +bool CMonoFunctions::World::SetOcclusionsEnabled( bool bEnabled ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetOcclusionsEnabled( RESOURCE->GetLua(), bEnabled ); + } + + return false; +} + +bool CMonoFunctions::World::ResetRainLevel( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetRainLevel( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::ResetSunSize( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetSunSize( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::ResetSunColor( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetSunColor( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::ResetWindVelocity( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetWindVelocity( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::ResetFarClipDistance( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetFarClipDistance( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::ResetFogDistance( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetFogDistance( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::RemoveWorldModel( unsigned short usModel, float fRadius, MonoObject* pPosition, char cInterior ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + + return CLuaFunctionDefinitions::RemoveWorldModel( RESOURCE->GetLua(), usModel, fRadius, vecPosition, cInterior ); + } + + return false; +} + +bool CMonoFunctions::World::RestoreWorldModel( unsigned short usModel, float fRadius, MonoObject* pPosition, char cInterior ) +{ + if( RESOURCE ) + { + Vector3 vecPosition = CMonoObject( pPosition ).GetVector3(); + + return CLuaFunctionDefinitions::RestoreWorldModel( RESOURCE->GetLua(), usModel, fRadius, vecPosition, cInterior ); + } + + return false; +} + +bool CMonoFunctions::World::RestoreAllWorldModels( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::RestoreAllWorldModels( RESOURCE->GetLua() ); + } + + return false; +} + +bool CMonoFunctions::World::SetMoonSize( int iMoonSize ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::SetMoonSize( RESOURCE->GetLua(), iMoonSize ); + } + + return false; +} + +bool CMonoFunctions::World::ResetMoonSize( void ) +{ + if( RESOURCE ) + { + return CLuaFunctionDefinitions::ResetMoonSize( RESOURCE->GetLua() ); + } + + return false; +} diff --git a/mta-mono/src/CMonoObject.cpp b/mta-mono/src/CMonoObject.cpp index 38ba559..bdd3313 100644 --- a/mta-mono/src/CMonoObject.cpp +++ b/mta-mono/src/CMonoObject.cpp @@ -1,3 +1,15 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + #include "CMonoObject.h" CMonoObject::CMonoObject( MonoObject* pMonoObject ) diff --git a/mta-mono/src/CMonoObject.h b/mta-mono/src/CMonoObject.h index 92b5a01..903597b 100644 --- a/mta-mono/src/CMonoObject.h +++ b/mta-mono/src/CMonoObject.h @@ -1,3 +1,15 @@ +/********************************************************* +* +* Copyright © 2013, Innovation Roleplay Engine. +* +* All Rights Reserved. +* +* Redistribution and use in source and binary forms, +* with or without modification, +* is permitted only for authors. +* +*********************************************************/ + class CMonoObject; #ifndef _C_MONO_OBJECT @@ -24,6 +36,35 @@ public: MonoObject* GetPropertyValue( const char* szPropertyName ); + Vector2 GetVector2() + { + float fX = this->GetPropertyValue< float >( "X" ); + float fY = this->GetPropertyValue< float >( "Y" ); + + return Vector2( fX, fY ); + } + + Vector3 GetVector3() + { + float fX = this->GetPropertyValue< float >( "X" ); + float fY = this->GetPropertyValue< float >( "Y" ); + float fZ = this->GetPropertyValue< float >( "Z" ); + + return Vector3( fX, fY, fZ ); + } + + SColor GetColor() + { + SColor pColor; + + pColor.R = this->GetPropertyValue< unsigned char >( "R" ); + pColor.G = this->GetPropertyValue< unsigned char >( "G" ); + pColor.B = this->GetPropertyValue< unsigned char >( "B" ); + pColor.A = this->GetPropertyValue< unsigned char >( "A" ); + + return pColor; + } + template T GetPropertyValue( char* szPropertyName ) { return *( reinterpret_cast( mono_object_unbox( this->GetPropertyValue( szPropertyName ) ) ) ); diff --git a/mta-mono/src/CResource.cpp b/mta-mono/src/CResource.cpp index 0463462..97ff331 100644 --- a/mta-mono/src/CResource.cpp +++ b/mta-mono/src/CResource.cpp @@ -160,9 +160,34 @@ CMonoObject* CResource::NewObject( const char* szNamespace, const char* szName ) return NULL; } -CMonoObject* CResource::NewObject( const char* szNamespace, const char* szName, Vector3& vecVector ) +CMonoObject* CResource::NewObject( SColor& pColor ) { - CMonoClass* pClass = this->GetClassFromName( szNamespace, szName ); + CMonoClass* pClass = this->GetClassFromName( "MultiTheftAuto", "Color" ); + + if( pClass ) + { + CMonoObject* pObject = pClass->New( mono_domain_get(), pColor ); + + if( pObject ) + { + return pObject; + } + else + { + g_pModuleManager->ErrorPrintf( "%s:%d: failed to create instance of 'MultiTheftAuto::Vector2'\n", __FILE__, __LINE__ ); + } + } + else + { + g_pModuleManager->ErrorPrintf( "%s:%d: class 'MultiTheftAuto::Vector2' not found\n", __FILE__, __LINE__ ); + } + + return NULL; +} + +CMonoObject* CResource::NewObject( Vector2& vecVector ) +{ + CMonoClass* pClass = this->GetClassFromName( "MultiTheftAuto", "Vector2" ); if( pClass ) { @@ -174,12 +199,37 @@ CMonoObject* CResource::NewObject( const char* szNamespace, const char* szName, } else { - g_pModuleManager->ErrorPrintf( "%s:%d: failed to create instance of '%s::%s'\n", __FILE__, __LINE__, szNamespace, szName ); + g_pModuleManager->ErrorPrintf( "%s:%d: failed to create instance of 'MultiTheftAuto::Vector2'\n", __FILE__, __LINE__ ); } } else { - g_pModuleManager->ErrorPrintf( "%s:%d: class '%s::%s' not found\n", __FILE__, __LINE__, szNamespace, szName ); + g_pModuleManager->ErrorPrintf( "%s:%d: class 'MultiTheftAuto::Vector2' not found\n", __FILE__, __LINE__ ); + } + + return NULL; +} + +CMonoObject* CResource::NewObject( Vector3& vecVector ) +{ + CMonoClass* pClass = this->GetClassFromName( "MultiTheftAuto", "Vector3" ); + + if( pClass ) + { + CMonoObject* pObject = pClass->New( mono_domain_get(), vecVector ); + + if( pObject ) + { + return pObject; + } + else + { + g_pModuleManager->ErrorPrintf( "%s:%d: failed to create instance of 'MultiTheftAuto::Vector3'\n", __FILE__, __LINE__ ); + } + } + else + { + g_pModuleManager->ErrorPrintf( "%s:%d: class 'MultiTheftAuto::Vector3' not found\n", __FILE__, __LINE__ ); } return NULL; diff --git a/mta-mono/src/CResource.h b/mta-mono/src/CResource.h index 4641153..b3beeb6 100644 --- a/mta-mono/src/CResource.h +++ b/mta-mono/src/CResource.h @@ -17,6 +17,7 @@ class CResource; #include "Common.h" #include "CMonoClass.h" +#include "extra/CLuaArguments.h" class CResource { @@ -45,7 +46,9 @@ public: CMonoClass* GetClassFromName( const char* szNamespace, const char* szName ); CMonoObject* NewObject( const char* szNamespace, const char* szName ); - CMonoObject* NewObject( const char* szNamespace, const char* szName, Vector3& vecVector ); + CMonoObject* NewObject( SColor& pColor ); + CMonoObject* NewObject( Vector2& vecVector ); + CMonoObject* NewObject( Vector3& vecVector ); CMonoObject* NewObject( const char* szNamespace, const char* szName, void** args, int argc ); MonoString* NewString( const char* szText ) @@ -58,6 +61,42 @@ public: return mono_string_new( this->m_pMonoDomain, strText.c_str() ); } + template MonoArray* NewArray( MonoClass* pMonoClass, CLuaArguments* pLuaArguments = NULL ) + { + MonoArray* pArray = mono_array_new( this->m_pMonoDomain, pMonoClass, pLuaArguments ? pLuaArguments->Count() : 0 ); + + if( pLuaArguments ) + { + vector< CLuaArgument* >::const_iterator iter = pLuaArguments->IterBegin(); + + for( unsigned int i = 0; iter != pLuaArguments->IterEnd(); iter++, i++ ) + { + if( LuaType == LUA_TBOOLEAN ) + { + mono_array_set( pArray, T, i, (T)( ( *iter )->GetBoolean() ) ); + } + else if( LuaType == LUA_TLIGHTUSERDATA ) + { + mono_array_set( pArray, T, i, (T)( ( *iter )->GetLightUserData() ) ); + } + else if( LuaType == LUA_TNUMBER ) + { + mono_array_set( pArray, T, i, ( *iter )->GetNumber< T >() ); + } + else if( LuaType == LUA_TSTRING ) + { + mono_array_set( pArray, T, i, (T)( ( *iter )->GetString() ) ); + } + else if( LuaType == LUA_TUSERDATA ) + { + mono_array_set( pArray, T, i, (T)( ( *iter )->GetLightUserData() ) ); + } + } + } + + return pArray; + } + string GetName ( void ) { return this->m_sName; } lua_State *GetLua ( void ) { return this->m_pLuaVM; } }; diff --git a/mta-mono/src/Common.h b/mta-mono/src/Common.h index 553dd94..e7a4021 100644 --- a/mta-mono/src/Common.h +++ b/mta-mono/src/Common.h @@ -31,6 +31,7 @@ extern "C" #include #include +#include #include #include #include diff --git a/mta-mono/src/extra/CLuaArgument.cpp b/mta-mono/src/extra/CLuaArgument.cpp index 00f1e61..4fcd05e 100644 --- a/mta-mono/src/extra/CLuaArgument.cpp +++ b/mta-mono/src/extra/CLuaArgument.cpp @@ -62,6 +62,7 @@ CLuaArgument::CLuaArgument ( void* pUserData ) m_pLightUserData = pUserData; } + CLuaArgument::CLuaArgument( lua_CFunction Function ) { m_szString = NULL; @@ -208,7 +209,7 @@ bool CLuaArgument::operator != ( const CLuaArgument& Argument ) } -void CLuaArgument::Read ( lua_State* luaVM, unsigned int uiArgument ) +void CLuaArgument::Read ( lua_State* luaVM, signed int uiArgument ) { // Eventually delete our previous string if ( m_szString ) @@ -219,6 +220,7 @@ void CLuaArgument::Read ( lua_State* luaVM, unsigned int uiArgument ) // Grab the argument type m_iType = lua_type ( luaVM, uiArgument ); + if ( m_iType != LUA_TNONE ) { // Read out the content depending on the type @@ -264,6 +266,34 @@ void CLuaArgument::Read ( lua_State* luaVM, unsigned int uiArgument ) break; } + case LUA_TTABLE: + { + m_pTable.clear(); + + m_pArray = new CLuaArguments(); + + lua_pushnil( luaVM ); + + uiArgument--; + + while( lua_next( luaVM, uiArgument ) != 0 ) + { + CLuaArgument pKey( luaVM, -2 ); + CLuaArgument pValue( luaVM, -1 ); + + if( pKey.GetType() == LUA_TSTRING ) + { + m_pTable[ string( pKey.GetString() ) ] = &pValue; + } + + m_pArray->PushArgument( pValue ); + + lua_pop( luaVM, 1 ); + } + + break; + } + default: { m_iType = LUA_TNONE; diff --git a/mta-mono/src/extra/CLuaArgument.h b/mta-mono/src/extra/CLuaArgument.h index 9209499..09fc420 100644 --- a/mta-mono/src/extra/CLuaArgument.h +++ b/mta-mono/src/extra/CLuaArgument.h @@ -16,6 +16,8 @@ * *********************************************************/ +class CLuaArgument; + #ifndef __CLUAARGUMENT_H #define __CLUAARGUMENT_H @@ -24,6 +26,12 @@ extern "C" #include } +#include "CLuaArguments.h" +#include +#include + +typedef std::map LuaTable; + class CLuaArgument { public: @@ -41,15 +49,17 @@ public: bool operator == ( const CLuaArgument& Argument ); bool operator != ( const CLuaArgument& Argument ); - void Read ( lua_State* luaVM, unsigned int uiArgument ); + void Read ( lua_State* luaVM, signed int uiArgument ); void Push ( lua_State* luaVM ) const; inline int GetType ( void ) const { return m_iType; }; - inline bool GetBoolean ( void ) const { return m_bBoolean; }; - inline lua_Number GetNumber ( void ) const { return m_Number; }; - inline const char* GetString ( void ) const { return m_szString; }; - inline void* GetLightUserData ( void ) const { return m_pLightUserData; }; + inline bool GetBoolean ( void ) const { return m_bBoolean; }; + inline lua_Number GetNumber ( void ) const { return m_Number; }; + inline const char* GetString ( void ) const { return m_szString; }; + inline void* GetLightUserData ( void ) const { return m_pLightUserData; }; + inline CLuaArguments* GetArray ( void ) const { return m_pArray; }; + inline LuaTable GetTable ( void ) const { return m_pTable; }; template T GetNumber() { @@ -57,12 +67,14 @@ public: } private: - int m_iType; - bool m_bBoolean; - lua_Number m_Number; - char* m_szString; - void* m_pLightUserData; - lua_CFunction m_Function; + int m_iType; + bool m_bBoolean; + lua_Number m_Number; + char* m_szString; + void* m_pLightUserData; + lua_CFunction m_Function; + CLuaArguments* m_pArray; + LuaTable m_pTable; }; #endif diff --git a/mta-mono/src/extra/CLuaArguments.h b/mta-mono/src/extra/CLuaArguments.h index 2397d15..5f9ddc4 100644 --- a/mta-mono/src/extra/CLuaArguments.h +++ b/mta-mono/src/extra/CLuaArguments.h @@ -16,6 +16,8 @@ * *********************************************************/ +class CLuaArguments; + #ifndef __CLUAARGUMENTS_H #define __CLUAARGUMENTS_H @@ -24,8 +26,8 @@ extern "C" #include } -#include "CLuaArgument.h" #include +#include "CLuaArgument.h" using namespace std; diff --git a/mta-mono/src/lua/CLuaFunctionDefinitions.cpp b/mta-mono/src/lua/CLuaFunctionDefinitions.cpp index 538a142..222e098 100644 --- a/mta-mono/src/lua/CLuaFunctionDefinitions.cpp +++ b/mta-mono/src/lua/CLuaFunctionDefinitions.cpp @@ -225,6 +225,27 @@ void* CLuaFunctionDefinitions::CloneElement( lua_State* pLuaVM, void* pUserData, // Element get funcs +CLuaArguments* CLuaFunctionDefinitions::GetElementsByType( lua_State* pLuaVM, const char* szTypeName, void* pUserData ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushString( szTypeName ); + + if( pUserData ) + { + pLuaArguments.PushUserData( pUserData ); + } + + if( pLuaArguments.Call( pLuaVM, "getElementsByType", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetArray(); + } + + return NULL; +} + bool CLuaFunctionDefinitions::IsElement( lua_State* pLuaVM, void* pUserData ) { CLuaArguments pLuaArguments; @@ -251,7 +272,10 @@ string CLuaFunctionDefinitions::GetElementType( lua_State* pLuaVM, void* pUserDa { CLuaArgument pLuaArgument( pLuaVM, -1 ); - return string( pLuaArgument.GetString() ); + if( pLuaArgument.GetString() ) + { + return string( pLuaArgument.GetString() ); + } } return string(); @@ -1307,28 +1331,28 @@ bool CLuaFunctionDefinitions::GetPlayerWantedLevel( lua_State* pLuaVM, void* pUs return false; } -bool CLuaFunctionDefinitions::GetAlivePlayers( lua_State* pLuaVM ) +CLuaArguments* CLuaFunctionDefinitions::GetAlivePlayers( lua_State* pLuaVM ) { CLuaArguments pLuaArguments; if( pLuaArguments.Call( pLuaVM, "getAlivePlayers", 1 ) ) { -// CLuaArgument( pLuaVM, -1 ).GetNumber(); + return CLuaArgument( pLuaVM, -1 ).GetArray(); } - return false; + return NULL; } -bool CLuaFunctionDefinitions::GetDeadPlayers( lua_State* pLuaVM ) +CLuaArguments* CLuaFunctionDefinitions::GetDeadPlayers( lua_State* pLuaVM ) { CLuaArguments pLuaArguments; if( pLuaArguments.Call( pLuaVM, "getDeadPlayers", 1 ) ) { -// CLuaArgument( pLuaVM, -1 ).GetNumber(); + return CLuaArgument( pLuaVM, -1 ).GetArray(); } - return false; + return NULL; } bool CLuaFunctionDefinitions::GetPlayerIdleTime( lua_State* pLuaVM, void* pUserData, unsigned int& uiIdleTime ) @@ -1523,20 +1547,20 @@ string CLuaFunctionDefinitions::GetPlayerVersion( lua_State* pLuaVM, void* pUser return string(); } -int CLuaFunctionDefinitions::GetPlayerACInfo( lua_State* pLuaVM, void* pUserData ) +LuaTable CLuaFunctionDefinitions::GetPlayerACInfo( lua_State* pLuaVM, void* pUserData ) { + map pLuaTable; + CLuaArguments pLuaArguments; pLuaArguments.PushUserData( pUserData ); if( pLuaArguments.Call( pLuaVM, "getPlayerACInfo", 1 ) ) { - CLuaArgument pLuaArgument( pLuaVM, -1 ); - - // TODO + pLuaTable = CLuaArgument( pLuaVM, -1 ).GetTable(); } - return 0; + return pLuaTable; } // Player set functions @@ -1760,14 +1784,14 @@ bool CLuaFunctionDefinitions::SetPlayerBlurLevel( lua_State* pLuaVM, void* pUser return false; } -bool CLuaFunctionDefinitions::RedirectPlayer( lua_State* pLuaVM, void* pUserData, string sServerIP, int iServerPort, string sServerPassword ) +bool CLuaFunctionDefinitions::RedirectPlayer( lua_State* pLuaVM, void* pUserData, const char* szServerIP, int iServerPort, const char* szServerPassword ) { CLuaArguments pLuaArguments; pLuaArguments.PushUserData( pUserData ); - pLuaArguments.PushString( sServerIP.c_str() ); + pLuaArguments.PushString( szServerIP ); pLuaArguments.PushNumber( iServerPort ); - pLuaArguments.PushString( sServerPassword.c_str() ); + pLuaArguments.PushString( szServerPassword ); if( pLuaArguments.Call( pLuaVM, "redirectPlayer", 1 ) ) { @@ -2210,6 +2234,42 @@ bool CLuaFunctionDefinitions::IsPedInVehicle( lua_State* pLuaVM, void* pUserData return false; } +bool CLuaFunctionDefinitions::GetWeaponProperty( lua_State* pLuaVM, unsigned char ucWeaponID, const char* szWeaponSkill, const char* szProperty, short& uData ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushNumber( ucWeaponID ); + pLuaArguments.PushString( szWeaponSkill ); + pLuaArguments.PushString( szProperty ); + + if( pLuaArguments.Call( pLuaVM, "getWeaponProperty", 1 ) ) + { + uData = CLuaArgument( pLuaVM, -1 ).GetNumber< short >(); + + return true; + } + + return false; +} + +bool CLuaFunctionDefinitions::GetOriginalWeaponProperty( lua_State* pLuaVM, unsigned char ucWeaponID, const char* szWeaponSkill, const char* szProperty, short& uData ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushNumber( ucWeaponID ); + pLuaArguments.PushString( szWeaponSkill ); + pLuaArguments.PushString( szProperty ); + + if( pLuaArguments.Call( pLuaVM, "getOriginalWeaponProperty", 1 ) ) + { + uData = CLuaArgument( pLuaVM, -1 ).GetNumber< short >(); + + return true; + } + + return false; +} + // Ped set functions bool CLuaFunctionDefinitions::SetPedArmor( lua_State* pLuaVM, void* pUserData, float fArmor ) @@ -2581,6 +2641,23 @@ bool CLuaFunctionDefinitions::ReloadPedWeapon( lua_State* pLuaVM, void* pUserDat return false; } +bool CLuaFunctionDefinitions::SetWeaponProperty( lua_State* pLuaVM, unsigned char ucWeaponID, const char* szWeaponSkill, const char* szProperty, short uData ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushNumber( ucWeaponID ); + pLuaArguments.PushString( szWeaponSkill ); + pLuaArguments.PushString( szProperty ); + pLuaArguments.PushNumber( uData ); + + if( pLuaArguments.Call( pLuaVM, "setWeaponProperty", 1 ) ) + { + return CLuaArgument( pLuaVM, -1 ).GetBoolean(); + } + + return false; +} + // Vehicle create/destroy functions void* CLuaFunctionDefinitions::CreateVehicle( lua_State* pLuaVM, int model, float fX, float fY, float fZ, float fRX, float fRY, float fRZ, string numberplate, bool direction, int variant1, int variant2 ) @@ -2748,11 +2825,10 @@ bool CLuaFunctionDefinitions::GetVehicleName( lua_State* pLuaVM, void* pUserData return false; } -bool CLuaFunctionDefinitions::GetVehicleNameFromModel( lua_State* pLuaVM, void* pUserData, unsigned short usModel, string& strOutName ) +bool CLuaFunctionDefinitions::GetVehicleNameFromModel( lua_State* pLuaVM, unsigned short usModel, string& strOutName ) { CLuaArguments pLuaArguments; - pLuaArguments.PushUserData( pUserData ); pLuaArguments.PushNumber( usModel ); if( pLuaArguments.Call( pLuaVM, "getVehicleNameFromModel", 1 ) ) @@ -2790,9 +2866,7 @@ CLuaArguments* CLuaFunctionDefinitions::GetVehicleOccupants( lua_State* pLuaVM, if( pLuaArguments.Call( pLuaVM, "getVehicleOccupants", 1 ) ) { - CLuaArgument pLuaArgument( pLuaVM, -1 ); - - //return pLuaArgument.GetLightUserData(); + return CLuaArgument( pLuaVM, -1 ).GetArray(); } return NULL; @@ -2881,20 +2955,18 @@ bool CLuaFunctionDefinitions::IsVehicleLocked( lua_State* pLuaVM, void* pUserDat return false; } -CLuaArguments* CLuaFunctionDefinitions::GetVehiclesOfType( lua_State* pLuaVM, void* pUserData ) +CLuaArguments* CLuaFunctionDefinitions::GetVehiclesOfType( lua_State* pLuaVM, unsigned int uiModel ) { - CLuaArguments pLuaArguments; + CLuaArguments* pLuaArguments = new CLuaArguments(); - pLuaArguments.PushUserData( pUserData ); + pLuaArguments->PushNumber( uiModel ); - if( pLuaArguments.Call( pLuaVM, "getVehiclesOfType", 1 ) ) + if( pLuaArguments->Call( pLuaVM, "getVehiclesOfType", 1 ) ) { - CLuaArgument pLuaArgument( pLuaVM, -1 ); - - //return pLuaArgument.GetBoolean(); + return CLuaArgument( pLuaVM, -1 ).GetArray(); } - return false; + return NULL; } bool CLuaFunctionDefinitions::GetVehicleUpgradeOnSlot( lua_State* pLuaVM, void* pUserData, unsigned char ucSlot, unsigned short& usUpgrade ) @@ -2922,9 +2994,7 @@ CLuaArguments* CLuaFunctionDefinitions::GetVehicleUpgrades( lua_State* pLuaVM, v if( pLuaArguments.Call( pLuaVM, "getVehicleUpgrades", 1 ) ) { - CLuaArgument pLuaArgument( pLuaVM, -1 ); - - //return pLuaArgument.GetNumber(); + return CLuaArgument( pLuaVM, -1 ).GetArray(); } return NULL; @@ -2970,9 +3040,7 @@ CLuaArguments* CLuaFunctionDefinitions::GetVehicleCompatibleUpgrades( lua_State* if( pLuaArguments.Call( pLuaVM, "getVehicleCompatibleUpgrades", 1 ) ) { - CLuaArgument pLuaArgument( pLuaVM, -1 ); - - //return pLuaArgument.GetString(); + return CLuaArgument( pLuaVM, -1 ).GetArray(); } return NULL; @@ -5692,7 +5760,7 @@ bool CLuaFunctionDefinitions::SetTeamFriendlyFire( lua_State* pLuaVM, void* pTea // Water funcs -void* CLuaFunctionDefinitions::CreateWater( lua_State* pLuaVM, Vector3* pV1, Vector3* pV2, Vector3* pV3, Vector3* pV4 ) +void* CLuaFunctionDefinitions::CreateWater( lua_State* pLuaVM, Vector3* pV1, Vector3* pV2, Vector3* pV3, Vector3* pV4, bool bShallow ) { CLuaArguments pLuaArguments; @@ -5715,6 +5783,8 @@ void* CLuaFunctionDefinitions::CreateWater( lua_State* pLuaVM, Vector3* pV1, Vec pLuaArguments.PushNumber( pV4->fZ ); } + pLuaArguments.PushBoolean( bShallow ); + if( pLuaArguments.Call( pLuaVM, "createWater", 1 ) ) { CLuaArgument pLuaArgument( pLuaVM, -1 ); @@ -7184,7 +7254,7 @@ void* CLuaFunctionDefinitions::GetAccount( lua_State* pLuaVM, const char* szName return NULL; } -bool CLuaFunctionDefinitions::GetAccounts( lua_State* pLuaVM ) // TODO +CLuaArguments* CLuaFunctionDefinitions::GetAccounts( lua_State* pLuaVM ) { CLuaArguments pLuaArguments; @@ -7192,7 +7262,7 @@ bool CLuaFunctionDefinitions::GetAccounts( lua_State* pLuaVM ) // TODO { CLuaArgument pLuaArgument( pLuaVM, -1 ); - return true; + return pLuaArgument.GetArray(); } return false; @@ -7270,7 +7340,7 @@ bool CLuaFunctionDefinitions::GetAccountSerial( lua_State* pLuaVM, void* pAccoun return false; } -bool CLuaFunctionDefinitions::GetAccountsBySerial( lua_State* pLuaVM, const string& strSerial, std::vector& outAccounts ) +bool CLuaFunctionDefinitions::GetAccountsBySerial( lua_State* pLuaVM, const string& strSerial, vector& outAccounts ) { return false; } @@ -7783,6 +7853,60 @@ bool CLuaFunctionDefinitions::ResetMapInfo( lua_State* pLuaVM, void* pElement ) // Resource funcs +void* CLuaFunctionDefinitions::CreateResource( lua_State* pLuaVM, const char* szResourceName, const char* szOrganizationalDir ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushString( szResourceName ); + pLuaArguments.PushString( szOrganizationalDir ); + + if( pLuaArguments.Call( pLuaVM, "createResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetLightUserData(); + } + + return NULL; +} + +void* CLuaFunctionDefinitions::CopyResource( lua_State* pLuaVM, void* pResource, const char* szNewResourceName, const char* szOrganizationalDir ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szNewResourceName ); + pLuaArguments.PushString( szOrganizationalDir ); + + if( pLuaArguments.Call( pLuaVM, "copyResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetLightUserData(); + } + + return NULL; +} + +void* CLuaFunctionDefinitions::GetResourceRootElement( lua_State* pLuaVM, void* pResource ) +{ + CLuaArguments pLuaArguments; + + if( pResource ) + { + pLuaArguments.PushUserData( pResource ); + } + + if( pLuaArguments.Call( pLuaVM, "getResourceRootElement", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetLightUserData(); + } + + return NULL; +} + void* CLuaFunctionDefinitions::GetResourceMapRootElement( lua_State* pLuaVM, const char* szMap ) { CLuaArguments pLuaArguments; @@ -7799,8 +7923,22 @@ void* CLuaFunctionDefinitions::GetResourceMapRootElement( lua_State* pLuaVM, con return false; } -//CXMLNode* CLuaFunctionDefinitions::AddResourceMap( lua_State* pLuaVM, const string& strFilePath, const std::string& strMapName, int iDimension ) -//CXMLNode* CLuaFunctionDefinitions::AddResourceConfig( lua_State* pLuaVM, const string& strFilePath, const std::string& strConfigName, int iType ) +void* CLuaFunctionDefinitions::GetResourceDynamicElementRoot( lua_State* pLuaVM, void* pResource ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "getResourceDynamicElementRoot", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetLightUserData(); + } + + return NULL; +} + bool CLuaFunctionDefinitions::RemoveResourceFile( lua_State* pLuaVM, const char* szFilename ) { CLuaArguments pLuaArguments; @@ -7817,8 +7955,404 @@ bool CLuaFunctionDefinitions::RemoveResourceFile( lua_State* pLuaVM, const char* return false; } +CLuaArguments* CLuaFunctionDefinitions::GetResourceExportedFunctions( lua_State* pLuaVM, void* pResource ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "getResourceExportedFunctions", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetArray(); + } + + return NULL; +} + +void* CLuaFunctionDefinitions::GetResourceFromName( lua_State* pLuaVM, const char* szResourceName ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushString( szResourceName ); + + if( pLuaArguments.Call( pLuaVM, "getResourceFromName", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetLightUserData(); + } + + return NULL; +} + +bool CLuaFunctionDefinitions::GetResourceInfo( lua_State* pLuaVM, void* pResource, const char* szAttribute, string& strInfo ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szAttribute ); + + if( pLuaArguments.Call( pLuaVM, "getResourceInfo", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + strInfo = string( pLuaArgument.GetString() ); + + return true; + } + + return false; +} + +bool CLuaFunctionDefinitions::GetResourceLastStartTime( lua_State* pLuaVM, void* pResource, unsigned int& uiTime ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "getResourceLastStartTime", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + uiTime = pLuaArgument.GetNumber< unsigned int >(); + + return true; + } + + return false; +} + +bool CLuaFunctionDefinitions::GetResourceLoadFailureReason( lua_State* pLuaVM, void* pResource, string& strReason ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "getResourceLoadFailureReason", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + strReason = string( pLuaArgument.GetString() ); + + return true; + } + + return false; +} + +bool CLuaFunctionDefinitions::GetResourceLoadTime( lua_State* pLuaVM, void* pResource, unsigned int& uiTime ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "getResourceLoadTime", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + uiTime = pLuaArgument.GetNumber< unsigned int >(); + + return true; + } + + return false; +} + +bool CLuaFunctionDefinitions::GetResourceName( lua_State* pLuaVM, void* pResource, string& strName ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "getResourceName", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + strName = string( pLuaArgument.GetString() ); + + return true; + } + + return false; +} + +CLuaArguments* CLuaFunctionDefinitions::GetResources( lua_State* pLuaVM ) +{ + CLuaArguments pLuaArguments; + + if( pLuaArguments.Call( pLuaVM, "getResources", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetArray(); + } + + return NULL; +} + +bool CLuaFunctionDefinitions::GetResourceState( lua_State* pLuaVM, void* pResource, string& strState ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "getResourceState", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + strState = string( pLuaArgument.GetString() ); + + return false; + } + + return false; +} + +void* CLuaFunctionDefinitions::GetThisResource( lua_State* pLuaVM ) +{ + CLuaArguments pLuaArguments; + + if( pLuaArguments.Call( pLuaVM, "getThisResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetLightUserData(); + } + + return false; +} + +bool CLuaFunctionDefinitions::RefreshResources( lua_State* pLuaVM, bool refreshAll ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushBoolean( refreshAll ); + + if( pLuaArguments.Call( pLuaVM, "refreshResources", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::RemoveResourceDefaultSetting( lua_State* pLuaVM, void* pResource, const char* szSettingName ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szSettingName ); + + if( pLuaArguments.Call( pLuaVM, "removeResourceDefaultSetting", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::StartResource( lua_State* pLuaVM, void* pResource, bool persistent, bool startIncludedResources, bool loadServerConfigs, bool loadMaps, bool loadServerScripts, bool loadHTML, bool loadClientConfigs, bool loadClientScripts, bool loadFiles ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushBoolean( persistent ); + pLuaArguments.PushBoolean( startIncludedResources ); + pLuaArguments.PushBoolean( loadServerConfigs ); + pLuaArguments.PushBoolean( loadMaps ); + pLuaArguments.PushBoolean( loadServerScripts ); + pLuaArguments.PushBoolean( loadHTML ); + pLuaArguments.PushBoolean( loadClientConfigs ); + pLuaArguments.PushBoolean( loadClientScripts ); + pLuaArguments.PushBoolean( loadFiles ); + + if( pLuaArguments.Call( pLuaVM, "startResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::RestartResource( lua_State* pLuaVM, void* pResource ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "restartResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::StopResource( lua_State* pLuaVM, void* pResource ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + + if( pLuaArguments.Call( pLuaVM, "stopResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::SetResourceDefaultSetting( lua_State* pLuaVM, void* pResource, const char* szSettingName, const char* szSettingValue ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szSettingName ); + pLuaArguments.PushString( szSettingValue ); + + if( pLuaArguments.Call( pLuaVM, "setResourceDefaultSetting", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::SetResourceDefaultSetting( lua_State* pLuaVM, void* pResource, const char* szSettingName, int iSettingValue ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szSettingName ); + pLuaArguments.PushNumber( iSettingValue ); + + if( pLuaArguments.Call( pLuaVM, "setResourceDefaultSetting", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::SetResourceDefaultSetting( lua_State* pLuaVM, void* pResource, const char* szSettingName, float fSettingValue ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szSettingName ); + pLuaArguments.PushNumber( fSettingValue ); + + if( pLuaArguments.Call( pLuaVM, "setResourceDefaultSetting", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::SetResourceInfo( lua_State* pLuaVM, void* pResource, const char* szAttribute, const char* szValue ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szAttribute ); + pLuaArguments.PushString( szValue ); + + if( pLuaArguments.Call( pLuaVM, "setResourceInfo", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::RenameResource( lua_State* pLuaVM, const char* szResourceName, const char* szNewResourceName, const char* szOrganizationalPath ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushString( szResourceName ); + pLuaArguments.PushString( szNewResourceName ); + pLuaArguments.PushString( szOrganizationalPath ); + + if( pLuaArguments.Call( pLuaVM, "renameResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::DeleteResource( lua_State* pLuaVM, const char* szResourceName ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushString( szResourceName ); + + if( pLuaArguments.Call( pLuaVM, "deleteResource", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + +bool CLuaFunctionDefinitions::UpdateResourceACLRequest( lua_State* pLuaVM, void* pResource, const char* szRightName, bool bAccess, const char* szByWho ) +{ + CLuaArguments pLuaArguments; + + pLuaArguments.PushUserData( pResource ); + pLuaArguments.PushString( szRightName ); + pLuaArguments.PushBoolean( bAccess ); + pLuaArguments.PushString( szByWho ); + + if( pLuaArguments.Call( pLuaVM, "updateResourceACLRequest", 1 ) ) + { + CLuaArgument pLuaArgument( pLuaVM, -1 ); + + return pLuaArgument.GetBoolean(); + } + + return false; +} + // Version funcs +LuaTable CLuaFunctionDefinitions::GetVersion( lua_State* pLuaVM ) +{ + LuaTable pLuaTable; + + if( CLuaArguments().Call( pLuaVM, "getVersion", 1 ) ) + { + pLuaTable = CLuaArgument( pLuaVM, -1 ).GetTable(); + } + + return pLuaTable; +} + // Camera get functions bool CLuaFunctionDefinitions::GetCameraMatrix( lua_State* pLuaVM, void* pPlayer, Vector3& vecPosition, Vector3& vecLookAt, float& fRoll, float& fFOV ) { diff --git a/mta-mono/src/lua/CLuaFunctionDefinitions.h b/mta-mono/src/lua/CLuaFunctionDefinitions.h index aa2aede..3aea253 100644 --- a/mta-mono/src/lua/CLuaFunctionDefinitions.h +++ b/mta-mono/src/lua/CLuaFunctionDefinitions.h @@ -18,6 +18,8 @@ class CLuaFunctionDefinitions; #include "../Common.h" #include "../extra/CLuaArguments.h" +extern ILuaModuleManager10 *g_pModuleManager; + class CLuaFunctionDefinitions { public: @@ -59,6 +61,7 @@ public: static void* CloneElement ( lua_State* pLuaVM, void* pUserData, const Vector3& vecPosition, bool bCloneElement ); // Element get funcs + static CLuaArguments* GetElementsByType ( lua_State* pLuaVM, const char* szTypeName, void* pUserData = NULL ); static bool IsElement ( lua_State* pLuaVM, void* pUserData ); static string GetElementType ( lua_State* pLuaVM, void* pUserData ); static void* GetElementByID ( lua_State* pLuaVM, const char* szID, unsigned int uiIndex ); @@ -125,8 +128,8 @@ public: static bool IsPlayerMuted ( lua_State* pLuaVM, void* pUserData, bool& bMuted ); static void* GetPlayerTeam ( lua_State* pLuaVM, void* pUserData ); static bool GetPlayerWantedLevel ( lua_State* pLuaVM, void* pUserData, unsigned int& uiWantedLevel ); - static bool GetAlivePlayers ( lua_State* pLuaVM ); - static bool GetDeadPlayers ( lua_State* pLuaVM ); + static CLuaArguments* GetAlivePlayers ( lua_State* pLuaVM ); + static CLuaArguments* GetDeadPlayers ( lua_State* pLuaVM ); static bool GetPlayerIdleTime ( lua_State* pLuaVM, void* pUserData, unsigned int& uiIdleTime ); static bool IsPlayerMapForced ( lua_State* pLuaVM, void* pUserData, bool& bForced ); static bool GetPlayerNametagText ( lua_State* pLuaVM, void* pUserData, string& strOutText ); @@ -139,7 +142,7 @@ public: static bool GetPlayerIP ( lua_State* pLuaVM, void* pUserData, string& strOutIP ); static void* GetPlayerAccount ( lua_State* pLuaVM, void* pUserData ); static string GetPlayerVersion ( lua_State* pLuaVM, void* pUserData ); - static int GetPlayerACInfo ( lua_State* pLuaVM, void* pUserData ); + static LuaTable GetPlayerACInfo ( lua_State* pLuaVM, void* pUserData ); // Player set functions static bool SetPlayerMoney ( lua_State* pLuaVM, void* pUserData, int iAmount, bool bInstant = false ); @@ -154,7 +157,7 @@ public: static bool SetPlayerNametagShowing ( lua_State* pLuaVM, void* pUserData, bool bShowing ); static bool SetPlayerMuted ( lua_State* pLuaVM, void* pUserData, bool bMuted ); static bool SetPlayerBlurLevel ( lua_State* pLuaVM, void* pUserData, int iLevel ); - static bool RedirectPlayer ( lua_State* pLuaVM, void* pUserData, string sServerIP, int iServerPort, string sServerPassword ); + static bool RedirectPlayer ( lua_State* pLuaVM, void* pUserData, const char* szServerIP, int iServerPort, const char* szServerPassword ); static bool SetPlayerName ( lua_State* pLuaVM, void* pUserData, string sName ); static bool DetonateSatchels ( lua_State* pLuaVM, void* pUserData ); static bool TakePlayerScreenShot ( lua_State* pLuaVM, void* pUserData, int iWidth, int iHeight, string sTag = "", int iQuality = 30, int iMaxBandwith = 5000 ); @@ -183,8 +186,8 @@ public: static void* GetPedOccupiedVehicle ( lua_State* pLuaVM, void* pUserData ); static bool GetPedOccupiedVehicleSeat ( lua_State* pLuaVM, void* pUserData, unsigned int& uiSeat ); static bool IsPedInVehicle ( lua_State* pLuaVM, void* pUserData, bool & bIsInVehicle ); -// static bool GetWeaponProperty ( lua_State* pLuaVM, void* pUserData ); -// static bool GetOriginalWeaponProperty ( lua_State* pLuaVM, void* pUserData ); + static bool GetWeaponProperty ( lua_State* pLuaVM, unsigned char ucWeaponID, const char* szWeaponSkill, const char* szProperty, short& uData ); + static bool GetOriginalWeaponProperty ( lua_State* pLuaVM, unsigned char ucWeaponID, const char *szWeaponSkill, const char* szProperty, short& uData ); // Ped set functions static bool SetPedArmor ( lua_State* pLuaVM, void* pUserData, float fArmor ); @@ -208,7 +211,7 @@ public: static bool SetPedHeadless ( lua_State* pLuaVM, void* pUserData, bool bIsHeadless ); static bool SetPedFrozen ( lua_State* pLuaVM, void* pUserData, bool bIsFrozen ); static bool ReloadPedWeapon ( lua_State* pLuaVM, void* pUserData ); -// static bool SetWeaponProperty ( lua_State* pLuaVM, void* pUserData ); + static bool SetWeaponProperty ( lua_State* pLuaVM, unsigned char ucWeaponID, const char *szWeaponSkill, const char* szProperty, short uData ); // Weapon give/take functions // static int GiveWeapon ( lua_State* pLuaVM ); @@ -228,7 +231,7 @@ public: static bool GetVehicleLandingGearDown ( lua_State* pLuaVM, void* pUserData, bool& bGearDown ); static bool GetVehicleMaxPassengers ( lua_State* pLuaVM, void* pUserData, unsigned char& ucMaxPassengers ); static bool GetVehicleName ( lua_State* pLuaVM, void* pUserData, string& strOutName ); - static bool GetVehicleNameFromModel ( lua_State* pLuaVM, void* pUserData, unsigned short usModel, string& strOutName ); + static bool GetVehicleNameFromModel ( lua_State* pLuaVM, unsigned short usModel, string& strOutName ); static void* GetVehicleOccupant ( lua_State* pLuaVM, void* pUserData, unsigned int uiSeat ); static CLuaArguments* GetVehicleOccupants ( lua_State* pLuaVM, void* pUserData ); static void* GetVehicleController ( lua_State* pLuaVM, void* pUserData ); @@ -236,7 +239,7 @@ public: static bool GetVehicleTurnVelocity ( lua_State* pLuaVM, void* pUserData, Vector3& vecTurnVelocity ); static bool GetVehicleTurretPosition ( lua_State* pLuaVM, void* pUserData, Vector2& vecPosition ); static bool IsVehicleLocked ( lua_State* pLuaVM, void* pUserData, bool& bLocked ); - static CLuaArguments* GetVehiclesOfType ( lua_State* pLuaVM, void* pUserData ); + static CLuaArguments* GetVehiclesOfType ( lua_State* pLuaVM, unsigned int uiModel ); static bool GetVehicleUpgradeOnSlot ( lua_State* pLuaVM, void* pUserData, unsigned char ucSlot, unsigned short& usUpgrade ); static CLuaArguments* GetVehicleUpgrades ( lua_State* pLuaVM, void* pUserData ); static bool GetVehicleUpgradeSlotName ( lua_State* pLuaVM, unsigned char ucSlot, string& strOutName ); @@ -398,7 +401,7 @@ public: static void* CreateColPolygon ( lua_State* pLuaVM, const vector< Vector2 >& vecPointList ); static void* CreateColTube ( lua_State* pLuaVM, const Vector3& vecPosition, float fRadius, float fHeight ); - // Explosion funcs + // Explosion funcs static bool CreateExplosion ( lua_State* pLuaVM, const Vector3& vecPosition, unsigned char ucType, void* pCreator = NULL ); // Fire funcs @@ -442,7 +445,7 @@ public: static bool SetTeamFriendlyFire ( lua_State* pLuaVM, void* pTeam, bool bFriendlyFire ); // Water funcs - static void* CreateWater ( lua_State* pLuaVM, Vector3* pV1, Vector3* pV2, Vector3* pV3, Vector3* pV4 ); + static void* CreateWater ( lua_State* pLuaVM, Vector3* pV1, Vector3* pV2, Vector3* pV3, Vector3* pV4, bool bShallow ); static bool SetElementWaterLevel ( lua_State* pLuaVM, void* pWater, float fLevel ); static bool SetAllElementWaterLevel ( lua_State* pLuaVM, float fLevel ); static bool SetWorldWaterLevel ( lua_State* pLuaVM, float fLevel, bool bIncludeWorldNonSeaLevel ); @@ -542,7 +545,7 @@ public: // Account get funcs static void* GetAccount ( lua_State* pLuaVM, const char* szName, const char* szPassword ); - static bool GetAccounts ( lua_State* pLuaVM ); + static CLuaArguments* GetAccounts ( lua_State* pLuaVM ); static void* GetAccountPlayer ( lua_State* pLuaVM, void* pAccount ); static bool IsGuestAccount ( lua_State* pLuaVM, void* pAccount, bool& bGuest ); static CLuaArgument* GetAccountData ( lua_State* pLuaVM, void* pAccount, const char* szKey ); @@ -598,20 +601,43 @@ public: static bool ResetMapInfo ( lua_State* pLuaVM, void* pElement ); // Resource funcs + static void* CreateResource ( lua_State* pLuaVM, const char* szResourceName, const char* szOrganizationalDir ); + static void* CopyResource ( lua_State* pLuaVM, void* pResource, const char* szNewResourceName, const char* szOrganizationalDir ); + static void* GetResourceRootElement ( lua_State* pLuaVM, void* pResource = NULL ); static void* GetResourceMapRootElement ( lua_State* pLuaVM, const char* szMap ); + static void* GetResourceDynamicElementRoot ( lua_State* pLuaVM, void* pResource ); // static CXMLNode* AddResourceMap ( lua_State* pLuaVM, const string& strFilePath, const std::string& strMapName, int iDimension ); // static CXMLNode* AddResourceConfig ( lua_State* pLuaVM, const string& strFilePath, const std::string& strConfigName, int iType ); static bool RemoveResourceFile ( lua_State* pLuaVM, const char* szFilename ); +// static CXMLNode AddResourceConfig ( lua_State* pLuaVM, const char* szFilePath, const char* szFileType = "server" ); +// static CXMLNode AddResourceMap ( lua_State* pLuaVM, const char* szFilePath, unsigned int uiDimension = 0 ); +// static CXMLNode GetResourceConfig ( lua_State* pLuaVM, const char* szFilePath ); + static CLuaArguments* GetResourceExportedFunctions ( lua_State* pLuaVM, void* pResource ); + static void* GetResourceFromName ( lua_State* pLuaVM, const char* szResourceName ); + static bool GetResourceInfo ( lua_State* pLuaVM, void* pResource, const char* szAttribute, string& strInfo ); + static bool GetResourceLastStartTime ( lua_State* pLuaVM, void* pResource, unsigned int& uiTime ); + static bool GetResourceLoadFailureReason ( lua_State* pLuaVM, void* pResource, string& strReason ); + static bool GetResourceLoadTime ( lua_State* pLuaVM, void* pResource, unsigned int& uiTime ); + static bool GetResourceName ( lua_State* pLuaVM, void* pResource, string& strName ); + static CLuaArguments* GetResources ( lua_State* pLuaVM ); + static bool GetResourceState ( lua_State* pLuaVM, void* pResource, string& strState ); + static void* GetThisResource ( lua_State* pLuaVM ); + static bool RefreshResources ( lua_State* pLuaVM, bool refreshAll = false ); + static bool RemoveResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName ); + static bool StartResource ( lua_State* pLuaVM, void* pResource, bool persistent = false, bool startIncludedResources = true, bool loadServerConfigs = true, bool loadMaps = true, bool loadServerScripts = true, bool loadHTML = true, bool loadClientConfigs = true, bool loadClientScripts = true, bool loadFiles = true ); + static bool RestartResource ( lua_State* pLuaVM, void* pResource ); + static bool StopResource ( lua_State* pLuaVM, void* pResource ); + static bool SetResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName, const char* szSettingValue ); + static bool SetResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName, int iSettingValue ); + static bool SetResourceDefaultSetting ( lua_State* pLuaVM, void* pResource, const char* szSettingName, float fSettingValue ); + static bool SetResourceInfo ( lua_State* pLuaVM, void* pResource, const char* szAttribute, const char* szValue ); + static bool RenameResource ( lua_State* pLuaVM, const char* szResourceName, const char* szNewResourceName, const char* szOrganizationalPath ); + static bool DeleteResource ( lua_State* pLuaVM, const char* szResourceName ); +// static CLuaArguments* GetResourceACLRequests ( lua_State* pLuaVM, void* pResource ); + static bool UpdateResourceACLRequest ( lua_State* pLuaVM, void* pResource, const char* szRightName, bool bAccess, const char* szByWho = NULL ); // Version funcs -// static unsigned long GetVersion ( lua_State* pLuaVM ); -// static const char* GetVersionString ( lua_State* pLuaVM ); -// static const char* GetVersionName ( lua_State* pLuaVM ); -// static string GetVersionBuildType ( lua_State* pLuaVM ); -// static unsigned long GetNetcodeVersion ( lua_State* pLuaVM ); -// static const char* GetOperatingSystemName ( lua_State* pLuaVM ); -// static const char* GetVersionBuildTag ( lua_State* pLuaVM ); -// static string GetVersionSortable ( lua_State* pLuaVM ); + static LuaTable GetVersion ( lua_State* pLuaVM ); // Camera get functions static bool GetCameraMatrix ( lua_State* pLuaVM, void* pPlayer, Vector3& vecPosition, Vector3& vecLookAt, float& fRoll, float& fFOV ); @@ -619,16 +645,16 @@ public: static bool GetCameraInterior ( lua_State* pLuaVM, void* pPlayer, unsigned char & ucInterior ); // Camera set functions - static bool SetCameraMatrix ( lua_State* pLuaVM, void* pElement, const Vector3& vecPosition, Vector3* pvecLookAt, float fRoll, float fFOV ); - static bool SetCameraTarget ( lua_State* pLuaVM, void* pElement, void* pTarget ); - static bool SetCameraInterior ( lua_State* pLuaVM, void* pElement, unsigned char ucInterior ); - static bool FadeCamera ( lua_State* pLuaVM, void* pElement, bool bFadeIn, float fFadeTime, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue ); + static bool SetCameraMatrix ( lua_State* pLuaVM, void* pPlayer, const Vector3& vecPosition, Vector3* pvecLookAt, float fRoll, float fFOV ); + static bool SetCameraTarget ( lua_State* pLuaVM, void* pPlayer, void* pTarget ); + static bool SetCameraInterior ( lua_State* pLuaVM, void* pPlayer, unsigned char ucInterior ); + static bool FadeCamera ( lua_State* pLuaVM, void* pPlayer, bool bFadeIn, float fFadeTime, unsigned char ucRed, unsigned char ucGreen, unsigned char ucBlue ); // Weapon give/take functions - static bool GiveWeapon ( lua_State* pLuaVM, void* pElement, unsigned char ucWeaponID, unsigned short usAmmo, bool bSetAsCurrent = false ); - static bool TakeWeapon ( lua_State* pLuaVM, void* pElement, unsigned char ucWeaponID, unsigned short usAmmo = 9999 ); - static bool TakeAllWeapons ( lua_State* pLuaVM, void* pElement ); - static bool SetWeaponAmmo ( lua_State* pLuaVM, void* pElement, unsigned char ucWeaponID, unsigned short usAmmo, unsigned short usAmmoInClip ); + static bool GiveWeapon ( lua_State* pLuaVM, void* pPed, unsigned char ucWeaponID, unsigned short usAmmo, bool bSetAsCurrent = false ); + static bool TakeWeapon ( lua_State* pLuaVM, void* pPed, unsigned char ucWeaponID, unsigned short usAmmo = 9999 ); + static bool TakeAllWeapons ( lua_State* pLuaVM, void* pPed ); + static bool SetWeaponAmmo ( lua_State* pLuaVM, void* pPed, unsigned char ucWeaponID, unsigned short usAmmo, unsigned short usAmmoInClip ); }; #endif \ No newline at end of file