public void AddMemory(GameObject LeTarget)
{
//Create a new memory record
MemoryRecord record = new MemoryRecord();
if (LeTarget.tag == "Player")
{
record = new MemoryRecord(DateTime.Now, LeTarget.transform.position, true, LeTarget.GetComponent <Player_Gun>().currentHP, LeTarget.GetComponent <Player_Gun>().currentAmmo);
}
else
{
record = new MemoryRecord(DateTime.Now, LeTarget.transform.position, true, LeTarget.GetComponent <Agent>().isDead);
}
//Check if there already is a previous memory record for this target
if (MemoryMap.ContainsKey(LeTarget))
{
//Overwrite the previous record instead of adding a new one
MemoryMap[LeTarget] = record;
}
else
{
//Otherwise add the new record
MemoryMap.Add(LeTarget, record);
}
}
/// <summary>
/// 清楚目标的方法
/// </summary>
public void ClearTarget()
{
//同时也清除这个目标对应的记忆
if (this.owner.Raven_TargetSelectionSystem.isHaveTarget())
{
this.owner.SensoryComponent.RemoveMemeory(currentTarget.TargetID);
}
currentTarget = null;
}
public void addMemory(GameObject target)
{
MemoryRecord mRecord = new MemoryRecord(DateTime.Now, target.transform.position, true);
if (MemoryMap.ContainsKey(target))
{
MemoryMap[target] = mRecord;
}
else
{
MemoryMap.Add(target, mRecord);
}
}
/// <summary>
/// 目标选择组件的消息处理函数
/// </summary>
public bool OnMessage(Msg msg)
{
switch ((EntityMsgType)msg.Op)
{
case EntityMsgType.HasBeenKilled:
//正中红心
if (currentTarget != null && msg.SenderID == currentTarget.TargetID)
{
currentTarget = null;
}
return(true);
}
return(false);
}
/// <summary>
/// Shows some of the scanner results.
/// </summary>
public void ShowScannerResults(Scanner scanner)
{
Contract.Requires(scanner != null);
SetResultCount(scanner.TotalResultCount);
resultMemoryRecordList.SetRecords(
scanner.GetResults()
.Take(MaxVisibleResults)
.OrderBy(r => r.Address, IntPtrComparer.Instance)
.Select(r =>
{
var record = new MemoryRecord(r);
record.ResolveAddress(Program.RemoteProcess);
return(record);
})
);
}
/// <summary>
/// 获取一个最近被感知的实体
/// </summary>
/// <returns></returns>
public MemoryRecord GetClostEntityLastSense()
{
float time = float.PositiveInfinity;
MemoryRecord target = null;
int targetID = -1;
foreach (var m in this.sensoryMemory.Memorys.Values)
{
if (time > m.TimeLastSensed)
{
time = m.TimeLastSensed;
target = m;
targetID = m.TargetID;
}
}
return(target);
}
/// <summary>
/// 获取一个视野范围内最近的一个目标
/// </summary>
/// <returns></returns>
public MemoryRecord GetClostEntityInFOV()
{
float sqrtDist = distance;
MemoryRecord target = null;
int targetID = -1;
foreach (var m in sensoryMemory.Memorys.Values)
{
float sdist = (this.owner.Pos - m.LastSensedPosition).sqrMagnitude;
if (sqrtDist > sdist)
{
targetID = m.TargetID;
target = m;
sqrtDist = sdist;
}
}
return(target);
}
/// <summary>
/// 更新目标选择系统的状态
/// </summary>
public void Update(float detalTime)
{
//每次更新目标是什么
//目标的选择规则
//1.目标要么是在攻击距离内的AI
//2.目标要么是在视野范围内的AI
//3.目标要么是最近被感知到的AI
if ((currentTarget = ravenSensoryComponent.GetClostCanShootEntityInMemory()) != null)
{
//Debug.Log("选中了一个可以攻击的目标");
}
else if ((currentTarget = ravenSensoryComponent.GetClostEntityInFOV()) != null)
{
//Debug.Log("选中了一个在视野范围内的目标");
}
else if ((currentTarget = ravenSensoryComponent.GetClostEntityLastSense()) != null)
{
//Debug.Log("选中了一个在视野中最近被感知到的目标");
}
}
/// <summary>
/// 上传一个听觉的数据
/// </summary>
public void UpdateViewRecord(GameObject target)
{
MemoryRecord r;
if ((r = viewRecords.Find(x => x.target == target)) == null) //没找到旧的记录
{
r = new MemoryRecord
{
firstTime = Time.time,
lastTime = Time.time,
lastPos = target.transform.position,
target = target
};
viewRecords.Add(r);
}
//找到旧记录
else
{
r.lastPos = target.transform.position;
r.lastTime = Time.time;
}
}
/// <summary>
/// Attaches the debugger to find what interacts with the selected record.
/// </summary>
/// <exception cref="ArgumentOutOfRangeException">Thrown when one or more arguments are outside the required range.</exception>
/// <param name="record">The record.</param>
/// <param name="writeOnly">True to search only for write access.</param>
private static void FindWhatInteractsWithSelectedRecord(MemoryRecord record, bool writeOnly)
{
int size;
switch (record.ValueType)
{
case ScanValueType.Byte:
size = 1;
break;
case ScanValueType.Short:
size = 2;
break;
case ScanValueType.Integer:
case ScanValueType.Float:
size = 4;
break;
case ScanValueType.Long:
case ScanValueType.Double:
size = 8;
break;
case ScanValueType.ArrayOfBytes:
size = record.ValueLength;
break;
case ScanValueType.String:
size = record.ValueLength;
break;
default:
throw new ArgumentOutOfRangeException();
}
LinkedWindowFeatures.FindWhatInteractsWithAddress(record.RealAddress, size, writeOnly);
}
/// <summary>
/// 添加一个记录
/// </summary>
public void AddMemoryRecord(RavenEntity entity, MemoryRecord record)
{
if (Memorys.ContainsKey(entity.ID))
{
//如果记忆中已经有这个记录了
var memory = Memorys[entity.ID];
memory.TimeLastSensed = record.TimeLastSensed;
memory.LastSensedPosition = record.LastSensedPosition;
memory.TimeLastVisible = record.TimeLastVisible;
memory.IsShootable = record.IsShootable;
memory.IsWithinFov = record.IsWithinFov;
//Debug.Log("记忆中已经有这个记录了");
}
else
{
record.TimeBecameVisible = record.TimeLastVisible;
record.TimeBecomeSense = record.TimeLastSensed;
Memorys.Add(entity.ID, record);
//Debug.Log("记忆中没有这个记录已经进行添加,当前的记忆有"+Memorys.Values.Count);
}
}
/// <summary>
/// 进行视觉检测
/// </summary>
protected void SightDetection()
{
foreach (var entity in EntityManager.Instance.EntityContainer.Values)
{
if (entity.ID != this.owner.ID)
{
var e = (RavenEntity)entity;
if (isInSight(e))
{
MemoryRecord record = new MemoryRecord();
record.IsWithinFov = true;
record.LastSensedPosition = e.Pos;
record.TimeLastSensed = Time.time;
record.TimeLastVisible = Time.time;
record.TargetID = e.ID;
if (this.isCanAttack(e))
{
//这个目标是可以进行射击的
//Debug.LogError(this.owner.gameObject.name+"检测到一个可以进行设计的目标");
record.IsShootable = true;
}
else
{
record.IsShootable = false;
}
//构建一个MemroyRecord
this.sensoryMemory.AddMemoryRecord(e, record);
}
}
}
}
/// <summary>
/// 从记忆中获取被感知的最近的AI
/// </summary>
/// <returns></returns>
public int GetCloseEntityInMemory(ref Vector2 pos)
{
MemoryRecord record = null;
float sqrtDist = float.PositiveInfinity;
foreach (var r in this.sensoryMemory.Memorys.Values)
{
float sdist = (r.LastSensedPosition - this.owner.Pos).sqrMagnitude;
if (sqrtDist > sdist)
{
record = r;
sqrtDist = sdist;
}
}
if (record != null)
{
pos = record.LastSensedPosition;
return(record.TargetID);
}
return(-1);
}
void OnTriggerStay2D(Collider2D other)
{
if (other.gameObject == owner)
return;
Vector3 toTarget = other.transform.position - owner.transform.position;
float angle = Vector3.Angle(owner.transform.right, toTarget);
if (angle <= fov/2.0f)
{
if (memory.ContainsKey(other.gameObject))
{
memory[other.gameObject].timeLastSeen = Time.time;
memory[other.gameObject].lastKnownPosition = other.gameObject.transform.position;
}
else
{
MemoryRecord record = new MemoryRecord(other.transform.position, Time.time);
memory.Add(other.gameObject, record);
}
}
}
public void MemoryRecordTest5()
{
MemoryRecord record = new MemoryRecord(0, "0000100000000101", "805", 2);
Assert.IsFalse(record.isComplex);
}
private void memorySearchResultControl_ResultDoubleClick(object sender, MemoryRecord record)
{
addressListMemoryRecordList.Records.Add(record);
}
public IEnumerable <MemoryRecord> Load(string filePath, ILogger logger)
{
using (var fs = new FileStream(filePath, FileMode.Open))
{
using (var archive = new ZipArchive(fs, ZipArchiveMode.Read))
{
var dataEntry = archive.GetEntry(DataFileName);
if (dataEntry == null)
{
throw new FormatException();
}
using (var entryStream = dataEntry.Open())
{
var document = XDocument.Load(entryStream);
if (document.Root == null)
{
logger.Log(LogLevel.Error, "File has not the correct format.");
yield break;
}
//var version = document.Root.Attribute(XmlVersionAttribute)?.Value;
var platform = document.Root.Attribute(XmlPlatformAttribute)?.Value;
if (platform != Constants.Platform)
{
logger.Log(LogLevel.Warning, $"The platform of the file ({platform}) doesn't match the program platform ({Constants.Platform}).");
}
foreach (var element in document.Root.Elements(XmlRecordElement))
{
var valueTypeStr = element.Attribute(XmlValueTypeAttribute)?.Value ?? string.Empty;
if (!Enum.TryParse <ScanValueType>(valueTypeStr, out var valueType))
{
logger?.Log(LogLevel.Warning, $"Unknown value type: {valueTypeStr}");
continue;
}
var description = element.Attribute(XmlDescriptionAttribute)?.Value ?? string.Empty;
var addressStr = element.Attribute(XmlAddressAttribute)?.Value ?? string.Empty;
var moduleName = element.Attribute(XmlModuleAttribute)?.Value ?? string.Empty;
long.TryParse(addressStr, NumberStyles.HexNumber, null, out var address);
var record = new MemoryRecord
{
Description = description,
AddressOrOffset = (IntPtr)address,
ValueType = valueType
};
if (!string.IsNullOrEmpty(moduleName))
{
record.ModuleName = moduleName;
}
if (valueType == ScanValueType.ArrayOfBytes || valueType == ScanValueType.String)
{
var lengthStr = element.Attribute(XmlValueLengthAttribute)?.Value ?? string.Empty;
int.TryParse(lengthStr, NumberStyles.Integer, null, out var valueLength);
record.ValueLength = Math.Max(1, valueLength);
if (valueType == ScanValueType.String)
{
switch (element.Attribute(XmlEncodingAttribute)?.Value ?? string.Empty)
{
default:
case "UTF8":
record.Encoding = Encoding.UTF8;
break;
case "UTF16":
record.Encoding = Encoding.Unicode;
break;
case "UTF32":
record.Encoding = Encoding.UTF32;
break;
}
}
}
yield return(record);
}
}
}
}
}
public void MemoryRecordTest4()
{
MemoryRecord record = new MemoryRecord(0, "0010100001001101", "284D", 2);
Assert.IsTrue(record.DA.Equals("01001101") && record.OP.Equals("00101") && record.XSI.Equals("000"));
}
public IEnumerable <MemoryRecord> Load(string filePath, ILogger logger)
{
using (var stream = File.OpenRead(filePath))
{
var document = XDocument.Load(stream);
if (document.Root != null)
{
var version = document.Root.Attribute(XmlVersionElement)?.Value;
if (string.Compare(version, Version26, StringComparison.Ordinal) >= 0)
{
var entries = document.Root.Element(XmlEntriesElement);
if (entries != null)
{
foreach (var entry in entries.Elements(XmlEntryElement))
{
var description = entry.Element(XmlDescriptionElement)?.Value.Trim() ?? string.Empty;
if (description == "\"No description\"")
{
description = string.Empty;
}
var variableTypeStr = entry.Element(XmlValueTypeElement)?.Value.Trim() ?? string.Empty;
var valueType = Parse(variableTypeStr, logger);
var record = new MemoryRecord
{
Description = description,
ValueType = valueType
};
var addressStr = entry.Element(XmlAddressElement)?.Value.Trim() ?? string.Empty;
var addressParts = addressStr.Split('+');
if (addressParts.Length == 2)
{
long.TryParse(addressParts[1], NumberStyles.HexNumber, null, out var value);
record.AddressOrOffset = (IntPtr)value;
record.ModuleName = addressParts[0].Trim();
}
else
{
long.TryParse(addressStr, NumberStyles.HexNumber, null, out var value);
record.AddressOrOffset = (IntPtr)value;
}
if (valueType == ScanValueType.ArrayOfBytes || valueType == ScanValueType.String)
{
var lengthStr = entry.Element(XmlLengthElement)?.Value ?? string.Empty;
int.TryParse(lengthStr, NumberStyles.Integer, null, out var valueLength);
record.ValueLength = Math.Max(1, valueLength);
if (valueType == ScanValueType.String)
{
var isUnicode = (entry.Element(XmlUnicodeElement)?.Value ?? string.Empty) == "1";
if (isUnicode)
{
record.Encoding = Encoding.Unicode;
}
else
{
record.Encoding = Encoding.UTF8;
}
}
}
yield return(record);
}
}
}
}
}
}
public IEnumerable <MemoryRecord> Load(string filePath, ILogger logger)
{
var document = XDocument.Load(filePath);
if (document.Root != null)
{
var version = document.Root.Element(XmlVersionElement)?.Value;
if (string.Compare(version, Version3, StringComparison.Ordinal) >= 0)
{
var entries = document.Root.Element(XmlEntriesElement);
if (entries != null)
{
foreach (var entry in entries.Elements(XmlItemElement))
{
var description = entry.Element(XmlDescriptionElement)?.Value.Trim() ?? string.Empty;
var valueTypeStr = entry.Element(XmlValueTypeElement)?.Attribute(XmlValueAttribute)?.Value.Trim() ?? string.Empty;
var addressStr = entry.Element(XmlAddressElement)?.Attribute(XmlValueAttribute)?.Value.Trim() ?? string.Empty;
var moduleName = entry.Element(XmlModuleNameElement)?.Value.Trim() ?? string.Empty;
long.TryParse(addressStr, NumberStyles.Number, null, out var value);
var valueType = Parse(valueTypeStr, logger);
var record = new MemoryRecord
{
AddressOrOffset = (IntPtr)value,
Description = description,
ValueType = valueType
};
if ((entry.Element(XmlIsRelativeElement)?.Attribute(XmlValueAttribute)?.Value.Trim() ?? string.Empty) == "1" && !string.IsNullOrEmpty(moduleName))
{
record.ModuleName = moduleName;
}
if (valueType == ScanValueType.ArrayOfBytes || valueType == ScanValueType.String)
{
var lengthStr = (entry.Element(XmlSizeElement)?.Attribute(XmlValueAttribute)?.Value.Trim() ?? string.Empty);
int.TryParse(lengthStr, NumberStyles.Integer, null, out var valueLength);
record.ValueLength = Math.Max(1, valueLength);
if (valueType == ScanValueType.String)
{
switch (valueTypeStr)
{
default:
case "8":
record.Encoding = Encoding.UTF8;
break;
case "9":
record.Encoding = Encoding.Unicode;
break;
}
}
}
yield return(record);
}
}
}
}
}
public void MemoryRecordTest3()
{
MemoryRecord record = new MemoryRecord(5, "0000000000000001", "0", 3);
Assert.IsTrue(record.isComplex && record.N.Equals("0000001"));
}
