/// <summary>
/// Contient l'execution des actions à la fin du match
/// </summary>
protected virtual void SequenceEnd()
{
// TODOEACHYEAR Couper ICI tous les actionneurs à la fin du match et lancer la Funny Action / afficher le score
Robots.MainRobot.Stop(StopMode.Freely);
Actionneur.ElevatorLeft.DoElevatorFree();
Actionneur.ElevatorRight.DoElevatorFree();
MovementFlags moveFlags = new MovementFlags();
if (moveFlags.ExecuteHere())
{
GameBoard.Score += moveFlags.Score;
}
System.Threading.Thread.Sleep(1000);
AllDevices.CanServos.DisableAll();
// On renvoie le score au cas où histoire d'assurer le truc...
if (!Config.CurrentConfig.IsMiniRobot)
{
Robots.MainRobot.ShowMessage("Estimation :", GameBoard.Score.ToString() + " points");
}
}
protected override void WriteMovementUpdate(PrimitiveWriter packet, UpdateFieldFlags relation)
{
WriteMovementPacketInfo(packet);
#region Speed Block
packet.Write(WalkSpeed);
packet.Write(RunSpeed);
packet.Write(RunBackSpeed);
packet.Write(SwimSpeed);
packet.Write(SwimBackSpeed);
packet.Write(FlightSpeed);
packet.Write(FlightBackSpeed);
packet.Write(TurnSpeed);
packet.Write(PitchRate);
#endregion
#region Spline Info
if (MovementFlags.HasFlag(MovementFlags.SplineEnabled))
{
// TODO: Write spline flags
//var splineFlags = SplineFlags.None;
}
#endregion
}
protected override void Write(BinaryWriter writer)
{
writer.Write(ObjectId.GetPacked());
writer.Write((int)MovementFlags);
writer.Write(Time);
writer.Write(Position.X);
writer.Write(Position.Y);
writer.Write(Position.Z);
writer.Write(Orientation);
if (MovementFlags.HasFlag(MovementFlags.OnTransport))
{
writer.Write(Transport.Id);
writer.Write(Transport.Position.X);
writer.Write(Transport.Position.Y);
writer.Write(Transport.Position.Z);
writer.Write(Transport.Orientation);
}
if (MovementFlags.HasFlag(MovementFlags.ModeSwimming))
{
writer.Write(Pitch.Value);
}
writer.Write(FallTime);
if (MovementFlags.HasFlag(MovementFlags.ModeFalling))
{
writer.Write(Falling.Velocity);
writer.Write(Falling.SinAngle);
writer.Write(Falling.CosAngle);
writer.Write(Falling.XYSpeed);
}
}
public void Read(PacketIn p)
{
GUID = p.ReadPackedGUID();
Flags = (MovementFlags)p.ReadUInt32();
Flags2 = (MovementFlags2)p.ReadUInt16();
Time = p.ReadUInt32();
PositionX = p.ReadSingle();
PositionY = p.ReadSingle();
PositionZ = p.ReadSingle();
PositionO = p.ReadSingle();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_ONTRANSPORT))
{
if (MovementDataTransport == null)
{
MovementDataTransport = new MovementDataTransport();
}
MovementDataTransport.TransportGuid = p.ReadPackedGUID();
MovementDataTransport.TransportX = p.ReadSingle();
MovementDataTransport.TransportY = p.ReadSingle();
MovementDataTransport.TransportZ = p.ReadSingle();
MovementDataTransport.TransportO = p.ReadSingle();
MovementDataTransport.TransportTime = p.ReadUInt32();
MovementDataTransport.TransportSeat = p.ReadByte();
if (Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_INTERPOLATED_MOVEMENT))
{
MovementDataTransport.TransportTime2 = p.ReadUInt32();
}
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SWIMMING | MovementFlags.MOVEMENTFLAG_FLYING) ||
Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING))
{
Pitch = p.ReadSingle();
}
FallTime = p.ReadUInt32();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_FALLING))
{
FallVerticalSpeed = p.ReadSingle();
FallSine = p.ReadSingle();
FallCosine = p.ReadSingle();
FallLateralSpeed = p.ReadSingle();
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SPLINE_ELEVATION))
{
SplineElevation = p.ReadSingle();
}
}
public void SetMovementFlag(MovementFlags flag, bool add)
{
if (add)
{
AddMovementFlag(flag);
}
else
{
RemoveMovementFlag(flag);
}
}
internal void SetMovementFlag(MovementFlags flag, bool add)
{
if (add)
{
MovementFlags |= flag;
}
else
{
MovementFlags &= ~flag;
}
UpdateMovementState();
}
public async Task StartReading(MovementFlags flags)
{
if (!isReading)
{
// One bit for each gyro and accelerometer axis (6), magnetometer (1), wake-on-motion enable (1), accelerometer range (2).
// Write any bit combination top enable the desired features
DataWriter writer = new DataWriter();
WriteBigEndian16bit(writer, (ushort)flags);
IBuffer buffer = writer.DetachBuffer();
await WriteCharacteristicBytes(MovementCharacteristicConfigUuid, buffer);
isReading = true;
}
}
protected Unit(ObjectID id, ObjectTypeID typeId, ushort fieldsCount) : base(id, typeId, fieldsCount)
{
movementFlags = MovementFlags.None;
movementFlagsUpdated = false;
MovementSpeed = new MovementSpeed();
// initialize default values
CastSpeed = 1.0f;
Energy = 100;
EnergyMax = 100;
RageMax = 1000;
AttackTimeMainhandMilliseconds = 2000;
AttackTimeOffhandMilliseconds = 2000;
AttackTimeRangedMilliseconds = 2000;
}
protected override void Read(BinaryReader reader)
{
MovementFlags = (MovementFlags)reader.ReadInt32();
Time = reader.ReadInt32();
Position = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Orientation = reader.ReadSingle();
if (MovementFlags.HasFlag(MovementFlags.OnTransport))
{
Transport = new TransportInfo()
{
Id = new ObjectID(reader.ReadInt64()),
Position = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()),
Orientation = reader.ReadSingle(),
};
}
else
{
Transport = null;
}
if (MovementFlags.HasFlag(MovementFlags.ModeSwimming))
{
Pitch = reader.ReadSingle();
}
else
{
Pitch = null;
}
FallTime = reader.ReadInt32();
if (MovementFlags.HasFlag(MovementFlags.ModeFalling))
{
Falling = new FallingInfo()
{
Velocity = reader.ReadSingle(),
SinAngle = reader.ReadSingle(),
CosAngle = reader.ReadSingle(),
XYSpeed = reader.ReadSingle(),
};
}
else
{
Falling = null;
}
}
public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
{
System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
this.CharacterMovementMovementFlags = ((MovementFlags)(binaryReader.ReadInt32()));
this.PathfindingRadius = binaryReader.ReadSingle();
this.DestinationRadius = binaryReader.ReadSingle();
this.DiveGrenadeChance = binaryReader.ReadSingle();
this.ObstacleLeapMinSize = ((ObstacleLeapMinSizeEnum)(binaryReader.ReadInt16()));
this.ObstacleLeapMaxSize = ((ObstacleLeapMaxSizeEnum)(binaryReader.ReadInt16()));
this.ObstacleIgnoreSize = ((ObstacleIgnoreSizeEnum)(binaryReader.ReadInt16()));
this.ObstacleSmashableSize = ((ObstacleSmashableSizeEnum)(binaryReader.ReadInt16()));
this.fieldpad = binaryReader.ReadBytes(2);
this.JumpHeight = ((JumpHeightEnum)(binaryReader.ReadInt16()));
this.CharacterMovementMovementHints = ((MovementHints)(binaryReader.ReadInt32()));
this.ThrottleScale = binaryReader.ReadSingle();
return(pointerQueue);
}
internal Spell(Unit caster, SpellInfo info, SpellCastingOptions options)
{
Logging.LogSpell($"Created new spell, current count: {++SpellAliveCount}");
spellManager = caster.World.SpellManager;
spellValue.CastFlags = options.SpellFlags;
casterMovementFlags = options.MovementFlags ?? caster.MovementInfo.Flags;
SchoolMask = info.SchoolMask;
CastTime = CastTimeLeft = EffectDamage = EffectHealing = 0;
Caster = OriginalCaster = caster;
SpellInfo = info;
IsTriggered = spellValue.CastFlags.HasTargetFlag(SpellCastFlags.TriggeredByAura);
if (IsTriggered)
{
spellValue.CastFlags |= SpellCastFlags.IgnoreTargetCheck | SpellCastFlags.IgnoreRangeCheck |
SpellCastFlags.IgnoreShapeShift | SpellCastFlags.IgnoreAuraInterruptFlags | SpellCastFlags.IgnoreCasterState;
}
if (info.HasAttribute(SpellExtraAttributes.CanCastWhileCasting))
{
spellValue.CastFlags |= SpellCastFlags.IgnoreCastInProgress | SpellCastFlags.CastDirectly;
}
if (info.HasAttribute(SpellExtraAttributes.IgnoreGcd))
{
spellValue.CastFlags |= SpellCastFlags.IgnoreGcd;
}
if (info.HasAttribute(SpellExtraAttributes.IgnoreCasterAuras))
{
spellValue.CastFlags |= SpellCastFlags.IgnoreCasterAuras;
}
CanReflect = SpellInfo.DamageClass == SpellDamageClass.Magic && !SpellInfo.HasAttribute(SpellAttributes.CantBeReflected) &&
!SpellInfo.HasAttribute(SpellAttributes.UnaffectedByInvulnerability) && !SpellInfo.IsPassive && !SpellInfo.IsPositive;
ExplicitTargets = options.Targets ?? new SpellExplicitTargets();
ImplicitTargets = new SpellImplicitTargets(this);
spellManager.Add(this);
}
public MovementInfo(InPacket packet)
{
Flags = (MovementFlags)packet.ReadUInt32();
Flags2 = (MovementFlags2)packet.ReadUInt16();
Time = packet.ReadUInt32();
Position = packet.ReadVector3();
O = packet.ReadSingle();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_ONTRANSPORT))
{
TransportGuid = packet.ReadPackedGuid();
TransportPosition = packet.ReadVector3();
TransportO = packet.ReadSingle();
TransportTime = packet.ReadUInt32();
TransportSeat = packet.ReadByte();
if (Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_INTERPOLATED_MOVEMENT))
{
TransportTime2 = packet.ReadUInt32();
}
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SWIMMING) || Flags.HasFlag(MovementFlags.MOVEMENTFLAG_FLYING) ||
Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING))
{
Pitch = packet.ReadSingle();
}
FallTime = packet.ReadUInt32();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_FALLING))
{
JumpZSpeed = packet.ReadSingle();
JumpSinAngle = packet.ReadSingle();
JumpCosAngle = packet.ReadSingle();
JumpXYSpeed = packet.ReadSingle();
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SPLINE_ELEVATION))
{
SplineElevation = packet.ReadSingle();
}
}
private async void MoveButton_Click(object sender, RoutedEventArgs args)
{
int x, y, z;
long e;
uint t;
MovementFlags flags = 0;
if (CB_X_Relative.IsChecked ?? false)
{
flags |= MovementFlags.RelativeX;
}
if (CB_Y_Relative.IsChecked ?? false)
{
flags |= MovementFlags.RelativeY;
}
if (CB_Z_Relative.IsChecked ?? false)
{
flags |= MovementFlags.RelativeZ;
}
if (!(CB_E_Relative.IsChecked ?? false))
{
flags |= MovementFlags.AbsoluteE;
}
if (int.TryParse(TB_X.Text, out x) && int.TryParse(TB_Y.Text, out y) && int.TryParse(TB_Z.Text, out z) && long.TryParse(TB_E.Text, out e) && uint.TryParse(TB_T.Text, out t))
{
var pos = new Movement()
{
Duration = t,
StepE = e,
StepX = x,
StepY = y,
StepZ = z,
Flags = flags,
};
var result = comms.WritePositionAsync(pos);
await debugCommand($"Move {x},{y},{z} {e} in {t / 1000000.0} sec", result);
}
}
private async Task <MovementFlags> GetConfig()
{
var ch = GetCharacteristic(MovementCharacteristicConfigUuid);
if (ch != null)
{
var properties = ch.CharacteristicProperties;
if ((properties & GattCharacteristicProperties.Read) != 0)
{
var result = await ch.ReadValueAsync();
IBuffer buffer = result.Value;
DataReader reader = DataReader.FromBuffer(buffer);
short value = ReadBigEndian16bit(reader);
MovementFlags flags = (MovementFlags)value;
Debug.WriteLine("Acceleration config = " + flags);
return(flags);
}
}
return(MovementFlags.None);
}
private void HandleSpellCast(Event request, int spellId, MovementFlags movementFlags, Vector3?destination = null)
{
Player caster = World.FindPlayer(request.RaisedBy);
SpellCastRequestAnswerEvent spellCastAnswer = request.FromSelf
? SpellCastRequestAnswerEvent.Create(GlobalTargets.OnlyServer)
: SpellCastRequestAnswerEvent.Create(request.RaisedBy);
spellCastAnswer.SpellId = spellId;
if (caster == null)
{
spellCastAnswer.Result = (int)SpellCastResult.CasterNotExists;
spellCastAnswer.Send();
return;
}
if (!balance.SpellInfosById.TryGetValue(spellId, out SpellInfo spellInfo))
{
spellCastAnswer.Result = (int)SpellCastResult.SpellUnavailable;
spellCastAnswer.Send();
return;
}
SpellCastingOptions options = destination.HasValue
? new SpellCastingOptions(new SpellExplicitTargets {
Destination = destination.Value
})
: new SpellCastingOptions(movementFlags: movementFlags);
SpellCastResult castResult = caster.Spells.CastSpell(spellInfo, options);
if (castResult != SpellCastResult.Success)
{
spellCastAnswer.Result = (int)castResult;
spellCastAnswer.Send();
}
}
public Task SetMovementState(MovementFlags movementFlags, int time, int fallTime, Jump jump)
{
VerifyExists();
State.MoveFlags = movementFlags;
State.MoveTime = time;
State.FallTime = fallTime;
if (jump != null)
{
State.Jump.Velocity = jump.Velocity;
State.Jump.SineAngle = jump.SineAngle;
State.Jump.CosineAngle = jump.CosineAngle;
State.Jump.XYSpeed = jump.XYSpeed;
}
else
{
State.Jump.Velocity = State.Jump.SineAngle = State.Jump.CosineAngle = State.Jump.XYSpeed = 0.0f;
}
IsMovementUpdated = true;
return(WriteStateAsync());
}
public bool IsMoveFlagSet(MovementFlags flag)
{
return(((MoveFlags & flag) >= (MovementFlags)1) ? true : false);
}
public static bool Has(this MovementFlags flags, MovementFlags toCheck)
{
return (flags & toCheck) != 0;
}
public MovementInfo(InPacket packet)
{
Flags = (MovementFlags)packet.ReadUInt32();
Flags2 = (MovementFlags2)packet.ReadUInt16();
Time = packet.ReadUInt32();
Position = packet.ReadVector3();
O = packet.ReadSingle();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_ONTRANSPORT))
{
TransportGuid = packet.ReadPackedGuid();
TransportPosition = packet.ReadVector3();
TransportO = packet.ReadSingle();
TransportTime = packet.ReadUInt32();
TransportSeat = packet.ReadByte();
if (Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_INTERPOLATED_MOVEMENT))
TransportTime2 = packet.ReadUInt32();
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SWIMMING) || Flags.HasFlag(MovementFlags.MOVEMENTFLAG_FLYING)
|| Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING))
Pitch = packet.ReadSingle();
FallTime = packet.ReadUInt32();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_FALLING))
{
JumpZSpeed = packet.ReadSingle();
JumpSinAngle = packet.ReadSingle();
JumpCosAngle = packet.ReadSingle();
JumpXYSpeed = packet.ReadSingle();
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SPLINE_ELEVATION))
SplineElevation = packet.ReadSingle();
}
public void Clear()
{
MoveFlags = new MovementFlags();
}
public void SetMoveFlag(MovementFlags flag)
{
MoveFlags |= (ulong)flag;
}
public bool HasMovementFlag(MovementFlags flag)
{
return((MovementFlags & flag) != 0);
}
public bool IsMoveFlagSet(MovementFlags flag)
{
return(((MoveFlags & (uint)flag) >= 1) ? true : false);
}
public static bool HasAnyFlag(this MovementFlags flags, MovementFlags otherFlags)
{
return (flags & otherFlags) != 0;
}
public void SetMoveFlag(MovementFlags flag)
{
MoveFlags |= (uint)flag;
}
public void UnSetMoveFlag(MovementFlags flag)
{
Flags &= ~flag;
}
public void SetMoveFlag(MovementFlags flag)
{
Flags |= flag;
}
public bool IsMoveFlagSet(MovementFlags flag)
{
return Flags.HasFlag(flag) ? true : false;
}
public void Read(PacketIn p)
{
GUID = p.ReadPackedGUID();
Flags = (MovementFlags)p.ReadUInt32();
Flags2 = (MovementFlags2)p.ReadUInt16();
Time = p.ReadUInt32();
PositionX = p.ReadSingle();
PositionY = p.ReadSingle();
PositionZ = p.ReadSingle();
PositionO = p.ReadSingle();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_ONTRANSPORT))
{
if (MovementDataTransport == null)
MovementDataTransport = new MovementDataTransport();
MovementDataTransport.TransportGuid = p.ReadPackedGUID();
MovementDataTransport.TransportX = p.ReadSingle();
MovementDataTransport.TransportY = p.ReadSingle();
MovementDataTransport.TransportZ = p.ReadSingle();
MovementDataTransport.TransportO = p.ReadSingle();
MovementDataTransport.TransportTime = p.ReadUInt32();
MovementDataTransport.TransportSeat = p.ReadByte();
if (Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_INTERPOLATED_MOVEMENT))
MovementDataTransport.TransportTime2 = p.ReadUInt32();
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SWIMMING | MovementFlags.MOVEMENTFLAG_FLYING) ||
Flags2.HasFlag(MovementFlags2.MOVEMENTFLAG2_ALWAYS_ALLOW_PITCHING))
Pitch = p.ReadSingle();
FallTime = p.ReadUInt32();
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_FALLING))
{
FallVerticalSpeed = p.ReadSingle();
FallSine = p.ReadSingle();
FallCosine = p.ReadSingle();
FallLateralSpeed = p.ReadSingle();
}
if (Flags.HasFlag(MovementFlags.MOVEMENTFLAG_SPLINE_ELEVATION))
SplineElevation = p.ReadSingle();
}
public void UnSetMoveFlag(MovementFlags flag)
{
MoveFlags &= ~(uint)flag;
}
public void AddMovementFlag(MovementFlags flag)
{
Flags |= flag;
UpdateMovementState();
}
public void RemoveMovementFlag(MovementFlags flag)
{
Flags &= ~flag;
UpdateMovementState();
}
protected void SetFlags(MovementFlags flags)
{
Flags = flags;
UpdateMovementState();
}
internal void OverrideMovementFlags(MovementFlags flags)
{
MovementFlags = flags;
UpdateMovementState();
}
public bool IsMoveFlagSet(MovementFlags flag)
{
return ((MoveFlags & (uint)flag) >= 1) ? true : false;
}
private void SetFlags(MovementFlags flags)
{
MovementFlags = flags;
UpdateMovementState();
}
public void SetMoveFlag(MovementFlags flag)
{
MoveFlags |= (uint)flag;
}
public static bool HasAnyFlag(this MovementFlags flags, MovementFlags otherFlags)
{
return((flags & otherFlags) != MovementFlags.None);
}
public void UnSetMoveFlag(MovementFlags flag)
{
MoveFlags &= ~(uint)flag;
}
/// <summary>
///
/// </summary>
/// <param name="packet">The packet to read the info from</param>
/// <param name="chr">The active character in the client that send the movement packet</param>
/// <param name="mover">The unit we want this movement info to affect</param>
/// <param name="clientTime">Used to return the read client time</param>
/// <returns>A boolean value used to determine broadcasting of this movement info to other clients</returns>
public static bool ReadMovementInfo(RealmPacketIn packet, Character chr, Unit mover, out uint clientTime)
{
MovementFlags movementFlags = (MovementFlags)packet.ReadInt32();
MovementFlags2 movementFlags2 = (MovementFlags2)packet.ReadInt16();
clientTime = packet.ReadUInt32();
Vector3 pt = packet.ReadVector3();
float orientation = packet.ReadFloat();
if (movementFlags.HasFlag((Enum)MovementFlags.OnTransport))
{
EntityId id = packet.ReadPackedEntityId();
Vector3 vector3 = packet.ReadVector3();
float num1 = packet.ReadFloat();
uint num2 = packet.ReadUInt32();
int num3 = (int)packet.ReadByte();
ITransportInfo transportInfo = mover.Map.GetObject(id) as ITransportInfo;
bool flag = transportInfo is Vehicle;
if (transportInfo == null)
{
if (mover.Transport != null)
{
mover.Transport.RemovePassenger(mover);
}
return(false);
}
if (mover.TransportInfo != transportInfo)
{
if (flag)
{
return(false);
}
((Transport)transportInfo).AddPassenger(mover);
}
if (!flag)
{
mover.TransportPosition = vector3;
mover.TransportOrientation = num1;
mover.TransportTime = num2;
}
}
else if (mover.Transport != null)
{
mover.Transport.RemovePassenger(mover);
}
if (movementFlags.HasFlag((Enum)(MovementFlags.Swimming | MovementFlags.Flying)) ||
movementFlags2.HasFlag((Enum)MovementFlags2.AlwaysAllowPitching))
{
if (movementFlags.HasFlag((Enum)MovementFlags.Flying) && !chr.CanFly)
{
return(false);
}
float moveAngle = packet.ReadFloat();
if (chr == mover)
{
chr.MovePitch(moveAngle);
}
}
int num4 = (int)packet.ReadUInt32();
if (movementFlags.HasFlag((Enum)MovementFlags.Falling))
{
double num1 = (double)packet.ReadFloat();
double num2 = (double)packet.ReadFloat();
double num3 = (double)packet.ReadFloat();
double num5 = (double)packet.ReadFloat();
}
if (packet.PacketId.RawId == 201U && chr == mover)
{
chr.OnFalling();
}
if (movementFlags.HasFlag((Enum)MovementFlags.Swimming) && chr == mover)
{
chr.OnSwim();
}
else if (chr.IsSwimming && chr == mover)
{
chr.OnStopSwimming();
}
if (movementFlags.HasFlag((Enum)MovementFlags.SplineElevation))
{
double num6 = (double)packet.ReadFloat();
}
bool flag1 = pt == mover.Position;
if (!flag1 && mover.IsInWorld && !mover.SetPosition(pt, orientation))
{
return(false);
}
if (flag1)
{
mover.Orientation = orientation;
}
else
{
mover.OnMove();
}
mover.MovementFlags = movementFlags;
mover.MovementFlags2 = movementFlags2;
if (flag1)
{
mover.Orientation = orientation;
}
else if (!mover.CanMove)
{
return(false);
}
return(true);
}
public static bool IsMoving(this MovementFlags movementFlags) => (movementFlags & MovementFlags.MaskMoving) != 0;
