void DoDamage(int dmg, GameObject go)
{
m_curHealth -= dmg;
if (m_curHealth <= 0)
{
m_curHealth = 0;
if (m_messageHandler)
{
DeathData deathData = new DeathData();
deathData.attacker = go;
deathData.attacked = gameObject;
m_messageHandler.GiveMessage(MessageType.DIED, gameObject, deathData);
}
}
if (m_messageHandler)
{
HealthData hpData = new HealthData();
hpData.maxHealth = maxHealth;
hpData.curHealth = m_curHealth;
m_messageHandler.GiveMessage(MessageType.HEALTHCHANGED, gameObject, hpData);
}
}
public HealthData CheckTablePermissions(string tableName, ICollection <TablePermission> permissions)
{
HealthData tableHealth = new HealthData(tableName);
try
{
foreach (TablePermission permission in permissions)
{
HealthData tablePermissionHealth = new HealthData(permission.Permission.ToString());
tablePermissionHealth.IsOK = this.CheckPermission(permission);
if (tablePermissionHealth.IsOK == false)
{
tablePermissionHealth.ErrorMessage = "Does not have permission.";
}
tableHealth.DependenciesStatus.Add(tablePermissionHealth);
}
tableHealth.IsOK = true;
}
catch (Exception ex)
{
OnDependencyException?.Invoke(this, new DependencyExceptionEvent(ex));
tableHealth.ErrorMessage = ex.Message;
tableHealth.IsOK = false;
}
return(tableHealth);
}
public void Execute(TriggerEvent triggerEvent)
{
if (playerGroup.HasComponent(triggerEvent.EntityA))
{
if (pickupGroup.HasComponent(triggerEvent.EntityB))
{
PickupTag pickup = pickupGroup[triggerEvent.EntityB];
switch (pickup.type)
{
case 0:
HealthData health = healthGroup[triggerEvent.EntityA];
health.health += 50;
if (health.health > 100)
{
health.health = 100;
}
health.damageCoolDown = .3f;
healthGroup[triggerEvent.EntityA] = health;
break;
case 1:
GunData gun = gunGroup[triggerEvent.EntityB];
gunGroup[triggerEvent.EntityA] = gun;
break;
default:
break;
}
pickup.destroy = true;
pickupGroup[triggerEvent.EntityB] = pickup;
}
}
}
public HealthData CheckHealth()
{
HealthData healthData = new HealthData($"{_hostname}:{_port} [{_serviceName ?? ""}]");
healthData.Type = "Telnet";
try
{
using (Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp))
{
socket.Connect(_hostname, _port);
if (socket.Connected)
{
healthData.IsOK = true;
}
}
}
catch (Exception ex)
{
healthData.IsOK = false;
healthData.ErrorMessage = ex.Message;
}
return(healthData);
}
public HealthData CheckHealth()
{
HealthData directoryHealthData = new HealthData(_windowsPrincipal.Identity.Name);
directoryHealthData.Type = "DirectoryPermission";
try
{
foreach (string directoryPath in _fileSystemRigths.Keys)
{
HealthData directoryHealth = CheckFileRigthPermissions(directoryPath, _fileSystemRigths[directoryPath]);
directoryHealthData.DependenciesStatus.Add(directoryHealth);
}
directoryHealthData.IsOK = true;
}
catch (Exception ex)
{
OnDependencyException?.Invoke(this, new DependencyExceptionEvent(ex));
directoryHealthData.IsOK = false;
directoryHealthData.ErrorMessage = ex.Message;
}
return(directoryHealthData);
}
private HealthData CheckTablePermissions(string tableName, ICollection <TablePermission> permissions, SqlConnection sqlConnection)
{
HealthData tableHealth = new HealthData(tableName);
try
{
foreach (TablePermission permission in permissions)
{
HealthData tablePermissionHealth = new HealthData(permission.Permission.ToString());
tablePermissionHealth.IsOK = CheckPermission(permission, sqlConnection);
if (tablePermissionHealth.IsOK == false)
{
tablePermissionHealth.ErrorMessage = "Does not have permission.";
}
tableHealth.DependenciesStatus.Add(tablePermissionHealth);
}
tableHealth.IsOK = true;
}
catch (Exception ex)
{
tableHealth.ErrorMessage = ex.Message;
tableHealth.IsOK = false;
}
return(tableHealth);
}
public virtual void ApplyDamage(int damage, GameObject go)
{
m_currentHealth -= damage;
// We died!
if (m_currentHealth <= 0)
{
m_currentHealth = 0;
// Send out message letting other know I died.
if (m_messageHandler)
{
DeathData deathData = new DeathData();
deathData.attacker = go;
deathData.attacked = gameObject; // this object was attacked
m_messageHandler.CustomSendMessage(MessageType.DIED, gameObject, deathData);
}
}
if (m_messageHandler)
{
HealthData healthData = new HealthData();
healthData.curHealth = m_currentHealth;
healthData.maxHealth = maxHealth;
}
}
private HealthData CheckFileRigthPermissions(string directoryPath, ICollection <FileSystemRights> fileSystemRights)
{
HealthData tableHealth = new HealthData(directoryPath);
try
{
foreach (FileSystemRights fileSystemRight in fileSystemRights)
{
HealthData tablePermissionHealth = new HealthData(fileSystemRight.ToString());
tablePermissionHealth.IsOK = CheckUserPermission(directoryPath, fileSystemRight);
if (tablePermissionHealth.IsOK == false)
{
tablePermissionHealth.ErrorMessage = "Does not have permission.";
}
tableHealth.DependenciesStatus.Add(tablePermissionHealth);
}
tableHealth.IsOK = true;
}
catch (Exception ex)
{
OnDependencyException?.Invoke(this, new DependencyExceptionEvent(ex));
tableHealth.ErrorMessage = ex.Message;
tableHealth.IsOK = false;
}
return(tableHealth);
}
void DoDamage(int dmg, GameObject go)
{
m_curHealth -= dmg;
if (m_curHealth <= 0)
{
m_curHealth = 0;
if (m_messageHandler)
{
DeathData deathData = new DeathData();
deathData.attacker = go;
deathData.attacked = gameObject;
m_messageHandler.GiveMessage(MessageType.DIED, gameObject, deathData);
}
}
if (m_messageHandler)
{
HealthData hpData = new HealthData();
hpData.maxHealth = maxHealth;
hpData.curHealth = m_curHealth;
m_messageHandler.GiveMessage(MessageType.HEALTHCHANGED, gameObject, hpData);
}
}
/// <summary>
/// 医生首页取居民信息
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public JsonResult AjaxGetUsersByDoctor(LayUIPageParam param)
{
List <User> users = new List <User>();
users = UserLogic.GetUsersByDoctorId(AuthUser.Id, param.page, param.limit);
users.ForEach(p =>
{
Device d = DeviceLogic.GetDeviceByUserId(p.Id);
if (d != null)
{
HealthInfoModel model = HealthData.GetHealthInfo(d.APIDeviceId ?? 0);
p.Step = model.Step;
p.Heart = model.HeartRate;
p.Shrink = model.BloodMax;
p.Diastolic = model.BloodMin;
p.LastCheckTime = model.LastUpdateTime;
}
p.HeartValue = p.HeartMin + "-" + p.HeartMax;
p.BloodValue = p.BloodMin + "-" + p.BloodMax;
p.BloodValue2 = p.BloodMin2 + "-" + p.BloodMax2;
});
LayuiPageResult <User> ls = new LayuiPageResult <User>();
ls.count = UserLogic.GetUsersByDoctorIdCount(AuthUser.Id);
ls.data = users;
ls.code = 0;
return(Json(ls));
}
void DoDamage(int dmg, GameObject attacker)
{
_curHealth -= dmg;
if (_curHealth <= 0)
{
_curHealth = 0;
if (_msgHandler)
{
DeathData deathData = new DeathData();
deathData.attacker = attacker;
deathData.attacked = gameObject;
MessageEventArgs messageEventArgs = new MessageEventArgs(MessageType.DIED, attacker, deathData);
_msgHandler.OnGiveMessage(messageEventArgs);
}
}
if (_msgHandler)
{
HealthData healthData = new HealthData
{
maxHealth = maxHealth,
curHealth = _curHealth
};
MessageEventArgs messageEventArgs = new MessageEventArgs(MessageType.HEALTHCHANGED, gameObject, healthData);
_msgHandler.OnGiveMessage(messageEventArgs);
}
}
public List <HealthData> GetHD()
{
List <HealthData> HDList = new List <HealthData>();
SqlConnection connection = new SqlConnection(this.conStr);
connection.Open();
SqlCommand cmd = new SqlCommand("Select * from tb_HealthData ", connection);
cmd.CommandType = CommandType.Text;
SqlDataReader sdr = cmd.ExecuteReader();
while (sdr.Read())
{
HealthData hd = new HealthData();
hd.Email = sdr["Email"].ToString();
hd.Weight = sdr["Weight"].ToString();
hd.Height = sdr["Height"].ToString();
hd.BloodType = sdr["BloodType"].ToString();
hd.Diabetes = sdr["Diabetes"].ToString();
hd.Epilepsy = sdr["Epilepsy"].ToString();
hd.Asma = sdr["Asma"].ToString();
hd.Allergies = sdr["Allergies"].ToString();
hd.Observations = sdr["Observations"].ToString();
HDList.Add(hd);
}
return(HDList);
}
void DisplayVitals()
{
HealthData vitals = playerHealth.GetVitals();
shieldbar.value = vitals.currentShield / vitals.maxShield;
healthBar.value = vitals.currentHealth / vitals.maxHealth;
}
async void DoneEdit(object ender, EventArgs e)
{
SQLiteConnection conn = new SQLiteConnection(App.DatabaseLocation);
conn.Query <HealthData>("select * from HealthData where id=?", tempid);
HealthData healthdata = new HealthData()
{
id = tempid,
vetVisited = vetVisit_entry.Text,
TypeVisit = type_entry.Text,
Date = date_entry.Text,
Weight = weight_entry.Text,
Vaccinations = vaccinations_entry.Text,
vetComments = comments_entry.Text
};
conn.Update(healthdata);
conn.Close();
await DisplayAlert("Success", "Vet information saved", "Ok");
await Navigation.PopToRootAsync();
}
public void Execute(CollisionEvent collisionEvent)
{
if (bulletGroup.HasComponent(collisionEvent.EntityA))
{
if (unitGroup.HasComponent(collisionEvent.EntityB))
{
HealthData data = unitGroup[collisionEvent.EntityB];
if (data.damageCoolDown <= 0)
{
data.damageCoolDown = 0.1f;
data.health -= 5;
unitGroup[collisionEvent.EntityB] = data;
BulletTag bullet = bulletGroup[collisionEvent.EntityA];
bullet.destroyTimer = 0;
bulletGroup[collisionEvent.EntityA] = bullet;
}
}
}
else if (unitGroup.HasComponent(collisionEvent.EntityA))
{
if (bulletGroup.HasComponent(collisionEvent.EntityB))
{
HealthData data = unitGroup[collisionEvent.EntityA];
if (data.damageCoolDown <= 0)
{
data.damageCoolDown = 0.1f;
data.health -= 5;
unitGroup[collisionEvent.EntityB] = data;
BulletTag bullet = bulletGroup[collisionEvent.EntityB];
bullet.destroyTimer = 0;
bulletGroup[collisionEvent.EntityA] = bullet;
}
}
}
}
void Update()
{
// Regenare health over time
if (canRegenerate)
{
if (Time.time > nextRegenRate)
{
nextRegenRate = Time.time + 1;
_curHealth += regenRate;
_curHealth = Mathf.Clamp(_curHealth, 0, maxHealth);
if (_msgHandler)
{
HealthData healthData = new HealthData
{
maxHealth = maxHealth,
curHealth = _curHealth
};
MessageEventArgs messageEventArgs = new MessageEventArgs(MessageType.HEALTHCHANGED, gameObject, healthData);
_msgHandler.OnGiveMessage(messageEventArgs);
}
}
}
}
public void ApplyDamage(int damage, GameObject go)
{
CurrentHealth -= damage;
//Will need to change this if statement, pretty sure I need to remove the spawn part
if (CurrentHealth <= 0f /*&& GameObject.Find("Cube-Spawn").GetComponent<HealthController>().currentHealth > 0*/)
{
// PlaySoundOnKill();
CurrentHealth = 0;
if (messageHandler)
{
DeathData deathData = new DeathData();
deathData.attacker = go;
deathData.attacked = gameObject;
messageHandler.GiveMessage(MessageTypes.DIED, gameObject, deathData);
}
if (transform.parent != null)
{
if (gameObject.GetComponentInParent <TotemDestroyed>())
{
gameObject.GetComponentInParent <TotemDestroyed>()._IsDestroyed = true;
}
}
if (gameObject.tag == "Player/Boy" || gameObject.tag == "Player/Girl")
{
DoDeath();
}
if (this.gameObject.tag == "Enemy")
{
GameObject.Find("/PlayerUI").GetComponent <UISpellSwap>().currentEnemy = null;
Destroy(transform.parent.gameObject, 0.15f);
if (isBoss)
{
EventManager.TriggerEvent("bossDied");
}
EventManager.TriggerEvent("checkVictory");
}
}
else if (CurrentHealth >= 0f && CurrentHealth <= totalHealth && this.GetComponent <HealthUI>())
{
this.GetComponent <HealthUI>().UpdateUi(totalHealth, currentHealth);
}
if (messageHandler)
{
HealthData hpData = new HealthData();
hpData.maxHealth = totalHealth;
hpData.curHealth = currentHealth;
messageHandler.GiveMessage(MessageTypes.HEALTHCHANGED, gameObject, hpData);
}
}
private void CheckHealth(HealthData health)
{
if (health.isDead)
{
PlayerData.Die();
playerUI.OpenDeathUI($"Age: {health.age}", $"Cause of death: {health.cause}");
}
}
public override HealthData CheckIndex(Index index)
{
HealthData tableHealth = new HealthData(index.IndexName);
tableHealth.ErrorMessage = $"Index '{index.IndexName}' is not yet verifiable for oracle at this point'.";
tableHealth.IsOK = true;
return(tableHealth);
}
public void HealthData_without_dependencies_is_not_ok()
{
HealthData healthData = new HealthData("test");
healthData.IsOK = false;
Assert.False(healthData.IsOK);
}
public void HealthData_without_dependencies_is_ok()
{
HealthData healthData = new HealthData("test");
healthData.IsOK = true;
Assert.True(healthData.IsOK);
}
private void Awake()
{
healthData = GetComponent <HealthData>();
rigidbody = GetComponent <Rigidbody>();
weaponSystem = GetComponent <WeaponSystem>();
audioSource = GetComponent <AudioSource>();
audioSource.spatialBlend = 1.0f;
audioSource.minDistance = 50.0f;
audioSource.maxDistance = 500.0f;
}
public static HealthData Clone(HealthData data)
{
HealthData res = new HealthData();
res.hp = data.hp;
res.maxHp = data.maxHp;
res.attr = data.attr;
res.physicDef = data.physicDef;
res.magicDef = data.magicDef;
return(res);
}
public HealthData Register(FieldEntity entity)
{
var data = new HealthData(); // TODO: pool theze boiz
entity.Health = data;
_active.Add(data);
_healthOwners.Add(data, entity);
return(data);
}
/// <summary>
/// Constrói uma lista de Diagnóstico
/// </summary>
/// <param name="healthData"></param>
/// <returns></returns>
private static IList <Diagnostic> BuildHealthData(HealthData healthData)
{
var buildHealthData = healthData.DependenciesStatus.Where(data => !data.IsOK)
.Select(data => new Diagnostic
{
FlowName = "DatabasePermission",
IsSuccess = healthData.IsOK,
Data = GetErrorMessages(healthData)
}).ToList();
return(buildHealthData);
}
private void Start()
{
health = dataGameObject.GetComponentInChildren <HealthData>();
weapons = dataGameObject.GetComponentsInChildren <WeaponData>();
if (health != null)
{
currentHealth = health.health;
}
weaponsCooldown = new float[weapons.Length];
}
private void AddDamageToPlanet(Entity planetEntity, Entity damageDealerEntity)
{
DamageDealerData damageDealerData = damaeDealerEntities[damageDealerEntity];
HealthData damageDealerHealthData = healthEntities[damageDealerEntity];
// Destroy the thing that hit the planet
damageDealerHealthData.healthLeft = 0;
healthEntities[damageDealerEntity] = damageDealerHealthData;
commandBuffer.AddComponent(planetEntity, new PlanetDamageData {
damage = damageDealerData.damage
});
}
public void OnReceiveMessage(MessageEventArgs msgEventArgs)
{
switch (msgEventArgs.MsgType)
{
case MessageType.HEALTHCHANGED:
HealthData health = msgEventArgs.MsgData as HealthData;
if (health != null)
{
UpdateUI(health.maxHealth, health.curHealth);
}
break;
}
}
void RecieveMessage(Messagetype msgType, GameObject go, MessageData msgData)
{
switch (msgType)
{
case Messagetype.HEALTHCHANGED:
HealthData hpData = msgData as HealthData;
if (hpData != null)
{
UpdateUi(hpData.maxHealth, hpData.curHealth);
}
break;
}
}
/// <summary>
/// 请求用户的健康数据
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public JsonResult AjaxGetHealthInfo(int deviceId)
{
Device d = DeviceLogic.GetDeviceById(deviceId);
if (d == null)
{
return(Json(new BaseResult {
State = State.NotFind, Message = "未找到该设备"
}));
}
HealthInfoModel model = HealthData.GetHealthInfo(d.APIDeviceId ?? 0);
return(Json(new { State = State.Success, Item = model }));
}
public override async Task <HealthResponse> AddPersonHealthData(HealthRequest request, ServerCallContext context)
{
var healthData = new HealthData {
Name = request.Name, HealthParameter1 = request.HealthParameter1, HealthParameter2 = request.HealthParameter2
};
_personDbContext.Health.Add(healthData);
await _personDbContext.SaveChangesAsync();
var results = new HealthResponse {
Message = "Health Data Save Successfully."
};
return(results);
}
private void Connection_Received(EndPoint ep, TypedPackage package)
{
// Select player
if (!_players.ContainsKey(ep))
{
Debug.Log("Received UDP from unconnected client! By " + ep.ToString());
return;
}
SpawnedPlayer p = _players[ep];
// Handle msg
if (package.Type == PackageType.PlayerMove)
{
p.Positioning.FromBytes(package.Data, ref package.Offset);
p.Updated = true;
}
else if (package.Type == PackageType.PlayerShoot)
{
ShootingData message = new ShootingData(package.Data, ref package.Offset);
p.ShootBuffer.Shots.AddRange(message.Shots);
}
else if (package.Type == PackageType.BoatPartHit)
{
HealthData message = new HealthData(package.Data, ref package.Offset);
lock (p.HitBuffer)
p.HitBuffer.Add(message);
}
else
{
Debug.Log("Unhandled UDP msg");
}
}
