void Update()
{
if (TimeCounter > 0 && playerShip.Won == false)
{
TimeCounter -= Time.deltaTime;
TimeOnScreen = Mathf.Floor(TimeCounter);
TimeText.text = "Time: " + TimeOnScreen;
if (playerShip != null && TimeCounter <= 0f)
{
playerShip.Kill();
YouLoseText.enabled = true;
DelayHelper.DelayAction(this, ReloadLevel, 5.0f);
}
}
else if (TimeCounter <= 0)
{
TimeText.text = "Time: " + 0;
}
if (Input.GetKeyDown(KeyCode.Backspace))
{
ReloadLevel();
}
if (Input.GetKeyDown(KeyCode.Escape))
{
Application.Quit();
}
}
//====================================================================
void Update()
{
if (null != helperList)
{
for (int i = 0; i < helperList.Count(); ++i)
{
DelayHelper helper = helperList[i];
helper.delay -= UnityEngine.Time.deltaTime;
if (helper.delay <= 0)
{
helperList.RemoveAt(i);
i--;
helper.Invoke();
}
}
}
if (null != unscaledHelperList)
{
for (int i = 0; i < unscaledHelperList.Count(); ++i)
{
DelayHelper helper = unscaledHelperList[i];
helper.delay -= UnityEngine.Time.unscaledDeltaTime;
if (helper.delay <= 0)
{
unscaledHelperList.RemoveAt(i);
i--;
helper.Invoke();
}
}
}
}
/// <summary>
/// Reads previous reading and prepares next reading for specified channel
/// </summary>
/// <param name="channelToCharge">Channel to prepare</param>
/// <returns>10 bit value corresponding to relative voltage level on channel</returns>
public int ReadPreviousAndChargeChannel(Channel channelToCharge)
{
if (!IsValidChannel(channelToCharge))
{
throw new ArgumentOutOfRangeException(nameof(channelToCharge));
}
Span <byte> readBuffer = stackalloc byte[2];
Span <byte> writeBuffer = stackalloc byte[2];
writeBuffer[0] = (byte)((int)channelToCharge << 1);
_spiDevice.TransferFullDuplex(writeBuffer, readBuffer);
int previousReading = ((readBuffer[0] & 0b11111) << 5) | (readBuffer[1] & 0b11111);
if (_endOfConversion != -1)
{
// Wait for ADC to report end of conversion or timeout at max conversion time
_controller.WaitForEvent(_endOfConversion, PinEventTypes.Rising, _conversionTime);
}
else
{
// Max conversion time (21us) as seen in table on page 10 in TLC1543 documentation
DelayHelper.Delay(_conversionTime, false);
}
return(previousReading);
}
/// <summary>
/// Write a PiJuice command
/// </summary>
/// <param name="command">The PiJuice command</param>
/// <param name="data">The data to write</param>
internal void WriteCommand(PiJuiceCommand command, ReadOnlySpan <byte> data)
{
byte tries = 0;
Span <byte> buffer = stackalloc byte[data.Length + 2];
data.CopyTo(buffer.Slice(1));
buffer[0] = (byte)command;
buffer[buffer.Length - 1] = GetCheckSum(data, checkLastByte: true);
// When writing/reading to the I2C port, PiJuice doesn't respond on time in some cases
// So we wait a little bit before retrying
// In most cases, the I2C read/write can go thru without waiting
while (tries < MaxRetries)
{
try
{
_i2cDevice.Write(buffer);
return;
}
catch (IOException ex)
{
tries++;
if (tries >= MaxRetries)
{
throw new IOException($"{nameof(WriteCommand)}: Failed to write command {command}", ex);
}
DelayHelper.DelayMilliseconds(ReadRetryDelay, false);
}
}
}
public async Task <RoundResult> PerformNextRoundAsync()
{
_roundNumber++;
_movementService.ExpiryExplosions();
await DelayHelper.DelayAsync(_delayTime);
_movementService.PerformMissilesMove();
await DelayHelper.DelayAsync(_delayTime);
//call winner
if (_antWarsViewModel.MovableObjectsCollection.OfType <AntModel>().Count() <= 1)
{
return(new RoundResult
{
FinalResult = _botService.GetBotResults(),
IsFinished = true,
History = new List <RoundPartialHistory>()
});
}
var partialResults = await _movementService.PlayAntsMoveAsync(200, _roundNumber);
return(new RoundResult
{
FinalResult = null,
IsFinished = false,
History = partialResults,
});
}
private byte Read_byte(byte register)
{
Change_register(register);
DelayHelper.DelayMilliseconds(10, allowThreadYield: true);
return(_device.ReadByte());
}
public static void IrTest(List <string> argsList, IrReceiver ir)
{
Console.WriteLine($"Ir Test");
double delay;
if (argsList.Count > 1)
{
delay = Convert.ToDouble(argsList[1]);
}
else
{
delay = 10;
}
while (true)
{
int data = ir.GetKey();
if (data == 0 & data != 999)
{
Console.Write($"_");
}
else if (data == 999)
{
Console.WriteLine($"data: repeated last");
}
else
{
Console.WriteLine($"data: {data} ");
}
DelayHelper.DelayMilliseconds((int)delay, true);
}
}
public static void MotorTest(List <string> argsList, DCMotor motorL, DCMotor motorR)
{
double delay;
if (argsList.Count > 1)
{
delay = Convert.ToDouble(argsList[1]);
}
else
{
delay = 10;
}
const double Period = 20.0;
Console.WriteLine($"Motor Test");
Stopwatch sw = Stopwatch.StartNew();
string lastSpeedDisp = null;
while (sw.ElapsedMilliseconds < (Math.PI * 2000))
{
double time = sw.ElapsedMilliseconds / 1000.0;
// Note: range is from -1 .. 1 (for 1 pin setup 0 .. 1)
motorL.Speed = Math.Sin(2.0 * Math.PI * time / Period);
motorR.Speed = Math.Sin(2.0 * Math.PI * time / Period);
string disp = $"Speed[L, R] = [{motorL.Speed:0.00}, {motorR.Speed:0.00}]";
if (disp != lastSpeedDisp)
{
lastSpeedDisp = disp;
Console.WriteLine(disp);
}
DelayHelper.DelayMilliseconds((int)delay, true);
}
}
public static void AdcTest(List <string> argsList, Tlc1543 adc)
{
Console.WriteLine($"ADC Test");
double delay;
byte sensorNumber;
if (argsList.Count > 1)
{
delay = Convert.ToDouble(argsList[1]);
}
else
{
delay = 10;
}
if (argsList.Count > 2)
{
sensorNumber = Convert.ToByte(argsList[2]);
}
else
{
sensorNumber = 11;
}
while (true)
{
for (int i = 0; i < sensorNumber; i++)
{
Console.Write($"{i}: {adc.ReadChannel((Tlc1543.Channel)i),4} ");
DelayHelper.DelayMilliseconds((int)delay, true);
}
Console.WriteLine();
}
}
public void TakeDamage(int damage)
{
Health -= damage;
Debug.Log("Health for " + this.transform.name + " is " + Health);
HitCircle.color = Color.red;
DelayHelper.DelayAction(this, swapToWhite, .7f);
bool deathnoise = false;
if (Health <= 0)
{
if (deathnoise == false)
{
EnemyAudio.clip = AudioExploding;
EnemyAudio.Play();
deathnoise = true;
Exploder.Play();
PLC.UpdateHealth(1);
}
DisableObject();
Debug.Log(this.transform.name + " is " + "dead");
LV.IncreaseScore(5);
if (IsFreezeOn == true)
{
LV.IncreaseScore(5);
}
}
}
public void UpdateHealth(int HPupdate)
{
if (IsImmune == false)
{
if (HPupdate < 0)
{
HP += HPupdate;
AudioHits.clip = AudioDamaged;
AudioHits.Play();
RedBoxLeft.enabled = true;
RedBoxRight.enabled = true;
RedBoxLeft.CrossFadeAlpha(0, .5f, false);
RedBoxRight.CrossFadeAlpha(0, .5f, false);
DelayHelper.DelayAction(this, Resetboxes, .5f);
}
if (HPupdate > 0)
{
if (HP < 5)
{
HP += HPupdate;
}
}
int HealhGUISize = HP * 100;
HealthGUI.rectTransform.sizeDelta = new Vector2(HealhGUISize, 50);
}
}
/// <summary>
/// Calibrates the probe using a single point using a mV value.
/// </summary>
/// <param name="solutionmV">mV value</param>
public void CalibrateSingle(float solutionmV)
{
Write_register((byte)Register.ISE_SOLUTION_REGISTER, solutionmV);
Send_command((byte)Command.ISE_CALIBRATE_SINGLE);
DelayHelper.DelayMilliseconds(ISE_MV_MEASURE_TIME, allowThreadYield: true);
}
//====================================================================
void Update()
{
if (null != m_lstHelper)
{
for (int i = 0; i < m_lstHelper.Count(); ++i)
{
DelayHelper helper = m_lstHelper[i];
helper.delay -= UnityEngine.Time.deltaTime;
if (helper.delay <= 0)
{
m_lstHelper.RemoveAt(i);
i--;
helper.Invoke();
}
}
}
if (null != m_lstUnscaledHelper)
{
for (int i = 0; i < m_lstUnscaledHelper.Count(); ++i)
{
DelayHelper helper = m_lstUnscaledHelper[i];
helper.delay -= UnityEngine.Time.unscaledDeltaTime;
if (helper.delay <= 0)
{
m_lstUnscaledHelper.RemoveAt(i);
i--;
helper.Invoke();
}
}
}
}
private void CancelInvokeWorker(object group)
{
if (null != helperList)
{
if (group == null)
{
for (int i = 0; i < helperList.Count; i++)
{
helperList[i] = null;
}
helperList.Clear();
return;
}
for (int i = 0; i < helperList.Count(); ++i)
{
DelayHelper helper = helperList[i];
if (helper.group == group)
{
helperList.RemoveAt(i);
i--;
}
}
}
}
public async override void Execute(object parameter = null)
{
_viewModel.IsGameInProgress = true;
if (_viewModel.IsGamePaused)
{
_viewModel.IsGamePaused = false;
await _viewModel.ResumeGameAsync();
await DelayHelper.DelayAsync(_viewModel.ArenaConfiguration.GameConfiguration.NextMatchDelay);
}
while (_viewModel.Elimination.GetNextCompetitors() != null && _viewModel.IsGameInProgress)
{
await _viewModel.PlayNextGameAsync();
await DelayHelper.DelayAsync(_viewModel.ArenaConfiguration.GameConfiguration.NextMatchDelay);
}
_viewModel.IsGameInProgress = false;
if (_viewModel.ShouldRestartGame)
{
_viewModel.RestartGame();
}
}
private void StartTransmission()
{
_controller.Write(_pinClk, PinValue.High);
_controller.Write(_pinDio, PinValue.High);
DelayHelper.DelayMicroseconds(ClockWidthMicroseconds, true);
_controller.Write(_pinDio, PinValue.Low);
}
/// <summary>
/// Initializes the bit mode settings.
/// </summary>
protected override void InitializeBitMode()
{
// Prep the pins
_controller.OpenPin(_rsPin, PinMode.Output);
if (_rwPin != -1)
{
_controller.OpenPin(_rwPin, PinMode.Output);
}
if (_backlight != -1)
{
_controller.OpenPin(_backlight, PinMode.Output);
if (_backlightBrightness > 0)
{
// Turn on the backlight
_controller.Write(_backlight, PinValue.High);
}
}
_controller.OpenPin(_enablePin, PinMode.Output);
for (int i = 0; i < _dataPins.Length; ++i)
{
_controller.OpenPin(_dataPins[i], PinMode.Output);
}
// The HD44780 self-initializes when power is turned on to the following settings:
//
// - 8 bit, 1 line, 5x7 font
// - Display, cursor, and blink off
// - Increment with no shift
//
// It is possible that the initialization will fail if the power is not provided
// within specific tolerances. As such, we'll always perform the software based
// initialization as described on pages 45/46 of the HD44780 data sheet. We give
// a little extra time to the required waits.
if (_dataPins.Length == 8)
{
// Init to 8 bit mode
DelayHelper.DelayMilliseconds(50, allowThreadYield: true);
Send(0b0011_0000);
DelayHelper.DelayMilliseconds(5, allowThreadYield: true);
Send(0b0011_0000);
DelayHelper.DelayMicroseconds(100, allowThreadYield: true);
Send(0b0011_0000);
}
else
{
// Init to 4 bit mode, setting _rspin to low as we're writing 4 bits directly.
// (Send writes the whole byte in two 4bit/nybble chunks)
_controller.Write(_rsPin, PinValue.Low);
DelayHelper.DelayMilliseconds(50, allowThreadYield: true);
WriteBits(0b0011, 4);
DelayHelper.DelayMilliseconds(5, allowThreadYield: true);
WriteBits(0b0011, 4);
DelayHelper.DelayMicroseconds(100, allowThreadYield: true);
WriteBits(0b0011, 4);
WriteBits(0b0010, 4);
}
}
public async Task <RoundResult> PerformNextRoundAsync()
{
if (Player1 == null || Player2 == null)
{
throw new Exception("There are no players to perform next round.");
}
var result = new RoundResult()
{
History = new List <RoundPartialHistory>(),
IsFinished = false
};
foreach (var competitor in _competitors)
{
if (IsBoardFull())
{
ClearTheBoard();
}
result.History.Add(await PerformNextMove(competitor));
await DelayHelper.DelayAsync(_configuration.NextMoveDelay);
if (await IsPlayerWon(competitor))
{
result.IsFinished = true;
result.FinalResult = GetResults();
break;
}
}
return(result);
}
public async Task HandleExplodablesAsync(int explosionDisplayTime)
{
_field.Explosions.Clear();
foreach (var missile in _field.Missiles)
{
HandleMissileMovement(missile);
}
foreach (var bomb in _field.Bombs)
{
bomb.RoundsUntilExplodes--;
if (!bomb.IsExploded && bomb.RoundsUntilExplodes == 0)
{
SetExplosion(bomb);
}
}
_field.Bombs.RemoveAll(bomb => bomb.IsExploded);
_field.Missiles.RemoveAll(missile => missile.IsExploded);
_field.OnArenaChanged();
await DelayHelper.DelayAsync(explosionDisplayTime);
_field.Explosions.Clear();
}
private void CancelInvokeWorker(object group)
{
if (null != m_lstHelper)
{
if (group == null)
{
for (int i = 0; i < m_lstHelper.Count; i++)
{
m_lstHelper[i] = null;
}
m_lstHelper.Clear();
return;
}
for (int i = 0; i < m_lstHelper.Count(); ++i)
{
DelayHelper helper = m_lstHelper[i];
if (helper.group == group)
{
m_lstHelper.RemoveAt(i);
i--;
}
}
}
}
private void Write_byte(byte register, byte value)
{
Change_register(register);
_device.WriteByte(value);
DelayHelper.DelayMilliseconds(10, allowThreadYield: true);
}
private async Task SetArenaMessage(string message)
{
ArenaMessage = message;
IsArenaMessageVisible = true;
await DelayHelper.DelayAsync(ArenaConfiguration.ArenaMessageDuration);
IsArenaMessageVisible = false;
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
Resume();
DelayHelper.DelayAction(this, Pause, 0.1f);
}
}
/// <summary>
/// Create a DHT10 sensor through I2C
/// </summary>
/// <param name="i2cDevice">I2C Device</param>
public Dht10(I2cDevice i2cDevice)
: base(i2cDevice)
{
i2cDevice.WriteByte(DHT10_CMD_SOFTRESET);
// make sure DHT10 stable (in the datasheet P7)
DelayHelper.DelayMilliseconds(20, true);
i2cDevice.WriteByte(DHT10_CMD_INIT);
}
private void Send_command(byte data)
{
Span <byte> bytes = stackalloc byte[2];
bytes[0] = (byte)Register.ISE_TASK_REGISTER;
bytes[1] = data;
_device.Write(bytes);
DelayHelper.DelayMilliseconds(10, allowThreadYield: true);
}
private void WakeUpDevice()
{
if (_pinWake >= 0)
{
_controller.Write(_pinWake, PinValue.Low);
// Doc says wait 50 micro seconds
DelayHelper.DelayMicroseconds(50, true);
}
}
private void SleepDownDevice()
{
if (_pinWake >= 0)
{
_controller.Write(_pinWake, PinValue.High);
// Doc says wait 20 micro seconds
DelayHelper.DelayMicroseconds(50, true);
}
}
/// <summary>
/// Initializes the bit mode settings.
/// </summary>
protected override void InitializeBitMode()
{
// Init to 8 bit mode
DelayHelper.DelayMilliseconds(50, allowThreadYield: true);
Send(0b0011_0000);
DelayHelper.DelayMilliseconds(5, allowThreadYield: true);
Send(0b0011_0000);
DelayHelper.DelayMicroseconds(100, allowThreadYield: true);
Send(0b0011_0000);
}
//FIRE PROJECTILE
void Shoot()
{
//create projectile
Instantiate(confuseProjectile, projectileSpawnPoint.position, transform.rotation, projectileParent);
//play projectile effects
PlayShootFeedback();
//prevents from shooting again until DelayAction marks the ship as reloaded
canFire = false;
DelayHelper.DelayAction(this, ReadyToFire, projectileReloadTime);
}
internal override void ReadThroughI2c()
{
// DHT10 has no calibration bits
IsLastReadSuccessful = true;
_i2cDevice.WriteByte(DHT10_CMD_START);
// make sure DHT10 ends measurement (in the datasheet P7)
DelayHelper.DelayMilliseconds(75, true);
_i2cDevice.Read(_dht10ReadBuff);
}
