internal static Dictionary <string, object> ToDictionary(this TargetStatus target) =>
new Dictionary <string, object>()
{
["id"] = target.Id,
["current_availability"] = target.CurrentAvailability,
["average_queue_time"] = target.AverageQueueTime,
};
void Start()
{
_target = cam.GetComponent <alTarget>();
_targetText.text = _targetStr;
TargetStatus = GameObject.Find("TargetStatus");
TargetStatus.SetActive(TargetStatusActive);
}
void OnDevicePoseStatusChanged(ObserverBehaviour behaviour, TargetStatus targetStatus)
{
var statusInfo = targetStatus.StatusInfo;
if (statusInfo == StatusInfo.RELOCALIZING)
{
// If the status is Relocalizing, then start the timer if it isn't active
if (!mRelocalizationStatusDelayTimer.Enabled)
{
mRelocalizationStatusDelayTimer.Start();
}
}
else
{
// If the status is not Relocalizing, then stop the timers if they are active
if (mRelocalizationStatusDelayTimer.Enabled)
{
mRelocalizationStatusDelayTimer.Stop();
}
if (mResetDeviceObserverTimer.Enabled)
{
mResetDeviceObserverTimer.Stop();
}
// Clear the status message
StatusMessage.Instance.Display(string.Empty);
}
}
public Target(int idx, int cnt, bool vis, TargetStatus st)
{
id = idx;
remainTouchCnt = cnt;
visible = vis;
status = st;
}
public GridAi()
{
for (int i = 0; i < TargetState.Length; i++)
{
TargetState[i] = new TargetStatus();
}
AiComp = new AiComponent(this);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 1);
TargetStatus targetStatus = DndUtils.GetTargetStatus(args[0]);
TargetCountEventArgs ea = new TargetCountEventArgs();
ea.TargetStatus = targetStatus;
OnRequestTargetCount(player, ea);
return(ea.Count);
}
/// <summary>
/// Returns Target status as string from TargetStatus Enum
/// </summary>
public static string TargetStatusAsString(TargetStatus Status)
{
string ret = string.Empty;
if (Status != TargetStatus.Null)
{
ret = Status.ToString().Replace('_', ' ');
}
return(ret);
}
internal Focus(int count)
{
Target = new MyEntity[count];
SubSystem = new BlockTypes[count];
TargetState = new TargetStatus[count];
PrevTargetId = new long[count];
for (int i = 0; i < TargetState.Length; i++)
{
TargetState[i] = new TargetStatus();
}
}
public void NotifyVoyeurOfEvent(TargetStatus status)
{
if (PhysicsObj == null || VoyeurTable == null)
{
return;
}
foreach (var voyeur in VoyeurTable.Values.ToList())
{
SendVoyeurUpdate(voyeur, PhysicsObj.Position, status);
}
}
/// <summary>
/// Copy constructor
/// </summary>
public TargetInfo(TargetInfo info)
{
ContextID = info.ContextID;
ObjectID = info.ObjectID;
Radius = info.Radius;
Quantum = info.Quantum;
TargetPosition = new Position(info.TargetPosition);
InterpolatedPosition = new Position(info.InterpolatedPosition);
InterpolatedHeading = new Vector3(info.InterpolatedHeading.X, info.InterpolatedHeading.Y, info.InterpolatedHeading.Z);
Velocity = new Vector3(info.Velocity.X, info.Velocity.Y, info.Velocity.Z);
Status = info.Status;
LastUpdateTime = info.LastUpdateTime;
}
private static bool FighterHasTargetableStatuses(Fighter targetFighter, TargetStatus targetStatus)
{
switch (targetStatus)
{
case TargetStatus.Any:
return(true);
case TargetStatus.Active:
return(targetFighter.CurrentHealth > 0);
case TargetStatus.Unconscious:
return(targetFighter.CurrentHealth == 0);
}
return(false);
}
void Update()
{
_currentTarget = _target.getActiveObject();
if (_currentTarget != null)
{
var controller = _currentTarget.GetComponent(typeof(alNpcController)) as alNpcController;
_targetStr = _currentTarget.name;
targetHp = controller.getHP();
_targetText.text = _targetStr;
hp_text.text = targetHp.ToString() + " HP";
TargetStatusActive = true;
TargetStatus.SetActive(TargetStatusActive);
}
}
public override void Empty()
{
base.Empty();
TargetNumber = 0;
TargetDistance = 0.0;
BearingFromOwnShip = 0.0;
BearingUnits = string.Empty;
TargetSpeed = 0.0;
TargetCourse = 0.0;
TargetCourseUnits = string.Empty;
DistanceOfClosestPointOfApproach = 0.0;
NumberOfMinutesToClosestPointOfApproach = 0.0;
Increasing = string.Empty;
TargetName = string.Empty;
TargetStatus = TargetStatus.Unknown;
}
public void SendVoyeurUpdate(TargettedVoyeurInfo voyeur, Position pos, TargetStatus status)
{
voyeur.LastSentPosition = new Position(pos); // ref?
var info = new TargetInfo(0, PhysicsObj.ID, voyeur.Radius, voyeur.Quantum);
info.TargetPosition = PhysicsObj.Position;
info.InterpolatedPosition = new Position(pos); // ref?
info.Velocity = PhysicsObj.get_velocity();
info.Status = status;
var voyeurObj = PhysicsObj.GetObjectA(voyeur.ObjectID);
if (voyeurObj != null)
{
voyeurObj.receive_target_update(info);
}
}
/// <summary>
/// For deserialization from a binary table.
/// </summary>
public EO3Skill(BinaryReader reader, int skillId, Table nameTable) : base(reader, skillId, nameTable)
{
Game = SkillModes.EO3;
MaxLevel = reader.ReadByte();
Type = reader.ReadByte();
UseRequirements = new EO3UseRequirements(reader.ReadUInt16());
TargetStatus = new TargetStatus(reader.ReadUInt16());
TargetType = reader.ReadByte();
TargetTeam = reader.ReadByte();
UsableLocation = new UsableLocation(reader.ReadByte());
ModifierStatus = reader.ReadByte();
ModifierType = reader.ReadByte();
reader.ReadByte(); // Unknown.
ModifierElement = new Element(reader.ReadUInt16());
DamageElement = new DamageElement(reader.ReadUInt16());
InflictionStatus = reader.ReadUInt16();
AssociatedDisables = new Disables(reader.ReadUInt16());
SkillFlags = new EO3SkillFlags(reader.ReadInt32());
DataSections = new DataSections(reader, Game);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature creature, Target target, CastedSpell spell, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 1, 3);
TargetStatus targetStatus = Expressions.Get <TargetStatus>(args[0], creature, target, spell, dice);
ea = new TargetEventArgs();
if (args.Count > 1)
{
ea.MinTargets = Expressions.GetInt(args[1], creature, target, spell, dice);
if (args.Count > 2)
{
ea.MaxTargets = Expressions.GetInt(args[2], creature, target, spell, dice);
}
}
ea.Player = creature as Character;
ea.Target = target;
ea.ShowUI = true;
ea.TargetStatus = targetStatus;
OnRequestSelectTarget(ea);
return(ea.Target);
}
public static int GetTargetCount(TargetStatus targetStatus)
{
int count = 0;
foreach (InGameCreature inGameCreature in Creatures)
{
if (inGameCreature.IsTargeted)
{
if (targetStatus.HasFlag(TargetStatus.Friendly) && inGameCreature.IsAlly)
{
count++;
}
else if (targetStatus.HasFlag(TargetStatus.Adversarial) && inGameCreature.IsEnemy)
{
count++;
}
else if (targetStatus.HasFlag(TargetStatus.AllTargets))
{
count++;
}
}
}
return(count);
}
// Works with "None" as well
public static bool HasFlag(TargetStatus a, TargetStatus b)
{
return((a & b) == b);
}
public void NotifyVoyeurOfEvent(TargetStatus status)
{
}
//Заготовка под бег
public void Run(EsoWindow esoWindow, IntPtr processHandle, IntPtr hWnd, String xAddress, String yAdress, String cAdress, String xTarget, String yTarget, String cTarget)
{
if (Form1.stopAction)
{
return; //Прекращаем функцию, если нажато F12
}
int timeCount = 0;
IntPtr bytesRead;
NumberFormatInfo nfi = new NumberFormatInfo();
nfi.NumberDecimalSeparator = ","; //Задаем запятую, как разделитель между числом и дробной частью
//Создаем массивы, куда будут считываться данные из памяти
var bufferX = new byte[8];
var bufferY = new byte[8];
var bufferC = new byte[8];
//Переводим адреса памяти из String в Hex
var addrX = long.Parse(xAddress, System.Globalization.NumberStyles.HexNumber);
var addrY = long.Parse(yAdress, System.Globalization.NumberStyles.HexNumber);
var addrC = long.Parse(cAdress, System.Globalization.NumberStyles.HexNumber);
//Читаем текущие значения X, Y, Corner
var resultX = esoWindow.ReadProcessMemory(processHandle, new IntPtr(addrX), bufferX, (uint)bufferX.Length, out bytesRead);
var resultY = esoWindow.ReadProcessMemory(processHandle, new IntPtr(addrY), bufferY, (uint)bufferY.Length, out bytesRead);
var resultC = esoWindow.ReadProcessMemory(processHandle, new IntPtr(addrC), bufferC, (uint)bufferC.Length, out bytesRead);
//Переводим текущие значения X, Y, Corner в Double
double actualX = BitConverter.ToDouble(bufferX, 0);
double actualY = BitConverter.ToDouble(bufferY, 0);
double actualC = BitConverter.ToDouble(bufferC, 0);
Console.WriteLine("Целевые координаты: " + "X: " + xTarget + " Y: " + yTarget + " C: " + cTarget);
Console.WriteLine("Текущие координаты: " + "X: " + Convert.ToString(actualX) + " Y: " + Convert.ToString(actualY) + " C: " + Convert.ToString(actualC));
//Переводим целевые значения из String в Double с использованием заданного
double targetX = Convert.ToDouble(xTarget, nfi);
double targetY = Convert.ToDouble(yTarget, nfi);
//Расчет катетов прямоугольного треугольника
double katetX = Math.Abs(targetX - actualX);
double katetY = Math.Abs(targetY - actualY);
//Находим тангенс угла и угол а
double cornerA = Math.Atan(katetY / katetX) * 180 / Math.PI;
//Поворачиваем к цели
if ((targetX > actualX) && (targetY > actualY)) //Если оба целевых значения больше текущих
{
turnCornerVer3(esoWindow, cAdress, processHandle, Convert.ToString(270 - cornerA));
tStatus = TargetStatus.X_bigger_Y_bigger;
}
if ((targetX < actualX) && (targetY < actualY)) //Если оба целевых значения меньше текущих
{
turnCornerVer3(esoWindow, cAdress, processHandle, Convert.ToString(90 - cornerA));
tStatus = TargetStatus.X_less_Y_less;
}
if ((targetX > actualX) && (targetY < actualY)) //Если целевой X больше, а Y - меньше
{
turnCornerVer3(esoWindow, cAdress, processHandle, Convert.ToString(270 + cornerA));
tStatus = TargetStatus.X_bigger_Y_less;
}
if ((targetX < actualX) && (targetY > actualY)) //Если целевой X меньше, а Y - больше
{
turnCornerVer3(esoWindow, cAdress, processHandle, Convert.ToString(90 + cornerA));
tStatus = TargetStatus.X_less_Y_bigger;
}
//Бежим к цели
while (ReachTarget(targetX, actualX, targetY, actualY))
{
if (Form1.stopAction)
{
break;
}
if (timeCount > 30000)
{
Form1.stopAction = true;
break;
}
if (isFight())
{
esoWindow.SendMessage(hWnd, (uint)WindowMessages.WM_KEYUP, new IntPtr((ushort)Keys.W), new IntPtr(0));
Fight(esoWindow, hWnd); //Если в бою, то воюем.
}
esoWindow.SendMessage(hWnd, (uint)WindowMessages.WM_KEYDOWN, new IntPtr((ushort)System.Windows.Forms.Keys.W), new IntPtr(0));
Thread.Sleep(150);
timeCount = timeCount + 150;
resultX = esoWindow.ReadProcessMemory(processHandle, new IntPtr(addrX), bufferX, (uint)bufferX.Length, out bytesRead);
resultY = esoWindow.ReadProcessMemory(processHandle, new IntPtr(addrY), bufferY, (uint)bufferY.Length, out bytesRead);
actualX = BitConverter.ToDouble(bufferX, 0);
actualY = BitConverter.ToDouble(bufferY, 0);
}
esoWindow.SendMessage(hWnd, (uint)WindowMessages.WM_KEYUP, new IntPtr((ushort)Keys.W), new IntPtr(0));
if (!Form1.stopAction && cTarget != null)
{
if (!cTarget.Equals(""))
{
turnCornerVer3(esoWindow, cAdress, processHandle, cTarget);
}
}
}
public static List <Fighter> GetTargettableFighters(Fighter originator, TargetCount targetCount, TargetSelection targetSelection, bool excludeSelf, TargetStatus targetStatus, ActionAttribute attackAttribute, TargetPosition targetPosition, TargetElevation targetElevation)
{
List <Fighter> targettableFighters = new List <Fighter>();
if (targetCount == TargetCount.AllFighters)
{
// Allys first
targettableFighters.AddRange(originator.FighterTeam.TeamMembers);
// Reverse ally order for navigation
targettableFighters.Reverse();
if (excludeSelf)
{
targettableFighters.Remove(originator);
}
targettableFighters.AddRange(originator.FighterTeam.opposingTeam.TeamMembers);
}
else
{
switch (targetSelection)
{
case TargetSelection.Ally:
targettableFighters.AddRange(originator.FighterTeam.TeamMembers);
if (excludeSelf)
{
targettableFighters.Remove(originator);
}
break;
case TargetSelection.Enemy:
targettableFighters.AddRange(originator.FighterTeam.opposingTeam.TeamMembers);
break;
case TargetSelection.Self:
targettableFighters.Add(originator);
break;
}
}
for (int i = targettableFighters.Count - 1; i >= 0; i--)
{
if (!FighterIsOnTargetableElevation(targettableFighters[i], targetElevation))
{
targettableFighters.RemoveAt(i);
continue;
}
// Positional actions will never focus on all teams, so lets do this conditionally
switch (targetPosition)
{
case TargetPosition.Front:
if (i > 0)
{
targettableFighters.RemoveAt(i);
continue;
}
break;
case TargetPosition.Rear:
if (i < targettableFighters.Count - 1)
{
targettableFighters.RemoveAt(i);
}
break;
}
if (!FighterHasTargetableStatuses(targettableFighters[0], targetStatus))
{
targettableFighters.RemoveAt(i);
}
if (!FighterHasTargetableAttributes(targettableFighters[0], attackAttribute))
{
targettableFighters.RemoveAt(i);
}
}
return(targettableFighters);
}
/// <summary>
/// Callback from the EasyAR component whic renders the foreground nodes.
/// </summary>
/// <param name="oFrame"></param>
/// <param name="cameraParameters"></param>
/// <param name="aspectRatio"></param>
/// <param name="rotation"></param>
protected void OnARFrameUpdated(OutputFrame oFrame, CameraParameters cameraParameters, float aspectRatio, int rotation)
{
var far = 100f;
var near = 0.01f;
Matrix44F sp = cameraParameters.projection(near, far, aspectRatio, rotation, true, false);
foreach (Optional <FrameFilterResult> unTypedResult in oFrame.results())
{
if (unTypedResult.OnSome)
{
if (unTypedResult.Some is ImageTrackerResult result)
{
int targetIndex = 0;
List <TargetInstance> targetInstances = result.targetInstances();
foreach (TargetInstance targetInstance in targetInstances)
{
TargetStatus status = targetInstance.status();
if (status == TargetStatus.Tracked)
{
Optional <Target> optionalTarget = targetInstance.target();
if (optionalTarget.OnSome)
{
Target target = optionalTarget.Some;
if (target is ImageTarget imageTarget)
{
List <Image> images = imageTarget.images();
Image targetImage = images[0];
Matrix4 prj = sp.ToUrhoMatrix();
prj.M34 /= 2f;
prj.M33 = far / (far - near);
prj.M43 *= -1;
fgCamera.SetProjection(prj);
Matrix4 convertedPoseMatrix = targetInstance.pose().ToUrhoMatrix();
Vector3 scale = new Vector3(imageTarget.scale(), imageTarget.scale() * targetImage.height() / targetImage.width(), 1);
UpdateArScene(targetIndex, convertedPoseMatrix, scale);
foreach (Image targetImageToRelease in images)
{
targetImageToRelease.Dispose();
}
}
target.Dispose();
}
}
targetInstance.Dispose();
targetIndex++;
}
// Remove any targets that can no longer be located
while (targetNodes.Count > targetIndex)
{
Node node = targetNodes[targetIndex];
targetNodes.RemoveAt(targetIndex);
node.Remove();
}
}
unTypedResult.Some.Dispose();
}
}
}
public static TargetStatus SetFlag(TargetStatus a, TargetStatus b)
{
return(a | b);
}
public static TargetStatus ToogleFlag(TargetStatus a, TargetStatus b)
{
return(a ^ b);
}
public override bool Parse(Sentence sentence)
{
/*
** TTM - Tracked Target Message
**
** 11 13
** 1 2 3 4 5 6 7 8 9 10| 12| 14
** | | | | | | | | | | | | | |
** $--TTM,xx,x.x,x.x,a,x.x,x.x,a,x.x,x.x,a,c--c,a,a*hh<CR><LF>
**
** 1) Target Number
** 2) Target Distance
** 3) Bearing from own ship
** 4) Bearing Units
** 5) Target speed
** 6) Target Course
** 7) Course Units
** 8) Distance of closest-point-of-approach
** 9) Time until closest-point-of-approach "-" means increasing
** 10) "-" means increasing
** 11) Target name
** 12) Target Status
** 13) Reference Target
** 14) Checksum
*/
/*
** First we check the checksum...
*/
if (sentence.IsChecksumBad() == NMEA.Boolean.True)
{
Empty();
return(false);
}
TargetNumber = sentence.Integer(1);
TargetDistance = sentence.Double(2);
BearingFromOwnShip = sentence.Double(3);
BearingUnits = sentence.Field(4);
TargetSpeed = sentence.Double(5);
TargetCourse = sentence.Double(6);
TargetCourseUnits = sentence.Field(7);
DistanceOfClosestPointOfApproach = sentence.Double(8);
NumberOfMinutesToClosestPointOfApproach = sentence.Double(9);
Increasing = sentence.Field(10);
TargetName = sentence.Field(11);
string field_data = sentence.Field(12);
if (field_data == "L")
{
TargetStatus = TargetStatus.Lost;
}
else if (field_data == "Q")
{
TargetStatus = TargetStatus.Query;
}
else if (field_data == "T")
{
TargetStatus = TargetStatus.Tracking;
}
else
{
TargetStatus = TargetStatus.Unknown;
}
ReferenceTarget = sentence.Field(13);
return(true);
}
public static TargetStatus UnsetFlag(TargetStatus a, TargetStatus b)
{
return(a & (~b));
}
