//EvalChargeState
private void EvalChargeState()
{
if (_chargeCurrent > MaximumChargeCurrent) // chargeCurrent > 500.00 mA
{
_usbCharger.StopCharge();
_chargerState = ChargerState.OverCurrentFail; // 3
}
else if (_chargeCurrent <= MaximumChargeCurrent &&
_chargeCurrent > MinimumChargeCurrent) // 500 mA > chargecurrent > 5 mA
{
_chargerState = ChargerState.IsCharging; //1
}
else if (_chargeCurrent > ZeroChargeCurrent &&
_chargeCurrent <= MinimumChargeCurrent) // Fully charged 5 mA > chargeCurrent > 0 mA
{
_chargerState = ChargerState.FullyCharged; // 2
}
else
{
if (_chargerState == ChargerState.OverCurrentFail)
{
return;
}
_chargerState = ChargerState.Idle; // 0
}
ReadChargerState = (int)_chargerState;
}
private void UpdateDisplay()
{
if (_latestState == _chargerState)
{
return;
}
switch (_chargerState)
{
case ChargerState.OverCurrentFail: //State charge fail
_display.UpdateChargeMsg("Current failed");
_latestState = ChargerState.OverCurrentFail;
break;
case ChargerState.FullyCharged:
_display.UpdateChargeMsg("Fully Charged");
_latestState = ChargerState.FullyCharged;
break;
case ChargerState.IsCharging:
_display.UpdateChargeMsg("Is Charging");
_latestState = ChargerState.IsCharging;
break;
case ChargerState.Idle:
_display.UpdateChargeMsg("Idle");
_latestState = ChargerState.Idle;
break;
default:
break;
}
}
// OnChargeCurrentUpdate Helper Functions
private void EvaluateChargerState()
{
if (_chargingCurrent > MaxChargingCurrent)
{
_usbCharger.StopCharge();
_chargerState = ChargerState.OverCurrentFail;
}
else if (_chargingCurrent <= MaxChargingCurrent &&
_chargingCurrent > MinChargingCurrent)
{
_chargerState = ChargerState.IsCharging;
}
else if (_chargingCurrent <= MinChargingCurrent &&
_chargingCurrent > ZeroChargingCurrent)
{
_chargerState = ChargerState.TrickleChargeFullyCharged;
}
else
{
// Persist OverCurrent State Message in Display
// until manually reset is performed by invoking StartCharge()
if (_chargerState == ChargerState.OverCurrentFail)
{
return;
}
_chargerState = ChargerState.Idle;
}
ReadChargerState = (int)_chargerState;
}
protected override void OnPollDataReceived(int pollID, byte i2cAddress, byte register, int[] values, object data)
{
if (values == null)
{
return;
}
int value = values[0];
switch (register)
{
case I2CRegisters.ChargerAState:
ChargerState x = GetChargerStatus((byte)value);
if (chargerAState == x)
{
return;
}
chargerAState = x;
OnNotifyPropertyChanged("ChargerAState");
break;
case I2CRegisters.ChargerBState:
x = GetChargerStatus((byte)value);
if (chargerBState == x)
{
return;
}
chargerBState = x;
OnNotifyPropertyChanged("ChargerBState");
break;
}
}
public void ControllChager()
{
if (chargerState == ChargerState.isEmpty)
{
chargerState = ChargerState.isCharging;
StartCoroutine(ChargeUp());
}
else if (chargerState == ChargerState.isCharging)
{
chargerState = ChargerState.isEmpty;
RetriveBattery();
}
}
IEnumerator ChargeUp()
{
// find the battery with min volume
float lastComparedVolume = 1000f;
for (int i = 0; i < batteryManager.batteries.Length; i++)
{
if (batteryManager.batteries[i].state == BatteryManager.BatteryState.Equipped && batteryManager.batteries[i].currentBatteryVolume < lastComparedVolume)
{
batteryIndex = i;
lastComparedVolume = batteryManager.batteries[i].currentBatteryVolume;
}
}
if (batteryManager.batteries[batteryIndex].state == BatteryManager.BatteryState.Equipped)
{
// set charger active and ligth intensity
batteryGraphics.gameObject.SetActive(true);
batteryGraphics.gameObject.GetComponent <Light>().intensity = Mathf.Lerp(minLightIntensity, maxLightIntensity, batteryManager.batteries[batteryIndex].currentBatteryVolume / 100);
// set battery of gun inactive
batteryManager.batteries[batteryIndex].batteryT.gameObject.SetActive(false);
batteryManager.batteries[batteryIndex].state = BatteryManager.BatteryState.Charging;
while (chargerState == ChargerState.isCharging)
{
// keep charging!
batteryManager.batteries[batteryIndex].currentBatteryVolume += 100 * Time.deltaTime / timeToFullVolume;
if (batteryManager.batteries[batteryIndex].currentBatteryVolume >= 100f)
{
batteryManager.batteries[batteryIndex].currentBatteryVolume = 100f;
print("FullyCharged: " + batteryIndex);
}
else
{
player.powerRemaining -= 100 * Time.deltaTime / timeToFullVolume;
}
yield return(null);
}
}
else
{
chargerState = ChargerState.isEmpty;
}
}
public ChargerMutantEnemy(LevelState parentWorld, Vector2 position)
{
this.position = position;
dimensions = new Vector2(32f, 96.0f);
velocity = Vector2.Zero;
disable_movement = false;
disable_movement_time = 0.0f;
windup_timer = 0.0f;
knockback_magnitude = 8.0f;
enemy_damage = 15;
enemy_life = 20;
enemy_found = false;
change_direction_time = 0.0f;
range_distance = 300.0f;
charge_timer = 0.0f;
alert_timer = 0.0f;
range_distance = 600f;
sound_timer = 0.0f;
play_sound = true;
prob_item_drop = 0.6;
number_drop_items = 5;
entity_found = null;
state = ChargerState.search;
enemy_type = EnemyType.Prisoner;
component = new IdleSearch();
sound_alert = false;
direction_facing = (GlobalGameConstants.Direction)(Game1.rand.Next() % 4);
this.parentWorld = parentWorld;
directionAnims = new AnimationLib.SpineAnimationSet[4];
directionAnims[(int)GlobalGameConstants.Direction.Up] = AnimationLib.loadNewAnimationSet("chargerUp");
directionAnims[(int)GlobalGameConstants.Direction.Down] = AnimationLib.loadNewAnimationSet("chargerDown");
directionAnims[(int)GlobalGameConstants.Direction.Left] = AnimationLib.loadNewAnimationSet("chargerRight");
directionAnims[(int)GlobalGameConstants.Direction.Left].Skeleton.FlipX = true;
directionAnims[(int)GlobalGameConstants.Direction.Right] = AnimationLib.loadNewAnimationSet("chargerRight");
for (int i = 0; i < 4; i++)
{
directionAnims[i].Animation = directionAnims[i].Skeleton.Data.FindAnimation("idle");
}
}
private void UpdateDisplay()
{
if (_lastState == _chargerState)
{
// If state is the same, then don't update display,
// but update progressbar if charging device
// Progressbar
if (_chargerState == ChargerState.IsCharging)
{
var progress = (((500 - (int)ReadChargingCurrent) * 100) / 495);
Console.Write("\rProgress: {0} %", progress);
}
return;
}
switch (_chargerState)
{
case ChargerState.OverCurrentFail:
_display.OverCurrentFail();
_lastState = ChargerState.OverCurrentFail;
break;
case ChargerState.TrickleChargeFullyCharged:
_display.FullyCharged();
_lastState = ChargerState.TrickleChargeFullyCharged;
break;
case ChargerState.IsCharging:
_display.IsCharging();
_lastState = ChargerState.IsCharging;
break;
case ChargerState.Idle:
_display.NotCharging();
_lastState = ChargerState.Idle;
break;
//DotCoverIgnore
default:
// Not Possible
break;
//EndDotCoverIgnore
}
}
protected override void OnPollDataReceived(int pollID, byte i2cAddress, byte register, int[] values, object data)
{
if (values == null) return;
int value = values[0];
switch (register)
{
case I2CRegisters.ChargerAState:
ChargerState x = GetChargerStatus((byte)value);
if (chargerAState == x) return;
chargerAState = x;
OnNotifyPropertyChanged("ChargerAState");
break;
case I2CRegisters.ChargerBState:
x = GetChargerStatus((byte)value);
if (chargerBState == x) return;
chargerBState = x;
OnNotifyPropertyChanged("ChargerBState");
break;
}
}
public void StopCharge()
{
_chargerState = ChargerState.Idle;
_usbCharger.StopCharge();
}
public override void update(GameTime currentTime)
{
animation_time += currentTime.ElapsedGameTime.Milliseconds / 1000f;
sound_timer += currentTime.ElapsedGameTime.Milliseconds;
if (sound_timer > 250f)
{
play_sound = true;
}
if (sound_alert && state == ChargerState.search && entity_found == null)
{
state = ChargerState.alert;
alert_timer = 0.0f;
}
if (state == ChargerState.dying)
{
velocity = Vector2.Zero;
death = true;
// may the programming gods have mercy on me hacking over this complicated state machine
goto DeadSkipStates;
}
if (disable_movement == true)
{
disable_movement_time += currentTime.ElapsedGameTime.Milliseconds;
if (disable_movement_time > 300)
{
disable_movement_time = 0.0f;
disable_movement = false;
velocity = Vector2.Zero;
state = ChargerState.alert;
}
directionAnims[(int)direction_facing].Animation = directionAnims[(int)direction_facing].Skeleton.Data.FindAnimation("hurt");
}
else
{
switch (state)
{
case ChargerState.search:
directionAnims[(int)direction_facing].Animation = directionAnims[(int)direction_facing].Skeleton.Data.FindAnimation("idle");
change_direction_time += currentTime.ElapsedGameTime.Milliseconds;
//first if state is if enemy was knocked back by a enemy of a different type
if (enemy_found == false)
{
for (int i = 0; i < parentWorld.EntityList.Count; i++)
{
if (parentWorld.EntityList[i] == this || (GameCampaign.PlayerAllegiance < 0.3 && parentWorld.EntityList[i] is Player))
{
continue;
}
else if (parentWorld.EntityList[i].Enemy_Type != enemy_type && parentWorld.EntityList[i].Enemy_Type != EnemyType.NoType && parentWorld.EntityList[i].Death == false)
{
component.update(this, parentWorld.EntityList[i], currentTime, parentWorld);
if (enemy_found == true)
{
entity_found = parentWorld.EntityList[i];
break;
}
}
}
}
if (enemy_found)
{
state = ChargerState.windUp;
velocity = Vector2.Zero;
}
else
{
if (change_direction_time > 5000)
{
switch (direction_facing)
{
case GlobalGameConstants.Direction.Right:
direction_facing = GlobalGameConstants.Direction.Down;
break;
case GlobalGameConstants.Direction.Left:
direction_facing = GlobalGameConstants.Direction.Up;
break;
case GlobalGameConstants.Direction.Up:
direction_facing = GlobalGameConstants.Direction.Right;
break;
default:
direction_facing = GlobalGameConstants.Direction.Left;
break;
}
change_direction_time = 0.0f;
}
entity_found = null;
sound_alert = false;
}
break;
case ChargerState.alert:
directionAnims[(int)direction_facing].Animation = directionAnims[(int)direction_facing].Skeleton.Data.FindAnimation("idle");
if (sound_alert && entity_found == null)
{
//if false then sound didn't hit a wall
if (!parentWorld.Map.soundInSight(this, sound_position))
{
directionAnims[(int)direction_facing].Animation = directionAnims[(int)direction_facing].Skeleton.Data.FindAnimation("run");
alert_timer += currentTime.ElapsedGameTime.Milliseconds;
for (int i = 0; i < parentWorld.EntityList.Count; i++)
{
if (parentWorld.EntityList[i].Enemy_Type != enemy_type && parentWorld.EntityList[i].Enemy_Type != EnemyType.NoType && parentWorld.EntityList[i].Death == false)
{
float distance = Vector2.Distance(CenterPoint, parentWorld.EntityList[i].CenterPoint);
if (distance <= range_distance)
{
enemy_found = true;
entity_found = parentWorld.EntityList[i];
state = ChargerState.windUp;
animation_time = 0.0f;
sound_alert = false;
alert_timer = 0.0f;
windup_timer = 0.0f;
animation_time = 0.0f;
velocity = Vector2.Zero;
charge_timer = 0.0f;
break;
}
}
}
if (alert_timer > 3000 || ((int)CenterPoint.X == (int)sound_position.X && (int)CenterPoint.Y == (int)sound_position.Y))
{
entity_found = null;
enemy_found = false;
sound_alert = false;
state = ChargerState.search;
velocity = Vector2.Zero;
animation_time = 0.0f;
charge_timer = 0.0f;
windup_timer = 0.0f;
animation_time = 0.0f;
}
}
else
{
entity_found = null;
enemy_found = false;
sound_alert = false;
state = ChargerState.search;
velocity = Vector2.Zero;
animation_time = 0.0f;
charge_timer = 0.0f;
windup_timer = 0.0f;
animation_time = 0.0f;
}
}
else if (entity_found != null)
{
sound_alert = false;
float distance = Vector2.Distance(CenterPoint, entity_found.CenterPoint);
if (parentWorld.Map.enemyWithinRange(entity_found, this, range_distance) && distance < range_distance && entity_found.Death == false)
{
state = ChargerState.windUp;
animation_time = 0.0f;
}
else
{
entity_found = null;
enemy_found = false;
state = ChargerState.search;
velocity = Vector2.Zero;
animation_time = 0.0f;
charge_timer = 0.0f;
windup_timer = 0.0f;
animation_time = 0.0f;
}
}
break;
case ChargerState.windUp:
directionAnims[(int)direction_facing].Animation = directionAnims[(int)direction_facing].Skeleton.Data.FindAnimation("windUp");
windup_timer += currentTime.ElapsedGameTime.Milliseconds;
angle = (float)Math.Atan2(entity_found.CenterPoint.Y - CenterPoint.Y, entity_found.CenterPoint.X - CenterPoint.X);
if (windup_timer > 300)
{
animation_time = 0.0f;
state = ChargerState.charge;
velocity = new Vector2(8.0f * (float)(Math.Cos(angle)), 8.0f * (float)(Math.Sin(angle)));
charge_timer = 0.0f;
}
break;
case ChargerState.charge:
directionAnims[(int)direction_facing].Animation = directionAnims[(int)direction_facing].Skeleton.Data.FindAnimation("charge");
charge_timer += currentTime.ElapsedGameTime.Milliseconds;
for (int i = 0; i < parentWorld.EntityList.Count; i++)
{
if (parentWorld.EntityList[i] == this)
{
continue;
}
if (hitTest(parentWorld.EntityList[i]))
{
if (play_sound)
{
AudioLib.playSoundEffect("chargerImpact");
sound_timer = 0.0f;
play_sound = false;
}
Vector2 direction = parentWorld.EntityList[i].CenterPoint - CenterPoint;
parentWorld.EntityList[i].knockBack(direction, knockback_magnitude, enemy_damage);
}
}
if (charge_timer > 800)
{
if (entity_found.Death == true)
{
entity_found = null;
}
sound_alert = false;
state = ChargerState.alert;
velocity = Vector2.Zero;
animation_time = 0.0f;
charge_timer = 0.0f;
windup_timer = 0.0f;
animation_time = 0.0f;
enemy_found = false;
}
break;
default:
break;
}
}
DeadSkipStates:
Vector2 pos = new Vector2(position.X, position.Y);
Vector2 nextStep = new Vector2(position.X + velocity.X, position.Y + velocity.Y);
Vector2 finalPos = parentWorld.Map.reloactePosition(pos, nextStep, dimensions);
position.X = finalPos.X;
position.Y = finalPos.Y;
directionAnims[(int)direction_facing].Animation.Apply(directionAnims[(int)direction_facing].Skeleton, animation_time, state == ChargerState.dying ? false : true);
if (enemy_life <= 0 && state != ChargerState.dying && death == false)
{
directionAnims[(int)direction_facing].Animation = directionAnims[(int)direction_facing].Skeleton.Data.FindAnimation(Game1.rand.Next() % 3 == 0 ? "die" : Game1.rand.Next() % 2 == 0 ? "die2" : "die3");
death = true;
state = ChargerState.dying;
animation_time = 0;
parentWorld.pushCoin(this);
}
}
