public void Two_entities_with_the_same_Id_should_equal_each_other() { var first = new Entity{Id = 99}; var second = new Entity { Id = 99 }; first.Equals(second).ShouldBeTrue(); second.Equals(first).ShouldBeTrue(); Equals(first, second).ShouldBeTrue(); Equals(second, first).ShouldBeTrue(); first.GetHashCode().ShouldEqual(second.GetHashCode()); (first == second).ShouldBeTrue(); (second == first).ShouldBeTrue(); (first != second).ShouldBeFalse(); (second != first).ShouldBeFalse(); }
public void Two_entities_with_different_Ids_should_not_equal_each_other() { var first = new Entity { Id = 66 }; var second = new Entity { Id = 77 }; first.Equals(second).ShouldBeFalse(); second.Equals(first).ShouldBeFalse(); Equals(first, second).ShouldBeFalse(); Equals(second, first).ShouldBeFalse(); first.GetHashCode().ShouldNotEqual(second.GetHashCode()); (first == second).ShouldBeFalse(); (second == first).ShouldBeFalse(); (first != second).ShouldBeTrue(); (second != first).ShouldBeTrue(); }
protected override void OnUpdate() { if (!SceneManager.GetActiveScene().name.Equals("Stranded")) { return; } if (agentTransformGO == null) { agentTransformGO = GameObject.Find("Player GO"); if (agentTransformGO == null) { return; } } if (cursor == null) { cursor = GameObject.Find("3D Cursor"); if (cursor == null) { return; } } if (cursorRenderer == null) { var cursorMesh = cursor.transform.GetChild(0); if (cursorMesh == null) { return; } cursorRenderer = cursorMesh.GetComponent <Renderer>(); if (cursorRenderer == null) { return; } cursorRenderer.enabled = false; } var keyboard = Keyboard.current; if (keyboard == null) { return; } try { playerEntity = GetSingletonEntity <Player>(); } catch { return; } if (playerEntity.Equals(Entity.Null)) { return; } var agentPosition = EntityManager.GetComponentData <LocalToWorld>(playerEntity).Position; agentTransformGO.transform.SetPositionAndRotation(agentPosition, Quaternion.identity); var mouse = Mouse.current; var point = new Vector3( mouse.position.x.ReadValue(), mouse.position.y.ReadValue() ); var pointOnNavigableSurface = NavUtil.GetPointOnNavigableSurface( point, playerEntity, Camera.main, physicsWorld, 500, EntityManager, filter, out var hit ); if (pointOnNavigableSurface) { cursorRenderer.enabled = true; var cursorPosition = hit.Position; cursorPosition.y += 1; cursor.transform.position = cursorPosition; cursor.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.SurfaceNormal); if (mouse != null && mouse.leftButton.isPressed) { EntityManager.AddComponentData(playerEntity, new NavDestination { WorldPoint = hit.Position, Tolerance = 1 }); } } else { cursorRenderer.enabled = false; } }
public bool Equals(HalfEdgeEntity other) { return(HalfEdge.Equals(other.HalfEdge) && Entity.Equals(other.Entity)); }
public Entity FindGraphicsEntityFromPhysics(Entity bodyEntity, ColliderKey leafColliderKey) { if (bodyEntity.Equals(Entity.Null)) { // No Physics so no Graphics return(Entity.Null); } // Set the Graphics Entity to the supplied Physics Entity var renderEntity = bodyEntity; // Check if we have hit a leaf node if (!leafColliderKey.Equals(ColliderKey.Empty)) { // Get the Physics Collider var rootCollider = EntityManager.GetComponentData <PhysicsCollider>(bodyEntity).Value; // If we hit a CompoundCollider we need to find the original Entity associated // the actual leaf Collider that was hit. if (rootCollider.Value.Type == ColliderType.Compound) { #region Find a Leaf Entity and ColliderKey var leafEntity = Entity.Null; unsafe { var rootColliderPtr = rootCollider.AsPtr(); // Get the leaf Collider and check if we hit was a PolygonCollider (i.e. a Triangle or a Quad) rootColliderPtr->GetLeaf(leafColliderKey, out var childCollider); leafEntity = childCollider.Entity; // PolygonColliders are likely to not have an original Entity associated with them // So if we have a Polygon and it has no Entity then we really need to check for // the higher level Mesh or Terrain Collider instead. var childColliderType = childCollider.Collider->Type; var childColliderIsPolygon = childColliderType == ColliderType.Triangle || childColliderType == ColliderType.Quad; if (childColliderIsPolygon && childCollider.Entity.Equals(Entity.Null)) { // Get the ColliderKey of the Polygon's parent if (TryGetParentColliderKey(rootColliderPtr, leafColliderKey, out leafColliderKey)) { // Get the Mesh or Terrain Collider of the Polygon TryGetChildInHierarchy(rootColliderPtr, leafColliderKey, out childCollider); leafEntity = childCollider.Entity; } } } #endregion // The Entities recorded in the leaves of a CompoundCollider may have been correct // at the time of conversion. However, if the Collider blob is shared, or came up // through a sub scene, we cannot assume that the baked Entities in the // CompoundCollider are still valid. // On conversion Entities using a CompoundCollider have an extra dynamic buffer added // which holds a list of Entity/ColliderKey pairs. This buffer should be patched up // automatically and be valid with each instance, at least until you start messing // with the Entity hierarchy yourself e.g. by deleting Entities. #region Check the Leaf Entity is valid // If the leafEntity was never assigned in the first place // there is no point in looking up any Buffers. if (!leafEntity.Equals(Entity.Null)) { // Check for an Key/Entity pair buffer first. // This should exist if the Physics conversion pipeline was invoked. var colliderKeyEntityPairBuffers = GetBufferFromEntity <PhysicsColliderKeyEntityPair>(true); if (colliderKeyEntityPairBuffers.HasComponent(bodyEntity)) { var colliderKeyEntityBuffer = colliderKeyEntityPairBuffers[bodyEntity]; // TODO: Faster lookup option? for (int i = 0; i < colliderKeyEntityBuffer.Length; i++) { var bufferColliderKey = colliderKeyEntityBuffer[i].Key; if (leafColliderKey.Equals(bufferColliderKey)) { renderEntity = colliderKeyEntityBuffer[i].Entity; break; } } } else { // We haven't found a Key/Entity pair buffer so the compound collider // may have been created in code. // We'll assume the Entity in the CompoundCollider is valid renderEntity = leafEntity; // If this CompoundCollider was instanced from a prefab then the entities // in the compound children would actually reference the original prefab hierarchy. var rootEntityFromLeaf = leafEntity; while (HasComponent <Parent>(rootEntityFromLeaf)) { rootEntityFromLeaf = GetComponent <Parent>(rootEntityFromLeaf).Value; } // If the root Entity found from the leaf does not match the body Entity // then we have hit an instance using the same CompoundCollider. // This means we can try and remap the leaf Entity to the new hierarchy. if (!rootEntityFromLeaf.Equals(bodyEntity)) { // This assumes there is a LinkedEntityGroup Buffer on original and instance Entity. // No doubt there is a more optimal way of doing this remap with more specific // knowledge of the final application. var linkedEntityGroupBuffers = GetBufferFromEntity <LinkedEntityGroup>(true); // Only remap if the buffers exist, have been created and are of equal length. bool hasBufferRootEntity = linkedEntityGroupBuffers.HasComponent(rootEntityFromLeaf); bool hasBufferBodyEntity = linkedEntityGroupBuffers.HasComponent(bodyEntity); if (hasBufferRootEntity && hasBufferBodyEntity) { var prefabEntityGroupBuffer = linkedEntityGroupBuffers[rootEntityFromLeaf]; var instanceEntityGroupBuffer = linkedEntityGroupBuffers[bodyEntity]; if (prefabEntityGroupBuffer.IsCreated && instanceEntityGroupBuffer.IsCreated && (prefabEntityGroupBuffer.Length == instanceEntityGroupBuffer.Length)) { var prefabEntityGroup = prefabEntityGroupBuffer.AsNativeArray(); var instanceEntityGroup = instanceEntityGroupBuffer.AsNativeArray(); for (int i = 0; i < prefabEntityGroup.Length; i++) { // If we've found the renderEntity index in the prefab hierarchy, // set the renderEntity to the equivalent Entity in the instance if (prefabEntityGroup[i].Value.Equals(renderEntity)) { renderEntity = instanceEntityGroup[i].Value; break; } } } } } } } #endregion } } // Finally check to see if we have a graphics redirection on the shape Entity. if (HasComponent <PhysicsRenderEntity>(renderEntity)) { renderEntity = GetComponent <PhysicsRenderEntity>(renderEntity).Entity; } return(renderEntity); }
public void EntityEqualsObject(Entity entity, object obj, bool expected) { var areEqual = entity.Equals(obj); Assert.Equal(expected, areEqual); }
public override bool CanSkip(Entity targetEntity) => targetEntity.Equals(base.ownerEntity) || targetEntity.IsSameGroup <TeamGroupComponent>(base.ownerEntity);
public void OnObjectMouseDown(Object o) { Entity currentEntity = entities[currentEntityTurn]; if (currentEntity.Equals(o)) { NextTurn(); } else if (currentEntity.CompareTag("Player")) { if (currentAction == 0) { if (!currentEntity.CanMoveTo(o.Vector2Position)) { Vector2 rotateTo = (o.Vector2Position - currentEntity.Vector2Position).normalized; if (currentEntity.CanRotateTo(rotateTo)) { currentEntity.RotateTo(rotateTo); if (currentEntity is Adventurer) { adventurerMovedOnTurn = true; } } } else { if (o.CompareTag("Walkable")) { if (currentEntity.CanMoveTo(o.Vector2Position)) { currentEntity.MoveTo(o.Vector2Position); if (currentEntity is Adventurer) { adventurerMovedOnTurn = true; } } else { Vector2 rotateTo = (o.Vector2Position - currentEntity.Vector2Position).normalized; if (currentEntity.CanRotateTo(rotateTo)) { currentEntity.RotateTo(rotateTo); if (currentEntity is Adventurer) { adventurerMovedOnTurn = true; } } } } } } else { if (o is Entity) { if (currentEntity.CanAttack(o.Vector2Position)) { Entity enemy = o.GetComponent <Entity>(); currentEntity.Attack(enemy); if (currentEntity is Guardian) { enemy.KnockBack(currentEntity.facingDirection); } } } } } }
public void Should_consider_as_equal_same_Entity_instance() { Entity.Equals(Entity).Should().BeTrue(); }
public void Should_consider_as_equal_same_instance_of_a_casted_entity() { Entity.Equals(Entity.ActLike <IProduct>()).Should().BeTrue(); }
public bool Equals(BackFaceCandidate other) { return(HalfEdge.Equals(other.HalfEdge)); }
protected override void OnUpdate() { if (Camera.main.transform.parent == null) { Camera.main.transform.SetParent(agentTransformGameObject.transform); } if (teleportationText == null) { teleportationText = GameObject.Find("Text").GetComponent <Text>(); } var keyboard = Keyboard.current; if (keyboard == null) { return; } if (keyboard.tKey.wasPressedThisFrame) { teleport = !teleport; if (teleport) { teleportationText.text = "Press <b>T</b> to toggle teleportation. It's <b>on</b>."; } else { teleportationText.text = "Press <b>T</b> to toggle teleportation. It's <b>off</b>."; } } try { entity = GetSingletonEntity <NavAgent>(); } catch { return; } if (entity.Equals(Entity.Null)) { return; } var agentPosition = EntityManager.GetComponentData <LocalToWorld>(entity).Position; agentTransformGameObject.transform.SetPositionAndRotation(agentPosition, Quaternion.identity); Camera.main.transform.LookAt(agentTransformGameObject.transform, Vector3.up); var mouse = Mouse.current; if ( mouse == null || !mouse.leftButton.wasPressedThisFrame || !Physics.Raycast(Camera.main.ScreenPointToRay(new Vector2(mouse.position.x.ReadValue(), mouse.position.y.ReadValue())), out RaycastHit hit) ) { return; } EntityManager.AddComponentData(entity, new NavDestination { WorldPoint = hit.point, Teleport = teleport }); }
/// <summary> /// Restores the given entity and recursively its dependencies. /// </summary> /// <param name="entityName">The name of the given entity.</param> /// <param name="entityPrimaryKeyValues">The primary key values of the entity.</param> /// <param name="path">The storage path.</param> private void InnerLoadEntity(string entityName, List <string> entityPrimaryKeyValues, string path, bool useLock) { // Check if entity is locked, if not, lock it. bool locked = false; if (useLock) { if (IsLocked(entityName)) { logger.LogInfo("Unable to visit " + entityName + ". It's locked."); return; } lockedEntities.Push(entityName); locked = true; logger.LogInfo(entityName + " is now locked."); } // Get the structure of the entity. EntityStructure entityStructure = entityStructures.Find(entityName); CheckPrimaryKeyCountsAreEqual(entityPrimaryKeyValues, entityStructure); // Return, if the current entity has already been updated in this batch. if (IsVisited(entityName, entityPrimaryKeyValues)) { logger.LogIsVisited(entityName, entityPrimaryKeyValues); // If the entity was visited, unlock the entity and return. if (useLock && locked) { logger.LogInfo(entityName + " is now unlocked."); lockedEntities.Pop(); } return; } // Get the searched entity from the database and from the serialized storage. Entity entityFromDb = dbClient.GetEntity(entityStructure, entityPrimaryKeyValues); Entity entityFromSerializedStorage = serializedStorageClient.GetEntity(entityStructure, entityPrimaryKeyValues, path); try { visitedEntities.Add(new EntityWithKey(entityName, entityPrimaryKeyValues)); logger.LogVisited(entityName, entityPrimaryKeyValues); // Create the list of dependencies and restore each dependency recursively. var dependencies = GetDependenciesAndKeys(entityFromSerializedStorage, entityStructure); logger.LogDependencies(dependencies); logger.LogInfo("Loading dependencies."); foreach (var dependency in dependencies) { InnerLoadEntity(dependency.Key, dependency.Value, path, useLock); } // Restore the current entity. // If the entity exists in the database, check if it's equal to the serialized entity. logger.LogInfo("Loading current entity."); if (entityFromDb != null) { // If the entity from the database is not equal to the serialized entity, restore the serialized entity // in the database. if (!entityFromSerializedStorage.Equals(entityFromDb)) { dbClient.UpdateWithTransaction(entityFromSerializedStorage, entityStructure); } } else { // The entity is missing, insert it into the database. dbClient.InsertWithTransaction(entityFromSerializedStorage, entityStructure); } // Restore the associative entities if the current entity is part of a many-to-many (associative) entity. logger.LogInfo("Loading associative entities."); LoadAssociativeEntities(entityFromSerializedStorage, entityStructure, path, useLock); // Unlock the entity. if (useLock) { string entityPop = lockedEntities.Pop(); logger.LogInfo(entityName + " is now unlocked."); if (!entityName.Equals(entityPop)) { throw new TdsLogicException("Entity unlock error."); } } } catch (Exception exception) { throw exception; } }
public override bool Equals(Category other) { if (!base.Equals(other)) { return(false); } AlgebraicStructureCategory asc = other as AlgebraicStructureCategory; if (asc == null) { return(false); } return(_structure.Equals(asc._structure) && _additiveEntity.Equals(asc._additiveEntity) && _multiplicativeEntity.Equals(asc._multiplicativeEntity)); }
public bool Equals(BulletSpawnerEntity other) { return(BulletPrefab.Equals(other.BulletPrefab) && Equals(SmokePrefab, other.SmokePrefab)); }
public bool VerifyPrediction(ref PlatePredictedState state) { return(Product.Equals(state.Product) && IsGenProduct.Equals(state.IsGenProduct)); }
public void EqualsDbNull() { Entity entity = new Entity(NAME); Assert.IsFalse(entity.Equals(DBNull.Value)); }
public bool Equals(ObstacleReference other) => Value.Equals(other.Value);
public bool Equals(Path other) { return(From.Equals(other.From) && To.Equals(other.To)); }
public void Should_consider_as_equal_entities_with_same_Iri() { Entity.Equals(new Entity(Iri, Context.Object)).Should().BeTrue(); }
public void ReturnsTrueForSameEntities() { Entity target = EmptyEntity(); Assert.True(target.Equals(target)); }
public void Should_consider_as_equal_different_entities_with_same_Iri() { Entity.Equals(AnotherEntity.Object).Should().BeTrue(); }
public bool DiffersFrom(ConsolidationEntry entry) { return (!Entity.Equals(entry.Entity, StringComparison.OrdinalIgnoreCase) || !Column.Equals(entry.Column, StringComparison.OrdinalIgnoreCase)); }
public virtual bool CanSkip(Entity targetEntity) => this.ExcludeSelf && targetEntity.Equals(this.ownerEntity);
public bool Equals(HalfEdgeVertices other) { return(Prev.Equals(other.Prev) && Next.Equals(other.Next)); }
public bool Equals(CollisionTriggerData other) { return(Other.Equals(other.Other)); }
public bool Equals(NavmeshObstacleComponent other) => Navmesh.Equals(other.Navmesh);
// --→ Function: Get Midas Owner Name private static string GetOwnerName(Entity owner) { return(owner.Equals(mHero) ? owner.Name.Replace("npc_dota_hero_", "") : "spirit_bear"); }
void OnTriggerEnter2D(Collider2D other) { // If weapon isn't being used by an entity, it shouldn't do anything if (owner == null) { return; } // If interactive tile if (((1 << other.gameObject.layer) & LayerMask.GetMask(new string[] { "InteractiveBlock", "InteractivePass" })) > 0) { Tile tile = other.GetComponentInParent <Tile> (); if (tile != null && tile.CanUseItem(this)) { GetEntity().TriggerItemUse(tile); } } // If collided with opponent's hitbox (weapon) if (other.gameObject.tag.Equals("Hitbox")) { Weapon otherW = other.GetComponent <Weapon> (); if (IsAttacking() && !otherW.IsAttacking()) { Entity entity = GetEntity(); if (otherW.CanDamage(entity)) { otherW.DealDamage(entity); //entity.Damage (otherW.DamageToInflict ()); otherW.AddToDamaged(entity); //print ("Damaging: " + entity.name); } } else if (!IsAttacking() && otherW.IsAttacking()) { Entity enemy = otherW.GetEntity(); if (!targetsHit.Contains(enemy)) { DealDamage(enemy); //enemy.Damage (DamageToInflict ()); targetsHit.Add(enemy); //print ("Damaging: " + enemy.name); } } else if (!otherW.IsBlocking()) { TradeBlows(otherW); } } else if (other.gameObject.tag.Equals("Character")) { // If collided with opponent if (IsAttacking()) { Entity enemy = other.GetComponentInParent <Entity>(); // Don't hurt ourselves if (enemy.Equals(GetEntity())) { return; } if (!CanDamage(enemy)) { return; } if (!enemy.InAttack() || enemy.IsIdleAttack()) { // Enemy but they are in lingering attack state, so still hit them DealDamage(enemy); AddToDamaged(enemy); } } } }
protected bool Equals(GeoPoint other) { return(base.Equals(other) && Entity.Equals(other.Entity)); }
public bool Equals(EntityConversionData other) { return(PrimaryEntity.Equals(other.PrimaryEntity) && Equals(AdditionalEntities, other.AdditionalEntities) && Equals(EntityManager, other.EntityManager)); }
/// <summary> /// Draw a specified entity /// </summary> /// <param name="e">The entity to draw</param> private void DrawEntity(Entity e) { if (!e.IsOnScreen || e.IsOccluded) return; var textScale = .25f; //Set text color var c = Color.FromArgb(150, Color.White); if (_selectedEntity != null && e.Equals(_selectedEntity)) c = Color.Red; else { switch (GTAFuncs.GetEntityType(e)) { case GTAFuncs.EntityType.Ped: c = new Ped(e.Handle).IsPlayer ? Color.FromArgb(150, Color.CornflowerBlue) : Color.FromArgb(150, Color.Yellow); break; case GTAFuncs.EntityType.Vehicle: c = Color.FromArgb(150, Color.DeepPink); break; case GTAFuncs.EntityType.Prop: c = Color.FromArgb(150, Color.Green); break; } } //Create entity info lines var lines = new List<string>(); switch(GTAFuncs.GetEntityType(e)) { case GTAFuncs.EntityType.Ped: Ped ped = new Ped(e.Handle); if (ped.IsPlayer) { Player pl = GTAFuncs.GetPedPlayer(ped); lines.Add(pl.Name); lines.Add("Player #" + pl.Handle); if (GTAFuncs.GetPlayerInvincible(pl)) lines.Add("INVINCIBLE"); } lines.Add("Ped #" + ped.Handle); e = ped; break; case GTAFuncs.EntityType.Vehicle: Vehicle v = new Vehicle(e.Handle); lines.Add("Vehicle #" + v.Handle); lines.Add(v.FriendlyName); lines.Add(v.DisplayName); e = v; break; case GTAFuncs.EntityType.Prop: Prop prop = new Prop(e.Handle); lines.Add("Prop #" + prop.Handle); lines.Add("Model: " + prop.Model.Hash); e = prop; break; default: lines.Add("Entity #" + e.Handle); break; } Entities.Add(e.Handle, e); //Draw entity info var screenPos = GTAFuncs.WorldToScreen(e.Position); var contain = new Rectangle( new Point((int) screenPos.X, (int)screenPos.Y + (GTAFuncs.GetEntityType(e) == GTAFuncs.EntityType.Ped && new Ped(e.Handle).IsInVehicle() ? lines.Count * -10 : 0)), new Size(50, (lines.Count*11) - 1)); for (var i = 0; i < lines.Count; i++) { GTAFuncs.SetTextDropShadow(2, Color.FromArgb(255, 0, 0, 0)); new UIText(lines[i], new Point(0, (i*10)), textScale, Color.FromArgb(255, c), 0, true).Draw( new Size(contain.Location)); GTAFuncs.SetTextDropShadow(0, Color.Transparent); } EntityClickBoxes.Add(e, contain); DrawEntBox(e, c); }
public bool IsEntity(string entity) { return(Entity.Equals(entity, StringComparison.InvariantCultureIgnoreCase)); }