public void NotRegisteredDerivedEntitySerializedAsBaseEntity()
{
var serializer = new SerializerConfig().Create();
var input = new EntityHolder
{
Entity = new DerivedEntity
{
Id = 111,
Discriminator = "DerivedEntity"
}
};
using (var stream = CreateStream())
{
serializer.Serialize(stream, input);
stream.Seek(0);
var result = serializer.Deserialize <EntityHolder>(stream);
Assert.NotNull(result);
Assert.NotNull(result.Entity);
Assert.IsType <Entity>(result.Entity);
Assert.Equal(111, result.Entity.Id);
}
}
public void ForgetPassword(EntityHolder <UserForgetPasswordDto> entityHolder)
{
var userFromDb = MainRepository.FindFirstOrDefault(x => x.Username == entityHolder.Entity.Username && x.Email == entityHolder.Entity.Email);
if (userFromDb != null)
{
userFromDb.ResetPasswordTokenValid = DateTime.Now.AddHours(1);
userFromDb.ResetPasswordToken = Guid.NewGuid().ToString("N").ToUpper();
MainRepository.Update(userFromDb);
MainRepository.Save();
Mail mail = new Mail
{
TemplateName = "forget-password.html",
MailTo = userFromDb.Email,
MailSubject = "Changing forgotten password",
Attributes = new Dictionary <string, object>
{
{ "username", userFromDb.Username },
{ "passwordChangeLink", $"http://{entityHolder.BaseUrl}/change-password/{userFromDb.ResetPasswordToken}" }
}
};
_emailService.SendEmail(mail);
}
else
{
throw new Exception("Provided username and e-mail do not match.");
}
}
public void CompareEntities(EntityHolder entityHolder, string previousVersion, string currentVersion)
{
Guard.WhenArgument(entityHolder, "Entity Holder").IsNull().Throw();
var entitiesFromPreviousVersion = this.entityExtracter
.ExtractEntitiesFromSitefinity(previousVersion)
.ToList();
var entitiesFromCurrentVersion = this.entityExtracter
.ExtractEntitiesFromSitefinity(currentVersion)
.ToList();
var addedEntities = entityHolder.AddedEntities;
var updatedEntities = entityHolder.UpdatedEntities;
var removedEntities = entityHolder.RemovedEntities;
foreach (var entity in entitiesFromPreviousVersion)
{
this.CheckIfEntityIsUpdatedOrRemoved(entity, entitiesFromCurrentVersion, updatedEntities, removedEntities);
}
foreach (var entity in entitiesFromCurrentVersion)
{
this.CheckIfEntityIsAdded(entity, entitiesFromPreviousVersion, addedEntities);
}
}
public void SetEntity(EntityHolder holder)
{
if (_entity != null)
{
_entity.SetEntity(holder._entity);
}
else
{
(_masters = _masters ?? new List <EntityHolder>()).Add(holder);
}
}
public void AddEntity(EntityHolder holder)
{
if (_entity != null)
{
_entity.AddEntity(holder._entity);
}
else
{
(_details = _details ?? new List <EntityHolder>()).Add(holder);
}
}
private void OnClick(EntityHolder entity)
{
if (entity)
{
castInfo.target = entity;
cardHolder.card.CheckForResolve();
}
else
{
cardHolder.player.cardSelection.CancelSelection();
}
}
public ActionResult ForgetPassword(EntityHolder <UserForgetPasswordDto> entityHolder)
{
try
{
_userService.ForgetPassword(entityHolder);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public static EntityHolder GetEntityHolder()
{
if (entityHolder == null)
{
entityHolder = new EntityHolder()
{
AddedEntities = new List <Entity>(),
UpdatedEntities = new List <Entity>(),
RemovedEntities = new List <Entity>()
};
}
return(entityHolder);
}
public Entity CreateFor(GameObject instance)
{
EntityConfig entityConfig = instance.GetComponent <EntityConfig>();
Entity entity = entityConfig.entity;
entity.gameobjectComponent.gameObject = instance;
entity.gameobjectComponent.gameObject.AddComponent <EntityHolder>();
EntityHolder entityHolder = entity.gameobjectComponent.gameObject.GetComponent <EntityHolder>();
entityHolder.entity = entity;
entity.LinkComponentToEntity();
world.AddEntity(entity);
//Debug.Log("EntitySystem.CreateFor, tag: " + entity.identity.tag);
return(entity);
}
protected void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
EntityHolder.Save();
}
if (Input.GetKeyDown(KeyCode.A))
{
PlayerPrefs.DeleteAll();
EntityHolder.Clear();
}
if (Input.GetKeyDown(KeyCode.L))
{
EntityHolder.Load();
}
}
protected void OnCollision(Collider2D other, Identity identity, BulletComponent bulletComponent, BoxCollider2D boxCollider2D, MoveComponent move)
{
EntityHolder entityHolder = other.gameObject.GetComponent <EntityHolder>();
if (entityHolder == null)
{
return;
}
Entity otherEntity = entityHolder.entity;
Identity otherIdentity = otherEntity.identity;
if (otherEntity == identity.master)
{
return;
}
if (otherIdentity.tag != "river")
{
move.needMove = false;
identity.isDead = true;
}
if (otherIdentity.tag == "brick" || otherIdentity.tag == "stone")
{
if (other.gameObject.tag == "brick")
{
world.entitySystem.DestroyEntity(otherEntity);
}
}
else if (otherEntity != identity.master && otherEntity.lifeComponent.enable == true)
{
world.lifeSystem.ChangeHP(otherEntity.lifeComponent, -bulletComponent.damage);
world.buffSystem.AddBuff(otherEntity, bulletComponent.buffName);
Debug.Log("bullet hit:" + otherIdentity.tag);
}
if (identity.isDead == true)
{
boxCollider2D.enabled = false; // disable collider to avoid mutiple times collision.
world.entitySystem.DestroyEntity(identity.entity);
world.effectSystem.CreateExplosion(bulletComponent.entity.gameobjectComponent.transform.position, "small");
}
}
public void Update(Identity identity, LaserComponent laser, GameobjectComponent gameobjectComponent)
{
if (laser == null || laser.enable == false)
{
return;
}
if (Time.time < laser.exisingTime)
{
laser.attackTimer += Time.deltaTime;
if (laser.attackTimer >= laser.attackInterval)
{
laser.attackTimer = 0;
Transform transform = gameobjectComponent.transform;
RaycastHit2D hit = Physics2D.Raycast(transform.position, transform.up);
Debug.DrawLine(transform.position, transform.up * 700);
if (hit.collider != null)
{
//Debug.DrawLine(transform.position, hit.point);
EntityHolder entityHolder = hit.collider.gameObject.GetComponent <EntityHolder>();
if (entityHolder == null)
{
return;
}
Entity hitEntity = entityHolder.entity;
if (hitEntity != identity.master)
{
Debug.Log("LaserSystem, camps:" + hitEntity.identity.camp.ToString() + identity.camp.ToString());
if (hitEntity.identity.camp != identity.camp && hitEntity.lifeComponent.enable == true)
{
world.lifeSystem.ChangeHP(hitEntity.lifeComponent, -laser.damage);
world.effectSystem.CreateExplosion(hit.point, "small");
}
}
}
}
}
else
{
world.entitySystem.DestroyEntity(identity.entity);
}
}
private static void ProccesParsedData(EntityHolder entityHolder)
{
List <DiagramFunction> allFunctions = entityHolder.Functions;
List <DiagramNode> allNodes = entityHolder.DiagramNodes;
List <DiagramLine> allLines = entityHolder.DiagramLines;
for (int itter = 0; itter < allFunctions.Count; itter++)
{
if (allFunctions[itter].FunctionName == "drawLine")
{
DiagramExecutor.CreateEdge(entityHolder.GetNodeByName(allFunctions[itter].ParametersNames[0]).Name,
entityHolder.GetNodeByName(allFunctions[itter].ParametersNames[1]).Name,
entityHolder.GetLineByName(allFunctions[itter].ParametersNames[2]));
}
else if (allFunctions[itter].FunctionName == "drawNode")
{
DiagramExecutor.CreateNode(entityHolder.GetNodeByName(allFunctions[itter].ParametersNames[0]));
}
}
}
static void Main(string [] args)
{
Lexer lexer = new Lexer();
char[] chars = File
.ReadAllText("D:\\Study\\Compilators\\TheoryOfCompilators\\Executer\\code.txt")
.ToCharArray();
lexer.FindLex(chars);
SyntaxParser syntaxParser = new SyntaxParser(lexer.AllLexes);
List <StatementToken> listOfStatement = new List <StatementToken>();
while (SyntaxParser._currentLex < lexer.AllLexes.Count)
{
listOfStatement.Add(new StatementToken().CreateToken());
}
SemanticAnalyzer.CheckDeclarationSemantic(listOfStatement);
DiagramExecutor.Setup();
ProccesParsedData(EntityHolder.GetInstance());
DiagramExecutor.ShowDiagram();
}
public Entity FindTarget()
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(selfTransform.position, visionRadius);
Entity otherEntity;
foreach (var collider in colliders)
{
EntityHolder entityHolder = collider.gameObject.GetComponent <EntityHolder>();
if (entityHolder == null)
{
return(null);
}
otherEntity = entityHolder.entity;
if (otherEntity.tankComponent.enable != false && otherEntity.identity.camp != entity.identity.camp)
{
return(otherEntity);
}
}
return(null);
}
public override void Update()
{
base.Update();
if (Input.GetButtonUp("Fire1"))
{
Ray mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
var hits = Physics.RaycastAll(mouseRay);
foreach (var hit in hits)
{
if (hit.transform.gameObject.GetComponentInParent <EntityHolder>())
{
holder = hit.transform.gameObject.GetComponentInParent <EntityHolder>();
OnClick.Invoke(holder);
RemoveEvent();
return;
}
}
OnClick.Invoke(null);
RemoveEvent();
}
}
public Entity NewEntity(GameObject prefab, Vector3 position)
{
Entity entity = new Entity();
entity.gameobjectComponent.SetGameObject(GameObject.Instantiate(prefab));
entity.gameobjectComponent.transform.position = position;
entity.gameobjectComponent.gameObject.AddComponent <EntityHolder>();
EntityHolder entityHolder = entity.gameobjectComponent.gameObject.GetComponent <EntityHolder>();
entityHolder.entity = entity;
world.AddEntity(entity);
ConvertToEntity convertToEntity = entity.gameobjectComponent.gameObject.GetComponent <ConvertToEntity>();
if (convertToEntity != null)
{
convertToEntity.convert = false;
}
Debug.Log("NewEntity");
return(entity);
}
public DamageInfo(EntityHolder who, EntityHolder to, int damage)
{
player = who;
target = to;
count = damage;
}
// Note that method is attached to EntityHolder, not a repository
public static Task <TEntity> FindBySelectorAsync <TRepository, TEntity, TSelector>(
this EntityHolder <TRepository, TEntity> repository, TSelector selector)
where TRepository : IReadableRepository <TEntity>, IListableRepository <TEntity>
where TEntity : class, ISearchableEntity <TSelector>
=> repository.Target.Entities.SingleOrDefaultAsync(x => x.Matches(selector));
protected void Start()
{
EntityHolder.Load();
}
private void Awake()
{
m_entity = GetComponent <EntityHolder>();
m_health = maxHealth;
}
public HealInfo(EntityHolder who, EntityHolder to, int heal)
{
player = who;
target = to;
count = heal;
}
