public void PlayAnimation(string animDict, string animName, float blendInSpeed, float blendOutSpeed, int duration, AnimationFlags flags, float playbackRate)
{
InputArgument[] arguments = new InputArgument[] { animDict };
Function.Call(Hash.REQUEST_ANIM_DICT, arguments);
DateTime time = DateTime.UtcNow + new TimeSpan(0, 0, 0, 0, 0x3e8);
while (true)
{
InputArgument[] argumentArray2 = new InputArgument[] { animDict };
if (Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, argumentArray2))
{
InputArgument[] argumentArray3 = new InputArgument[11];
argumentArray3[0] = this._ped.Handle;
argumentArray3[1] = animDict;
argumentArray3[2] = animName;
argumentArray3[3] = blendInSpeed;
argumentArray3[4] = blendOutSpeed;
argumentArray3[5] = duration;
argumentArray3[6] = flags;
argumentArray3[7] = playbackRate;
argumentArray3[8] = 0;
argumentArray3[9] = 0;
argumentArray3[10] = 0;
Function.Call(Hash.TASK_PLAY_ANIM, argumentArray3);
return;
}
Script.Yield();
if (DateTime.UtcNow >= time)
{
return;
}
}
}
private void ForceCarryAnimation()
{
/* A somewhat fix to the force play door opening animation */
AnimationFlags flags = AnimationFlags.UpperBodyOnly | AnimationFlags.Loop | AnimationFlags.AllowRotation | AnimationFlags.StayInEndFrame | (AnimationFlags)2;
Game.PlayerPed.Task.PlayAnimation("anim@heists@box_carry@", "walk", 18.0f, -1, flags);
}
public Animation(float timePerFrame, int[] indices, AnimationFlags flags)
: this() {
this.TimePerFrame = timePerFrame;
this.Flags = flags;
this.Indices.AddRange(indices);
}
/// <summary>
/// Zwraca odpowiednią flagę animacji.
/// </summary>
/// <param name="animData"></param>
/// <returns></returns>
public static int BuildAnimationFlags(Animation animData)
{
AnimationFlags output = AnimationFlags.None;
if (animData.Loop)
{
output = output | AnimationFlags.Loop;
}
if (animData.StopOnLastFrame)
{
output = output | AnimationFlags.StopOnLastFrame;
}
if (animData.OnlyAnimateUpperBody)
{
output = output | AnimationFlags.OnlyAnimateUpperBody;
}
if (animData.AllowPlayerControl)
{
output = output | AnimationFlags.AllowPlayerControl;
}
if (animData.Cancellable)
{
output = output | AnimationFlags.Cancellable;
}
return((int)output);
}
public Animations(string animDict, string animName, float blendSpeed = 3f, AnimationFlags flag = 0)
{
AnimationDictionary = animDict;
AnimationName = animName;
BlendInSpeed = blendSpeed;
AnimationFlag = flag;
}
internal void RefreshMenu()
{
AnimationFlags flags = AnimationFlags.Activate | AnimationFlags.Slide;
bool isRTL = CultureInfo.CurrentUICulture.TextInfo.IsRightToLeft;
if (isRTL)
{
OpenFlags = flags | AnimationFlags.Right;
}
else
{
OpenFlags = flags | AnimationFlags.Left;
}
//---
flags = AnimationFlags.Hide | AnimationFlags.Slide;
if (isRTL)
{
CloseFlags = flags | AnimationFlags.Left;
}
else
{
CloseFlags = flags | AnimationFlags.Right;
}
}
public AnimationInstance(ModelInstance modelInstance, W3DAnimation animation,
AnimationMode mode, AnimationFlags flags)
{
_animation = animation;
_mode = mode;
_flags = flags;
_boneInstances = modelInstance.ModelBoneInstances;
_keyframeIndices = new int[animation.Clips.Length];
if (_flags.HasFlag(AnimationFlags.StartFrameFirst) ||
_flags == AnimationFlags.None)
{
_currentTimeValue = TimeSpan.Zero;
}
else if (_flags.HasFlag(AnimationFlags.StartFrameLast))
{
_currentTimeValue = _animation.Duration;
}
else
{
//TODO: implement other flags
//throw new NotImplementedException();
}
}
private void PopulateAnimations(SpriteDataContent Sprite, SpriteHeader Header, IEnumerable <string> AnimationRows)
{
List <SpriteAnimationDataContent> Animations = new List <SpriteAnimationDataContent>();
foreach (var AnimationRow in AnimationRows)
{
var Reader = CreateReader(AnimationRow);
string AnimationName = Reader.Read();
float Duration = float.Parse(Reader.Read());
var Frames = ParseFrames(Header, Reader).ToArray(); // Array to process entirely so we do Reader.Read at right times.
AnimationFlags Flags = AnimationFlags.None;
while (Reader.HasMore())
{
string NextFlag = Reader.Read();
AnimationFlags Flag = (AnimationFlags)Enum.Parse(typeof(AnimationFlags), NextFlag);
Flags |= Flag;
}
var FrameNames = Frames.Select(IndexToName);
Dictionary <string, TimeSpan> FrameDurations = new Dictionary <string, TimeSpan>();
foreach (var FrameName in FrameNames)
{
FrameDurations.Add(FrameName, TimeSpan.FromMilliseconds(Duration));
}
SpriteAnimationDataContent Animation = new SpriteAnimationDataContent()
{
FrameDurations = FrameDurations,
IsDefault = (Flags & AnimationFlags.Default) != 0,
IsLooped = (Flags & AnimationFlags.Looped) != 0,
Name = AnimationName
};
Animations.Add(Animation);
}
Sprite.Animations = Animations;
}
public AnimationFlags Load(string path, string name)
{
var cacheKey = $"{path}/{name}";
if (_cache.ContainsKey(cacheKey))
{
return(_cache[cacheKey]);
}
foreach (var config in _settings)
{
var flags = config.Load(path, name);
if (flags != null)
{
_cache[cacheKey] = flags;
return(flags);
}
}
lock (locker)
{
var flags = new AnimationFlags();
_cache[cacheKey] = flags;
_dumpSetting.Save(path, name, flags);
return(flags);
}
}
public Animations(string scenarioName, string animationName, float blendSpeed = 3f, AnimationFlags flag = AnimationFlags.None)
{
ScenarioName = scenarioName;
FirstAnimation = animationName;
BlendInSpeed = blendSpeed;
AnimationFlag = flag;
}
internal static void AnimateWindow(Control control, int time, AnimationFlags flags)
{
try {
SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
sp.Demand();
AnimateWindow(new HandleRef(control, control.Handle), time, flags);
} catch (SecurityException) { }
}
public Animation(float timePerFrame, int[] indices, AnimationFlags flags)
: this()
{
this.TimePerFrame = timePerFrame;
this.Flags = flags;
this.Indices.AddRange(indices);
}
public Animation(string name, float framesPerSecond, AnimationFlags animationFlag = AnimationFlags.None,
SpriteEffects flipEffect = SpriteEffects.None, float rotation = 0f)
: this(name, framesPerSecond)
{
FlipEffect = flipEffect;
AnimationFlag = animationFlag;
Rotation = rotation;
}
public Animation(EMSAnimation type, string dict, string name, int time, AnimationFlags flags)
{
AnimationType = type;
ShortName = type.ToString();
Dictionary = dict;
AnimationName = name;
AnimationTime = time;
Flags = flags;
}
protected override void OnVisibleChanged(EventArgs e)
{
base.OnVisibleChanged(e);
if ((Visible && PopupAnimation == PopupAnimations.None) || (!Visible && CloseAnimation == PopupAnimations.None))
{
return;
}
AnimationFlags flags = Visible ? AnimationFlags.Roll : AnimationFlags.Hide;
PopupAnimations _flags = Visible ? PopupAnimation : CloseAnimation;
if (_flags == PopupAnimations.SystemDefault)
{
if (SystemInformation.IsMenuAnimationEnabled)
{
if (SystemInformation.IsMenuFadeEnabled)
{
_flags = PopupAnimations.Blend;
}
else
{
_flags = PopupAnimations.Slide | (Visible ? PopupAnimations.TopToBottom : PopupAnimations.BottomToTop);
}
}
else
{
_flags = PopupAnimations.None;
}
}
if ((_flags & (PopupAnimations.Blend | PopupAnimations.Center | PopupAnimations.Roll | PopupAnimations.Slide)) == PopupAnimations.None)
{
return;
}
if (_resizableTop) // popup is “inverted”, so the animation must be
{
if ((_flags & PopupAnimations.BottomToTop) != PopupAnimations.None)
{
_flags = (_flags & ~PopupAnimations.BottomToTop) | PopupAnimations.TopToBottom;
}
else if ((_flags & PopupAnimations.TopToBottom) != PopupAnimations.None)
{
_flags = (_flags & ~PopupAnimations.TopToBottom) | PopupAnimations.BottomToTop;
}
}
if (_resizableLeft) // popup is “inverted”, so the animation must be
{
if ((_flags & PopupAnimations.RightToLeft) != PopupAnimations.None)
{
_flags = (_flags & ~PopupAnimations.RightToLeft) | PopupAnimations.LeftToRight;
}
else if ((_flags & PopupAnimations.LeftToRight) != PopupAnimations.None)
{
_flags = (_flags & ~PopupAnimations.LeftToRight) | PopupAnimations.RightToLeft;
}
}
flags |= (AnimationFlags.Mask & (AnimationFlags)(int)_flags);
NativeUtility.AnimateWindow(this, AnimationDuration, flags);
}
public AnimationInstance(ModelInstance modelInstance, W3DAnimation animation,
AnimationMode mode, AnimationFlags flags, GameObject gameObject)
{
_gameObject = gameObject;
_animation = animation;
_mode = mode;
_flags = flags;
_boneInstances = modelInstance.ModelBoneInstances;
_keyframeIndices = new int[animation.Clips.Length];
}
public ISerializable Deserialize(BinaryInput input)
{
Name = input.ReadString();
TimePerFrame = input.ReadSingle();
Frames = input.ReadList<KeyFrame>();
AnimationFlag = (AnimationFlags) input.ReadByte();
FlipEffect = (SpriteEffects) input.ReadByte();
Rotation = input.ReadSingle();
return this;
}
public FoodInventoryItem(int amount, int maxAmount, string id, string description, string animationDict, string animationName, AnimationFlags animationFlags, int animationDuration, FoodType foodType, float restorationAmount)
: base(amount, maxAmount, id, description)
{
AnimationDict = animationDict;
AnimationName = animationName;
AnimationFlags = animationFlags;
AnimationDuration = animationDuration;
FoodType = foodType;
RestorationAmount = restorationAmount;
}
internal static void AnimateWindow(Control control, int time, AnimationFlags flags)
{
try
{
SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
sp.Demand();
AnimateWindow(new HandleRef(control, control.Handle), time, flags);
}
catch (SecurityException) { }
}
public void PlayAnimation(string dictionary, string name, float speed = 8, AnimationFlags flags = (AnimationFlags)0)
{
Contract.NotEmpty(dictionary, nameof(dictionary));
Contract.NotEmpty(name, nameof(name));
CheckExistence();
using (var converter = new StringConverter())
{
Rage.Player.Player_PlayAnimation(NativePointer, converter.StringToPointer(dictionary), converter.StringToPointer(name), speed, (int)flags);
}
}
/// <summary>
/// Construct a new <see cref="AnimationInstance"/>
/// </summary>
/// <param name="modelBoneInstances">The bone instances to use, which will be modified as the animation plays</param>
/// <param name="animation">The animation to apply to the bones</param>
/// <param name="mode">The animation mode</param>
/// <param name="flags">Additional animation flags</param>
/// <param name="gameObject"></param>
/// <param name="random">Random number generator used when combined with <see cref="AnimationFlags.RandomStart"/></param>
public AnimationInstance(ModelBoneInstance[] modelBoneInstances, W3DAnimation animation,
AnimationMode mode, AnimationFlags flags, GameObject gameObject, Random random)
{
_animation = animation;
_mode = mode;
_flags = flags;
_boneInstances = modelBoneInstances;
_keyframeIndices = new int[animation.Clips.Length];
_gameObject = gameObject;
_random = random;
}
internal static void AnimateWindow(Control control, int time, AnimationFlags flags)
{
Contract.Requires<ArgumentNullException>(control != null);
try
{
SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
sp.Demand();
AnimateWindow(new HandleRef(control, control.Handle), time, flags);
}
catch (SecurityException) { }
}
private async Task GetPlayerPropsForDelivery(DeliveryType aDeliveryType)
{
if (aDeliveryType == DeliveryType.Scooter)
{
CitizenFX.Core.Debug.WriteLine(" :: Getting Player props for delivery.");
if (aDeliveryType == DeliveryType.Scooter)
{
if (!HasModelLoaded((uint)GetHashKey("prop_paper_bag_01")))
{
RequestModel((uint)GetHashKey("prop_paper_bag_01"));
while (!HasModelLoaded((uint)GetHashKey("prop_paper_bag_01")))
{
await Delay(0);
}
}
Prop prop_ent = null;
prop_ent = await World.CreateProp("prop_paper_bag_01", Game.PlayerPed.Position, Vector3.Zero, true, false);
AttachEntityToEntity(prop_ent.Handle, Game.PlayerPed.Handle, GetPedBoneIndex(Game.PlayerPed.Handle, 28422), 0.25f, 0.0f, 0.06f, 65.0f, -130.0f, -65.0f, true, true, false, true, 0, true);
m_player_attatchments.Add(prop_ent);
}
}
if (aDeliveryType == DeliveryType.Van)
{
AnimationFlags flags = AnimationFlags.UpperBodyOnly | AnimationFlags.Loop | AnimationFlags.AllowRotation | AnimationFlags.StayInEndFrame | (AnimationFlags)2;
Game.PlayerPed.Task.PlayAnimation("anim@heists@box_carry@", "walk", 18.0f, -1, flags);
Prop prop_ent = null;
var rs = GetRandomFromRange(0, DeliveryData.VAN_GOODS_PROP_NAMES.Count - 1);
prop_ent = await World.CreateProp(DeliveryData.VAN_GOODS_PROP_NAMES[rs], GetOffsetFromEntityInWorldCoords(Game.PlayerPed.Handle, 0.0f, 0.0f, -5.0f), Vector3.Zero, false, false);
AttachEntityToEntity(prop_ent.Handle, Game.PlayerPed.Handle, GetPedBoneIndex(Game.PlayerPed.Handle, 28422), 0.0f, 0.0f, -0.55f, 0.0f, 0.0f, 90.0f, true, false, false, true, 1, true);
m_player_attatchments.Add(prop_ent);
}
if (aDeliveryType == DeliveryType.Truck)
{
AnimationFlags flags = AnimationFlags.UpperBodyOnly | AnimationFlags.Loop | AnimationFlags.AllowRotation | AnimationFlags.StayInEndFrame | (AnimationFlags)3;
Game.PlayerPed.Task.PlayAnimation("anim@heists@box_carry@", "idle", 18.0f, -1, flags);
Prop prop_ent = null;
prop_ent = await World.CreateProp("prop_sacktruck_02b", GetOffsetFromEntityInWorldCoords(Game.PlayerPed.Handle, 0.0f, 0.0f, -5.0f), Vector3.Zero, false, false);
AttachEntityToEntity(prop_ent.Handle, Game.PlayerPed.Handle, GetEntityBoneIndexByName(Game.PlayerPed.Handle, "SKEL_Pelvis"), -0.075f, 0.90f, -0.86f, -20.0f, 0.5f, 181.0f, true, false, false, true, 1, true);
m_player_attatchments.Add(prop_ent);
}
}
internal static void AnimateWindow(Control control, int time, AnimationFlags flags)
{
Contract.Requires <ArgumentNullException>(control != null);
try
{
SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
sp.Demand();
AnimateWindow(new HandleRef(control, control.Handle), time, flags);
}
catch (SecurityException) { }
}
public static void PlayKneelAnim(int duration)
{
if (!API.DoesEntityExist(API.GetPlayerPed(API.PlayerId())))
{
return;
}
if (API.IsPedArmed(API.GetPlayerPed(API.PlayerId()), 7))
{
API.SetCurrentPedWeapon(API.GetPlayerPed(API.PlayerId()), 0xA2719263, true);
}
AnimationFlags flags = AnimationFlags.None;
Game.PlayerPed.Task.PlayAnimation("amb@medic@standing@kneel@idle_a", "idle_a", 10, duration, flags);
}
internal static void AnimateWindow(Control control, int time, AnimationFlags flags)
{
if (control == null)
{
throw new ArgumentNullException(nameof(control), "Contract assertion not met: control != null");
}
try
{
SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
sp.Demand();
AnimateWindow(new HandleRef(control, control.Handle), time, flags);
}
catch (SecurityException) { }
}
/// <summary>
/// Plays a specific animation and waits until this animation is over.
/// </summary>
/// <param name="animDict">The animation dictionary to use.</param>
/// <param name="animName">The name of the animation to use.</param>
/// <param name="animFlags">The flags to apply to the animation.</param>
public static void PlayAnimationAndWait(string animDict, string animName, AnimationFlags animFlags)
{
Ped ped = Game.Player.Character;
Function.Call(Hash.REQUEST_ANIM_DICT, animDict);
while (!Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, animDict))
{
Script.Yield();
}
Game.Player.Character.Task.PlayAnimation(animDict, animName, 8f, -8f, -1, animFlags, 0f);
while (Function.Call <float>(Hash.GET_ENTITY_ANIM_CURRENT_TIME, ped, animDict, animName) < 0.9f)
{
Script.Yield();
}
}
public void Save(string path, string name, AnimationFlags flags)
{
lock (locker)
{
foreach (var config in _settings)
{
var existing = config.Load(path, name);
if (existing != null)
{
config.Save(path, name, flags);
return;
}
}
_cache.Clear();
_defaultSetting.Save(path, name, flags);
_dumpSetting.Delete(path, name);
}
}
public void PlayAnimation(string animDict, string animName, float blendInSpeed, float blendOutSpeed, int duration,
AnimationFlags flags, float playbackRate, float timeout = 1000f)
{
if (!Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, animDict))
{
Function.Call(Hash.REQUEST_ANIM_DICT, animDict);
}
var end = DateTime.UtcNow.AddMilliseconds(timeout);
while (!Function.Call <bool>(Hash.HAS_ANIM_DICT_LOADED, animDict))
{
if (DateTime.UtcNow >= end)
{
return;
}
}
Function.Call(Hash.TASK_PLAY_ANIM, _ped.Handle, animDict, animName, blendInSpeed, blendOutSpeed,
duration, (int)flags, playbackRate, false, false, false);
}
/// <summary>
/// Plays a raw animation.
/// </summary>
/// <param name="animationName">Name of the animation we wish to play</param>
/// <param name="flags"></param>
/// <param name="slot">Slot on which to play the animation</param>
/// <param name="layer">Animation layer to play the animation in.</param>
/// <param name="blend">Transition time between two animations.</param>
/// <param name="speed">Animation playback speed</param>
public void PlayAnimation(string animationName, AnimationFlags flags = 0, int slot = 0, int layer = 0, float blend = 0.175f, float speed = 1.0f)
{
NativeEntityMethods.PlayAnimation(this.GetIEntity(), animationName, slot, layer, blend, speed, flags);
}
private static extern int AnimateWindow(HandleRef windowHandle, int time, AnimationFlags flags);
public static async Task AnimatePlayer(string dict, string animation, AnimationFlags anim_flags)
{
await RequestAnimationDictionary(dict);
PlayAnimation(dict, animation, anim_flags);
}
public static void PlayAnimation(string dict, string animation, AnimationFlags anim_flags)
{
Game.PlayerPed.Task.ClearAll();
Game.PlayerPed.Task.PlayAnimation(dict, animation, -1, -1, anim_flags);
}
public static void PlayEntityAnim(Entity entity, AnimationDictionary animDict, string animName, bool loop, AnimationFlags flags = AnimationFlags.None)
{
animDict.LoadAndWait();
NativeFunction.CallByName <uint>("PLAY_ENTITY_ANIM", entity, animName, animDict.Name, 1000f, loop, 1, 0, 0f, (uint)flags);
}
public bool HasFlag(AnimationFlags flags)
{
return((this.flags & (ushort)flags) == (ushort)flags);
}
private static extern int AnimateWindow(HandleRef windowHandle, int time, AnimationFlags flags);
/// <summary>
/// Plays a raw animation.
/// </summary>
/// <param name="animationName">Name of the animation we wish to play</param>
/// <param name="flags"></param>
/// <param name="slot">Slot on which to play the animation</param>
/// <param name="layer">Animation layer to play the animation in.</param>
/// <param name="blend">Transition time between two animations.</param>
/// <param name="speed">Animation playback speed</param>
public void PlayAnimation(string animationName, AnimationFlags flags = 0, int slot = 0, int layer = 0, float blend = 0.175f, float speed = 1.0f)
{
NativeEntityMethods.PlayAnimation(this.GetIEntity(), animationName, slot, layer, blend, speed, flags);
}
public static void AnimateWindow(Control control, int time, AnimationFlags flags)
{
User32.AnimateWindow(new HandleRef(control, control.Handle), time, flags);
}
internal static extern void PlayAnimation(IntPtr ptr, string animationName, int slot, int layer, float blend, float speed, AnimationFlags flags);
