public void InsertToMemory(EMemoryEvent eventType, Vector2 position, Vector2 direction, float remainTime = 1f, float matureTime = 0f, float shadeTime = 0f, float importance = 1f) { int id = (int)eventType; var mem = eventMemory[id]; MemoryEvent item = new MemoryEvent(); /// no unit/ unknown unit responsible for the event item.unit = null;/// otherwise insert new item item.hadUnit = false; /// spatial data item.exactPosition = position; item.direction = direction; /// time data item.remainedTime = new Timer(); item.remainedTime.Restart(); item.matureTime = matureTime; item.knowledgeTime = remainTime; item.shadeTime = shadeTime; item.importance = importance; mem.Add(item); /// list is not sorted anyEventAdded[id] = true; }
protected void EmitEvent(MemoryEvent eventOut, bool disableSaveContext = true, bool reuseContext = true, bool afterExecution = false) { if (Context != null && reuseContext) { // Reusando o contexto var eventContext = Context.GetEvent(); eventOut.InstanceId = Context.InstanceId; eventOut.Tag = eventContext.Tag; eventOut.Branch = eventContext.Branch; eventOut.Reprocess = eventContext.Reprocess; if (!afterExecution) { Context.Memory.Event.Name = eventOut.Name; Context.Memory.Event.Payload = eventOut.Payload; Context.GetEvent().SetPayload((IPayload)eventOut.Payload); Context.DisableSaveContext = disableSaveContext; var processMemoryService = (SDK.Services.ProcessMemory.IProcessMemoryService)SDK.Configuration.SDKConfiguration.ServiceProvider.GetService( typeof(SDK.Services.ProcessMemory.IProcessMemoryService)); processMemoryService.Commit(Context.UpdateMemory()); } } if (!afterExecution) { EventManagerService.Push(eventOut); } else { Context.EventsToSend.Add(eventOut); } }
void ReactToNoise(NoiseData data) { if (data.fraction && myUnit.fraction.GetAttitude(data.fraction) != AiFraction.EAttitude.EEnemy) { return; } Vector2 toNoise = (Vector2)transform.position - data.position; if (toNoise.sqrMagnitude > hearingDistance * hearingDistance || Random.value > reactionChance) { return; } MemoryEvent ev = new MemoryEvent(); ev.velocity = data.velocity * velocityPredictionScale; ev.forward = data.velocity; ev.exactPosition = data.position; ev.lifetimeTimer.Restart(); noiseStorage.PerceiveEvent(ev); #if UNITY_EDITOR Debug.DrawRay(ev.exactPosition, Vector3.up, Color.blue, 0.5f); #endif }
public void Update(BehaviourStateMachine stateMachine) { for (int i = 1; i <= memoryInterruptions.Count; ++i) { var it = memoryInterruptions[i - 1]; MemoryEvent ev = stateMachine.memory.SearchInMemory(it.eventType); if (ev != null && ev.GetState() == it.eventState) { //Debug.Log(i + "; " + it.eventType + "; " + it.eventState); stateMachine.target = ev; if (lastInterruptionType != i) { lastInterruptionType = i; stateMachine.SetCurrentBehaviour(it.entry); } return; } } { //Debug.Log("neutral"); stateMachine.target = null; if (lastInterruptionType != 0) { lastInterruptionType = 0; stateMachine.SetCurrentBehaviour(neutralEntry); } } }
new void Awake() { base.Awake(); //// initialize focus painStorage = RegisterSenseInBlackboard("painStorage"); var healthController = GetComponentInParent <HealthController>(); healthController.onDamageCallback += (data) => { if (!tPain.IsReadyRestart()) { return; } MemoryEvent ev = new MemoryEvent(); ev.exactPosition = data.position; ev.forward = data.direction; // we have no information about hit velocity; just assume it is stationary ev.velocity = Vector2.zero; ev.lifetimeTimer.Restart(); painStorage.PerceiveEvent(ev); Debug.DrawRay(ev.position, Vector3.up, Color.blue, 0.25f); }; }
void InsertEvent(MemoryEvent ev, AiFraction.EAttitude attitude) { switch (attitude) { case AiFraction.EAttitude.EEnemy: if (trackEnemy) { enemyStorage.PerceiveEvent(ev); } break; case AiFraction.EAttitude.EFriendly: if (trackAlly) { allyStorage.PerceiveEvent(ev); } break; case AiFraction.EAttitude.ENeutral: if (trackNeutrals) { neutralStorage.PerceiveEvent(ev); } break; } }
public Memory(MemoryEvent memEvent, Tuple3I tuple) : base( (int)memEvent, tuple, tuple, 0 ) { }
public Memory(MemoryEvent memEvent, float progress) : base( (int)memEvent, null, null, progress ) { }
protected void EmitEvent <T>(string eventName, T payload, bool disableSaveContext = true, bool reuseContext = true, bool afterExecution = false) where T : IPayload { var eventOut = new MemoryEvent() { Name = eventName, Payload = payload }; EmitEvent(eventOut, disableSaveContext, reuseContext, afterExecution); }
public override bool CanEnter(MemoryEvent target) { Character.State state = character.GetState(id); return /// can transition happen from current state? ((requireTransition || character.GetCurrentState().GetTransition(state) != null) && /// can enter atm? state.CanEnterSoft()); }
public MemEntry(uint StartAddress, uint EndAddress, byte[] ReadArray, byte[] WriteArray, string Name, MemoryEvent ReadEvent = null, MemoryEvent WriteEvent = null) { this.StartAddress = StartAddress; this.EndAddress = EndAddress; this.ReadArray = ReadArray; this.WriteArray = WriteArray; this.Name = Name; this.ReadEvent = ReadEvent; this.WriteEvent = WriteEvent; }
public bool CanEnter(MemoryEvent target) { foreach (var it in filters) { if (!it.CanEnter(target)) { return(false); } } return(true); }
public override bool CanEnter(MemoryEvent target) { if (target == null) { return(false); } var distSq = ((Vector2)transform.position - target.position).sqrMagnitude; return(distSq > maxDistance * maxDistance || distSq < minDistance * minDistance); }
public override bool CanEnter(MemoryEvent target) { if (!PatrolManager.instance) { Debug.LogWarning("No Patrol Manager on map"); return(false); } pretendingPath = PatrolManager.instance.GetRandomUnusedPath(transform.position - PatrolManager.instance.transform.position, maxPatrolPathDistance); return(pretendingPath != null); }
// Update is called once per frame void Update() { MemoryEvent ev = focus.lastEvent; ev.velocity = focus.lastEvent != null ? (Vector2)transform.position - focus.GetTargetPosition() : Vector2.zero; ev.exactPosition = target.position; ev.forward = transform.up; ev.lifetimeTimer = new MinimalTimer(); ev.lifetimeTimer.Restart(); }
private void OnCollisionEnter2D(Collision2D collision) { // omit too weak touches if (collision.relativeVelocity.sqrMagnitude < minimalRelativeVelocity * minimalRelativeVelocity) { return; } // only targets with perceive unit will report // mostly to allow to tune what is perceived AiPerceiveUnit otherUnit = collision.gameObject.GetComponent <AiPerceiveUnit>(); if (!otherUnit) { return; } // only report every given seconds if (!tTouch.IsReadyRestart()) { return; } var otherRigidbody = collision.rigidbody; var otherTransform = collision.transform; MemoryEvent ev = new MemoryEvent(); ev.exactPosition = otherTransform.position; ev.forward = otherTransform.up; ev.velocity = otherRigidbody ? otherRigidbody.velocity : Vector2.zero; ev.lifetimeTimer.Restart(); touchStorage.PerceiveEvent(ev); #if UNITY_EDITOR Debug.DrawRay(ev.exactPosition, Vector3.up, Color.blue); #endif }
public Memory(MemoryEvent memEvent, Tuple3I second, Tuple3I third, float fourth) : base((int)memEvent, second, third, fourth) { }
void PerformSearch() { AiFraction myFraction = myUnit.fraction; if (!myFraction) { #if UNITY_EDITOR Debug.LogWarning("No fraction in perceive unit but trying to use sight"); #endif // there's no way to determine where to put events return; } // perform cast int n = Physics2D.OverlapCircleNonAlloc(transform.position, searchDistance, StaticCacheLists.colliderCache, memorableMask); // preselect targets // they have to be in proper angle and contain PerceiveUnit for (int i = 0; i < n; ++i) { var it = StaticCacheLists.colliderCache[i]; Transform itTransform = it.transform; //// check if the target is in proper angle Vector2 toIt = itTransform.position - transform.position; float cosAngle = Vector2.Dot(toIt.normalized, transform.up); float angle = Mathf.Acos(cosAngle) * 180 / Mathf.PI; //Debug.Log(angle); bool bProperAngle = angle < coneAngle * 0.5f; if (!bProperAngle) { continue; } // ok, now check if it has AiPerceiveUnit // we need it's fraction to determine our attitude AiPerceiveUnit perceiveUnit = it.GetComponent <AiPerceiveUnit>(); if (perceiveUnit == myUnit) { // oh, come on do not look at yourself... don't be soo narcissistic continue; } if (!perceiveUnit) { // no perceive unit, this target is invisible to us continue; } AiFraction itFraction = perceiveUnit.fraction; if (!itFraction) { // the same as above, return; } //// determine attitude AiFraction.EAttitude attitude = myFraction.GetAttitude(itFraction); //// Check if obstacles blocks vision if (DoObstaclesBlockVision(itTransform.position)) { continue; } //// create event MemoryEvent ev = new MemoryEvent(); ev.exactPosition = itTransform.position; ev.forward = itTransform.up; // if collider has rigidbody then take its velocity // otherwise there is no simple way to determine event velocity ev.velocity = it.attachedRigidbody ? it.attachedRigidbody.velocity * velocityPredictionScale : Vector2.zero; // set up agent reponsible for this event ev.perceiveUnit = perceiveUnit; // ensure event will tick from now on ev.lifetimeTimer.Restart(); Debug.DrawRay(ev.exactPosition, Vector3.up, Color.blue, searchTime * nEvents); Debug.DrawRay(ev.exactPosition, ev.velocity * searchTime, Color.gray, searchTime); InsertEvent(ev, attitude); } }
public virtual bool CanEnter(MemoryEvent target) { return(true); }
public override bool CanEnter(MemoryEvent target) { float distSq = ((Vector2)transform.position - target.position).sqrMagnitude; return(distSq >= minDistance * minDistance && distSq <= maxDistance * maxDistance); }
public override bool CanEnter(MemoryEvent target) { return(blackboard.distanceAttractionAccumulator > min); }
/// auto compute direction of unit public bool InsertToMemory(AiPerceiveUnit unit, EMemoryEvent eventType, Vector2 position, float predictionScale, float remainTime = 1f, float matureTime = 0f, float shadeTime = 0f, float importance = 1f) { if (!unit.memoriable) { return(false); } int id = (int)eventType; var mem = eventMemory[id]; /// search if the unit is recorded in our memory /// if so then update it if (unit) { foreach (var itMemory in mem) { if (itMemory.unit == unit) { /// spatial data if (itMemory.remainedTime.ElapsedTime() > 3 * float.Epsilon) { itMemory.direction = (position - itMemory.exactPosition) * (predictionScale / itMemory.remainedTime.ElapsedTime()); /// auto compute direction } /// else keep last value... dunno what to do in case of such a small time step itMemory.exactPosition = position; /// time data itMemory.remainedTime.Restart(); itMemory.matureTime = 0f; /// list is not sorted anyEventAdded[id] = true; return(false); } } } /// otherwise insert new item MemoryEvent item = new MemoryEvent(); item.unit = unit; item.hadUnit = unit != null; /// spatial data item.exactPosition = position; item.direction = Vector2.zero; /// time data item.remainedTime = new Timer(); item.remainedTime.Restart(); item.matureTime = matureTime; item.knowledgeTime = remainTime; item.shadeTime = shadeTime; item.importance = importance; mem.Add(item); /// list is not sorted anyEventAdded[id] = true; return(true); }
public bool InsertToMemory(AiPerceiveUnit unit, EMemoryEvent eventType, Vector2 position, Vector2 direction, float remainTime = 1f, float matureTime = 0f, float shadeTime = 0f, float importance = 1f) { if (!unit.memoriable) { return(false); } int id = (int)eventType; var mem = eventMemory[id]; /// search if the unit is recorded in our memory /// if so then update it if (unit) { foreach (var itMemory in mem) { if (itMemory.unit == unit) { /// time data /// /// If information is mature - result should be mature too /// if (itMemory.remainedTime.IsReady(itMemory.matureTime)) { itMemory.matureTime = 0; itMemory.remainedTime.Restart(); } else { itMemory.matureTime = matureTime; } itMemory.knowledgeTime = remainTime; itMemory.shadeTime = shadeTime; /// spatial data itMemory.exactPosition = position; itMemory.direction = direction; itMemory.importance = importance; /// list is not sorted anyEventAdded[id] = true; return(false); } } } /// otherwise insert new item MemoryEvent item = new MemoryEvent(); item.unit = unit; item.hadUnit = unit != null; /// spatial data item.exactPosition = position; item.direction = direction; /// time data item.remainedTime = new Timer(); item.remainedTime.Restart(); item.matureTime = matureTime; item.knowledgeTime = remainTime; item.shadeTime = shadeTime; item.importance = importance; mem.Add(item); /// list is not sorted anyEventAdded[id] = true; return(true); }
private static void MemoryTargetOnEventReceived(LogEventInfo logEventInfo) { MemoryEvent?.Invoke(logEventInfo); }