public async Task <AnimalEntity> InsertAsync(string name)
{
var entity = new AnimalEntity(name);
await _collection.InsertAsync(entity);
return(entity);
}
public IActionResult CreateAnimal([FromBody] AnimalEntity animal)
{
if (animal == null)
{
return(BadRequest());
}
_animalService.CreateAnimal(animal);
return(Ok(animal));
}
/// <summary>
/// 回收动物
/// </summary>
/// <param name="entity"></param>
public static void AddToCollectList(AnimalEntity entity)
{
if (recycleObj == null)
{
recycleObj = new GameObject("Recycle");
}
entity.gameObject.SetActive(false);
entity.Clear();
entity.transform.parent = recycleObj.transform;
m_collectAnimalList.Add(entity.gameObject);
}
public void UseAnimal(AnimalEntity entity, int index)
{
for (int i = 0; i < WaitAnimals.Count; i++)
{
if (WaitAnimals[i] == entity)
{
WaitAnimals.RemoveAt(i);
break;
}
}
m_roads[index].OnRoad(entity);
UpdateSeatInfo();
}
public static AnimalDto AsDto(this AnimalEntity entity)
{
return(new AnimalDto
{
Id = entity.Id,
Avatar = entity.Avatar,
Name = entity.Name,
Type = entity.Type,
Weight = entity.Weight,
AreaId = entity.AreaId,
AreaType = entity.AreaType,
CageNo = entity.CageNo
});
}
public void Update(int id, Animal animal)
{
var connectionString = RuntimeConfiguration.GetConnectionString("AnimalContext");
using var adapter = new DataAccessAdapter(connectionString);
var entity = new AnimalEntity {
Id = id
};
adapter.FetchEntity(entity);
entity.Type = (int)animal.Type;
entity.Name = animal.Name;
adapter.SaveEntity(entity);
}
public void EditAnimal(AnimalEntity animal)
{
using (var sqlConnection = new SqlConnection(_connectionString))
{
var query = "UPDATE Animal SET Name = @Name, AnimalInfo = @AnimalInfo, ImageUrl = @ImageUrl WHERE ID_Animal =" + animal.Id;
var command = new SqlCommand(query, sqlConnection);
command.Parameters.AddWithValue("@Name", animal.Name);
command.Parameters.AddWithValue("@AnimalInfo", animal.Text);
command.Parameters.AddWithValue("@ImageUrl", animal.ImageUrl);
sqlConnection.Open();
command.ExecuteNonQuery();
}
}
// Try and find a another animal of the same breed in x range and make ....love.... i guess xD
public void Breed(int range)
{
Vector2Int mapSize = Environment.instance.mMapGenerationPayload.size;
// Calculate the mins and maxes for the possible touching tile coordinates
int xMin = CurrentPosition.PositionTile.x - range < 0 ? 0 : CurrentPosition.PositionTile.x - range;
int yMin = CurrentPosition.PositionTile.y - range < 0 ? 0 : CurrentPosition.PositionTile.y - range;
int xMax = CurrentPosition.PositionTile.x + range < mapSize.x ? CurrentPosition.PositionTile.x + range : mapSize.x - 1;
int yMax = CurrentPosition.PositionTile.y + range < mapSize.y ? CurrentPosition.PositionTile.y + range : mapSize.y - 1;
List <AnimalEntity> animalsInRange = new List <AnimalEntity>();
foreach (AnimalEntity entity in Environment.instance.GetEntities())
{
EnvironmentTile entityTile = entity.CurrentPosition;
if (entity != this && entity.entityName == this.entityName &&
entityTile.PositionTile.x >= xMin && entityTile.PositionTile.x <= xMax &&
entityTile.PositionTile.y >= yMin && entityTile.PositionTile.y <= yMax)
{
animalsInRange.Add(entity);
}
}
if (animalsInRange.Count > 0)
{
AnimalEntity entity = animalsInRange[Random.Range(0, animalsInRange.Count)];
List <EnvironmentTile> route = Environment.instance.SolveNeighbour(CurrentPosition, entity.CurrentPosition);
// If the animal is already there, break
if (route == null)
{
mPreformingAction = false;
return;
}
if (route.Count > 0)
{
StopAllCoroutines();
StartCoroutine(DoWalkAndBreed(route, entity.CurrentPosition, entity));
}
else
{
mPreformingAction = false;
return;
}
m_breedingTimerDelta = 0.0f;
}
mPreformingAction = false;
}
public static float BlockDamage(INetObject damager, float damage, AnimalEntity entity)
{
// turtle power! (or uhh tortoise power!)
if (entity.State == AnimalState.Hiding)
{
damage /= 4;
// TODO: sound effect of arrow bouncing off
if (damager is Player damagerPlayer)
{
damagerPlayer.MsgLoc($"{entity.Species.Name}: Arrow bounced off my shell!");
}
}
return(damage);
}
public IActionResult UpdateAnimal(long id, [FromBody] AnimalEntity animal)
{
if (animal == null)
{
return(BadRequest());
}
var updatedAnimal = _animalService.getAnimal(id);
if (updatedAnimal == null)
{
return(NotFound());
}
_animalService.UpdateAnimal(animal);
return(Ok(animal));
}
public void OnRoad(AnimalEntity animal)
{
animal.Index = RoadIndex;
float zPos = TopMarkPos;
float xPos = transform.localPosition.x;
if (animal.AttackDir == AttackDirection.Bottom)
{
t2bSide.AddAnimal(animal);
}
else
{
b2tSide.AddAnimal(animal);
zPos = BottomMarkPos;
}
animal.transform.parent = null;
animal.OnToRoad(xPos, zPos);
}
public async Task <int> Handle(CreateAnimalCommand request, CancellationToken cancellationToken)
{
var entity = new AnimalEntity
{
Nombre = request.Nombre,
Raza = request.Raza,
Edad = request.Edad,
Genero = request.Genero,
Comida = request.Comida
};
entity.DomainEvents.Add(new AnimalCreatedEvent(entity));
_context.Animals.Add(entity);
await _context.SaveChangesAsync(cancellationToken);
return(entity.Id);
}
// Walk to the partners tile and breform the breed action
private IEnumerator DoWalkAndBreed(List <EnvironmentTile> route, EnvironmentTile tile, AnimalEntity partner)
{
yield return(TileActionWalk.DoGoTo(this, GetMovmentSpeed(), route));
partner.ResetBreedingTimer();
partner.breedHeartEffect.Play();
breedHeartEffect.Play();
// Create new animal
{
AnimalEntity ent = GameObject.Instantiate(this, Environment.instance.transform);
Environment.instance.RegisterEntity(ent);
ent.ResetBreedingTimer();
ent.transform.position = tile.Position;
ent.transform.rotation = Quaternion.identity;
ent.CurrentPosition = tile;
}
mPreformingAction = false;
}
public void UpdateAnimal(AnimalEntity animal)
{
var updatedAnimal = _entityContext.Animals.FirstOrDefault(x => x.Id == animal.Id);
if (updatedAnimal != null)
{
updatedAnimal.Name = animal.Name;
updatedAnimal.Sex = animal.Sex;
updatedAnimal.Race = animal.Race;
updatedAnimal.RaceType = animal.RaceType;
updatedAnimal.BirthDate = animal.BirthDate;
updatedAnimal.AdmissionDate = animal.AdmissionDate;
updatedAnimal.Weight = animal.Weight;
updatedAnimal.Width = animal.Width;
updatedAnimal.Height = animal.Height;
updatedAnimal.Length = animal.Length;
updatedAnimal.Description = animal.Description;
updatedAnimal.Classification = animal.Classification;
}
_entityContext.Animals.Update(updatedAnimal);
_entityContext.SaveChanges();
}
public bool TrySetToRoad(AnimalEntity entity)
{
if (entity == null)
{
return(false);
}
for (int i = 0; i < RoadList.Count; i++)
{
if (RoadList[i].TryOnRoad(entity.transform.position, entity.AttackDir))
{
if (entity.AttackDir == HumanPlayer.AttackDir)
{
HumanPlayer.UseAnimal(entity, i);
}
else
{
ComputerPlayer.UseAnimal(entity, i);
}
return(true);
}
}
entity.SetState(AnimalState.Wait);
return(false);
}
public void AddAnimal(AnimalEntity animal)
{
if (animal != null)
{
using (var sqlConnection = new SqlConnection(_connectionString))
{
var awardCheck = "SELECT * FROM Animal WHERE Name ='" + animal.Name + "'";
var checkCommand = new SqlCommand(awardCheck, sqlConnection);
var query = "INSERT INTO Animal(Name, AnimalInfo, ImageUrl) Values(@Name, @AnimalInfo, @ImageUrl)";
var command = new SqlCommand(query, sqlConnection);
command.Parameters.AddWithValue("@Name", animal.Name);
command.Parameters.AddWithValue("@AnimalInfo", animal.Text);
command.Parameters.AddWithValue("@ImageUrl", animal.ImageUrl);
sqlConnection.Open();
if (checkCommand.ExecuteScalar() == null)
{
command.ExecuteNonQuery();
}
}
}
}
public void EditAnimal(AnimalEntity animal)
{
_animalDAO.EditAnimal(animal);
}
public void AddAnimal(AnimalEntity animal)
{
_animalDAO.AddAnimal(animal);
}
public void AddAnimal(AnimalEntity animal)
{
_animalLogic.AddAnimal(animal);
}
//先更新移动再更新状态
public void UpdateState(AnimalEntity diffSideFirstAnim, float roadLength, float otherPower)
{
for (int i = 0; i < SideAnimals.Count; i++)
{
//如果第一个动物未连接，则判断第一个动物和反向动物第一个碰头的时候设置为链接状态
if (i == 0 && SideAnimals[0].CurState != AnimalState.Connect)
{
bool canConnect = false;
if (diffSideFirstAnim != null)
{
canConnect = CanDiffSideConnect(diffSideFirstAnim, SideAnimals[0], roadLength);
}
//如果链接起来则设置此方向的力度
if (canConnect)
{
SidePower += SideAnimals[0].Power;
SideAnimals[0].SetState(AnimalState.Connect);
}
}
else
{
//如果对面没动物了 要把所有设置为非链接状态并且方向力清零
if (diffSideFirstAnim == null)
{
if (SideAnimals[i].CurState == AnimalState.Connect)
{
SideAnimals[i].SetState(AnimalState.Run);
}
SidePower = 0;
}
//如果为链接状态则按照链接状态移动
if (SideAnimals[i].CurState == AnimalState.Run)
{//非链接状态判断是否需要链接 和前面一个动物的距离差值是否为前一动物的身长 是则链接 否则则按照非链接状态移动
bool canConnect = false;
if (i > 0 && SideAnimals[0].CurState == AnimalState.Connect)
{
canConnect = CanSameSideConnect(SideAnimals[i - 1], SideAnimals[i]);
}
//如果链接起来方向力度增加
if (canConnect)
{
SidePower += SideAnimals[i].Power;
SideAnimals[i].SetState(AnimalState.Connect);
}
}
}
}
if (SideAnimals.Count > 0)
{
//判断地0个动物是否跑完 跑完则把后面链接的动物的状态设为run,并且把方向力设置为0
if (SideAnimals[0].MoveDistance >= roadLength + 0.01f)
{
var entity = SideAnimals[0];
if (entity.CurState == AnimalState.Connect)
{
SidePower -= entity.Power;
}
entity.SetState(AnimalState.Finish);
Points += entity.FinshPoint;
SideAnimals.RemoveAt(0);
AnimalFactory.AddToCollectList(entity);
if (SideAnimals.Count > 0)
{
SideAnimals[0].SetState(AnimalState.Run);
}
SidePower = 0;
for (int i = 0; i < SideAnimals.Count; i++)
{
//如果第0个动物是Run则后面每个动物都是run
if (SideAnimals[0].CurState == AnimalState.Run && SideAnimals[i].CurState == AnimalState.Connect)
{
SideAnimals[i].SetState(AnimalState.Run);
}
}
}
//如果被对面推回去则方向力减小
int lastIndex = SideAnimals.Count - 1;
if (SideAnimals.Count > 0 && SideAnimals[lastIndex].MoveDistance <= 0)
{
var entity = SideAnimals[lastIndex];
if (entity.CurState == AnimalState.Connect)
{
SidePower -= entity.Power;
}
entity.SetState(AnimalState.Dead);
SideAnimals.RemoveAt(lastIndex);
AnimalFactory.AddToCollectList(entity);
}
}
}
public void AddAnimal(AnimalEntity entity)
{
SideAnimals.Add(entity);
}
public async Task InsertAsync(AnimalEntity entity)
{
await _animalsCollection.InsertOneAsync(entity);
}
public void EditAnimal(AnimalEntity animal)
{
_animalLogic.EditAnimal(animal);
}
public static Animal AsAnimal(this AnimalEntity entity)
{
return(new Animal(entity.Id, entity.Avatar, entity.Name, entity.Type, entity.Weight, entity.YearOfBirth,
entity.AreaId, entity.AreaType, entity.CageNo));
}
public AnimalCompletedEvent(AnimalEntity item)
{
Item = item;
}
//判断相对跑的动物是否能链接起来
public bool CanDiffSideConnect(AnimalEntity anima0, AnimalEntity animal1, float roadLength)
{
return((anima0.MoveDistance + animal1.MoveDistance) >= roadLength);
}
//判断同一侧的动物链接起来
public bool CanSameSideConnect(AnimalEntity anima0, AnimalEntity animal1)
{
return((anima0.MoveDistance - animal1.MoveDistance - anima0.BodyLength) <= 0);
}
public void CreateAnimal(AnimalEntity animal)
{
_entityContext.Animals.Add(animal);
_entityContext.SaveChanges();
}
public AnimalCreatedEvent(AnimalEntity item)
{
Item = item;
}