void
DeviceDescriptor::OnSysTicker()
{
assert(InMainThread());
if (port != nullptr && port->GetState() == PortState::FAILED && !IsOccupied())
Close();
if (device == nullptr)
return;
const bool now_alive = IsAlive();
if (!now_alive && was_alive && !IsOccupied()) {
/* connection was just lost */
device->LinkTimeout();
NullOperationEnvironment env;
EnableNMEA(env);
}
was_alive = now_alive;
if (now_alive || IsBorrowed()) {
ticker = !ticker;
if (ticker)
// write settings to vario every second
device->OnSysTicker();
}
}
void VehicleExit() override
{
if (IsOccupied())
{
exitCount += 1;
state = Empty;
vehicle.reset();
}
}
void
DeviceDescriptor::Return()
{
assert(InMainThread());
assert(IsBorrowed());
borrowed = false;
assert(!IsOccupied());
/* if the caller has disabled the NMEA while the device was
borrowed, we may not have received new values for some time, but
that doesn't mean the device has failed; give it some time to
recover, and don't reopen right away */
reopen_clock.Update();
}
void ScoreManager::CheckForFullColls()
{
std::vector<int> filledRows;
int bottomRow = -1;
for(int y = m_blockGrid.size() - 1; y > -1; y--)
{
int squaresFilled = 0;
for(unsigned int x = 0; x < m_blockGrid[0].size(); x++)
{
if(IsOccupied(x, y))
{ squaresFilled++; }
}
if(squaresFilled == m_blockGrid[0].size())
{
filledRows.push_back(y);
if(bottomRow == -1)
{ bottomRow = y; }
}
}
if(filledRows.size() == 0)
{ return; }
for(unsigned int i = 0; i < filledRows.size(); i++)
{
int row = filledRows[i];
for(unsigned int x = 0; x < m_blockGrid[0].size(); x++)
{
m_blockGrid[row][x]->Destroy();
m_blockGrid[row][x] = NULL;
}
}
RepositionSquares(bottomRow, filledRows.size());
if(filledRows.size() < 4)
{ m_currentScore += filledRows.size() * 100; }
else
{
m_currentScore += 800;
m_currentScore += (filledRows.size() - 4) * 100;
}
SoundManager::Instance->PlayClip(SoundManager::Sounds::RowCleared, false);
}
void CVehicle::CheckForIdleRespawn()
{
// can't respawn an idle train or train part
if(IsATrainPart()) return;
if( (GetTickCount() - m_dwLastRespawnedTick) < 10000 ) {
// We should wait at least 10 seconds after the last
// respawn before checking. Come back later.
return;
}
if(!IsOccupied()) {
if( m_bHasBeenOccupied &&
(GetTickCount() - m_dwLastSeenOccupiedTick) >= (DWORD)m_SpawnInfo.iRespawnDelay ) {
//printf("Respawning idle vehicle %u\n",m_VehicleID);
Respawn();
}
}
}
void
DeviceDescriptor::AutoReopen(OperationEnvironment &env)
{
assert(InMainThread());
if (/* don't reopen a device that is occupied */
IsOccupied() ||
!config.IsAvailable() ||
!ShouldReopen() ||
/* attempt to reopen a failed device every 30 seconds */
!reopen_clock.CheckUpdate(30000))
return;
TCHAR buffer[64];
LogStartUp(_T("Reconnecting to device %s"), config.GetPortName(buffer, 64));
InputEvents::processGlideComputer(GCE_COMMPORT_RESTART);
Reopen(env);
}
HRESULT CVisualTree::AddVisual(CVisualObject * pVisual, bool fEnsureOpenSpace)
{
assert(pVisual != NULL);
m_Objects.Add(pVisual);
if(fEnsureOpenSpace)
{
while(IsOccupied(pVisual))
{
pVisual->AddPosition(120, 0);
if(pVisual->Rect().x() > 600)
{
pVisual->Move(20, pVisual->Rect().y() + 120);
}
}
}
return S_OK;
}
void
DeviceDescriptor::AutoReopen(OperationEnvironment &env)
{
assert(InMainThread());
if (/* don't reopen a device that is occupied */
IsOccupied() ||
!config.IsAvailable() ||
!ShouldReopen() ||
/* attempt to reopen a failed device every 30 seconds */
!reopen_clock.CheckUpdate(30000))
return;
#ifdef ANDROID
if (config.port_type == DeviceConfig::PortType::RFCOMM &&
android_api_level < 11 && n_failures >= 2) {
/* on Android < 3.0, system_server's "BT EventLoop" thread
eventually crashes with JNI reference table overflow due to a
memory leak after too many Bluetooth failures
(https://code.google.com/p/android/issues/detail?id=8676);
don't attempt to reconnect on this Android version over and
over to keep the chance of this bug occurring low enough */
if (n_failures == 2) {
LogFormat(_T("Giving up on Bluetooth device %s to avoid Android crash bug"),
config.bluetooth_mac.c_str());
++n_failures;
}
return;
}
#endif
TCHAR buffer[64];
LogFormat(_T("Reconnecting to device %s"), config.GetPortName(buffer, 64));
InputEvents::processGlideComputer(GCE_COMMPORT_RESTART);
Reopen(env);
}
void
DeviceDescriptor::Open(OperationEnvironment &env)
{
assert(InMainThread());
assert(port == nullptr);
assert(device == nullptr);
assert(!ticker);
assert(!IsBorrowed());
if (is_simulator() || !config.IsAvailable())
return;
CancelAsync();
assert(!IsOccupied());
assert(open_job == nullptr);
TCHAR buffer[64];
LogFormat(_T("Opening device %s"), config.GetPortName(buffer, 64));
open_job = new OpenDeviceJob(*this);
async.Start(open_job, env, this);
}
void ScoreManager::RepositionSquares(int bottomRow, int rowCount)
{
for(int y = bottomRow; y > -1; y--)
{
for(unsigned int x = 0; x < m_blockGrid[0].size(); x++)
{
SmartPtr<Square> square = m_blockGrid[y][x];
if(square == NULL)
{ continue; }
bool foundCollision = false;
int coll = square->GetColl();
int row = square->GetRow();
int newY = row;
while(!foundCollision)
{
if(newY == Settings::NoOfRows || (IsOccupied(coll, newY) && newY != row) || (newY - row) == rowCount + 1)
{
foundCollision = true;
newY--;
break;
}
newY++;
}
if(newY != row)
{
square->SetPosition(coll, newY);
m_blockGrid[y][x] = NULL;
m_blockGrid[newY][x] = square;
}
}
}
}
void Taxi::Update(float time, float seconds)
{
//m_position.y = sinf(time * (((m_speed + 1) / 13.0f) * 1.0f)) * 0.5f + 0.5f;
//m_position.y *= 0.5f;
sm::Vec3 oldPos = m_position;
if (IsOccupied())
{
m_timeLeft -= seconds;
if (m_timeLeft < 0.0f)
m_timeLeft = 0.0f;
}
sm::Vec3 turnPivot;
sm::Matrix turnMatrix;
float pivotDistance = 0.0f;
m_speed += m_acc * 5.0f * seconds;
static float maxSpeed = 14.0f;
if (m_acc == 0.0f)
{
m_speed -= MathUtils::Min(MathUtils::Abs(m_speed), 8.0f * seconds) * MathUtils::Sign(m_speed);
}
if (m_speed > 0.0f && m_acc == -1.0f)
{
m_speed -= MathUtils::Min(MathUtils::Abs(m_speed), 12.0f * seconds) * MathUtils::Sign(m_speed);
}
m_speed = MathUtils::Clamp(m_speed, -maxSpeed / 4, maxSpeed);
SoundManager::GetInstance()->SetEnginePitch((MathUtils::Abs(m_speed) / maxSpeed) * 1.0f + 1.0f);
m_wheelsAngle += 2.0f * m_turnValue * seconds;
m_wheelsAngle = MathUtils::Clamp(m_wheelsAngle, -MathUtils::PI4, MathUtils::PI4);
if (m_wheelsAngle != 0.0f)
{
if (m_wheelsAngle < 0.0)
{
pivotDistance = m_backFrontWheelsDistance / tanf(fabs(m_wheelsAngle));
turnPivot = sm::Vec3(m_baseBackRightWheelPosition.x + pivotDistance, 0, m_baseBackRightWheelPosition.z);
}
else
{
pivotDistance = m_backFrontWheelsDistance / tanf(fabs(m_wheelsAngle));
turnPivot = sm::Vec3(m_baseBackLeftWheelPosition.x - pivotDistance, 0, m_baseBackLeftWheelPosition.z);
}
float angleSpeed = m_speed / (2.0f * MathUtils::PI * MathUtils::Abs(turnPivot.x));
sm::Matrix turnMatrixNormal =
sm::Matrix::RotateAxisMatrix(
angleSpeed * (MathUtils::PI * 2.0f) * seconds * MathUtils::Sign(m_wheelsAngle),
0, 1, 0);
turnPivot = m_worldMatrix * turnPivot;
turnPivot.y = 0.0f;
turnMatrix =
sm::Matrix::TranslateMatrix(turnPivot) *
turnMatrixNormal *
sm::Matrix::TranslateMatrix(turnPivot.GetReversed());
sm::Vec3 prevCarDirection = m_carDirection;
m_carDirection = turnMatrixNormal * m_carDirection;
m_carDirection.Normalize();
float angleDiff = sm::Vec3::GetAngle(prevCarDirection, m_carDirection);
m_wheelsAngle -= angleDiff * MathUtils::Sign(m_wheelsAngle);
m_position = turnMatrix * m_position;
}
else
m_position += m_carDirection * m_speed * seconds;
sm::Matrix newWorldMatrix =
sm::Matrix::TranslateMatrix(m_position) *
sm::Matrix::CreateLookAt(m_carDirection.GetReversed(), sm::Vec3(0, 1, 0));
sm::Vec3 boundsTopLeftWorldOld = m_worldMatrix * m_boundsTopLeft;
sm::Vec3 boundsBottomLeftWorldOld = m_worldMatrix * m_boundsBottomLeft;
sm::Vec3 boundsTopRightWorldOld = m_worldMatrix * m_boundsTopRight;
sm::Vec3 boundsBottomRightWorldOld = m_worldMatrix * m_boundsBottomRight;
sm::Vec3 boundsTopLeftWorldNew = newWorldMatrix * m_boundsTopLeft;
sm::Vec3 boundsBottomLeftWorldNew = newWorldMatrix * m_boundsBottomLeft;
sm::Vec3 boundsTopRightWorldNew = newWorldMatrix * m_boundsTopRight;
sm::Vec3 boundsBottomRightWorldNew = newWorldMatrix * m_boundsBottomRight;
sm::Vec3 collisionNormal;
sm::Vec3 collisionPoint;
if (Street::Instance->GetCollistion(boundsTopLeftWorldOld, boundsTopLeftWorldNew, collisionPoint, collisionNormal))
{
if (m_speed > 4.0f)
{
static Randomizer random;
SoundManager::GetInstance()->PlaySound((SoundManager::Sound)random.GetInt(0, 2));
}
float dot = sm::Vec3::Dot(collisionNormal, m_carDirection.GetReversed());
if (dot > 0.8 && m_speed > 3.0f)
m_speed = -3.0f;
else
m_speed *= 1.0f - sm::Vec3::Dot(collisionNormal, m_carDirection.GetReversed());
collisionPoint += collisionNormal * 0.01f;
sm::Vec3 toCollisionTarget = collisionPoint - boundsTopLeftWorldOld;
sm::Vec3 fromCollisionTarget = sm::Vec3::Reflect(collisionNormal, toCollisionTarget);
sm::Vec3 correntPosition = boundsTopLeftWorldOld + toCollisionTarget + fromCollisionTarget;
sm::Vec3 deltaMove = collisionPoint - boundsTopLeftWorldOld;
m_carDirection = (collisionPoint - boundsBottomLeftWorldOld).GetNormalized();
m_position = oldPos + deltaMove;
m_worldMatrix =
sm::Matrix::TranslateMatrix(m_position) *
sm::Matrix::CreateLookAt(m_carDirection.GetReversed(), sm::Vec3(0, 1, 0));
}
else if (Street::Instance->GetCollistion(boundsTopRightWorldOld, boundsTopRightWorldNew, collisionPoint, collisionNormal))
{
if (m_speed > 4.0f)
{
static Randomizer random;
SoundManager::GetInstance()->PlaySound((SoundManager::Sound)random.GetInt(0, 2));
}
float dot = sm::Vec3::Dot(collisionNormal, m_carDirection.GetReversed());
if (dot > 0.8 && m_speed > 3.0f)
m_speed = -3.0f;
else
m_speed *= 1.0f - sm::Vec3::Dot(collisionNormal, m_carDirection.GetReversed());
collisionPoint += collisionNormal * 0.01f;
sm::Vec3 toCollisionTarget = collisionPoint - boundsTopRightWorldOld;
sm::Vec3 fromCollisionTarget = sm::Vec3::Reflect(collisionNormal, toCollisionTarget);
sm::Vec3 correntPosition = boundsTopRightWorldOld + toCollisionTarget + fromCollisionTarget;
sm::Vec3 deltaMove = collisionPoint - boundsTopRightWorldOld;
m_carDirection = (collisionPoint - boundsBottomRightWorldOld).GetNormalized();
m_position = oldPos + deltaMove;
m_worldMatrix =
sm::Matrix::TranslateMatrix(m_position) *
sm::Matrix::CreateLookAt(m_carDirection.GetReversed(), sm::Vec3(0, 1, 0));
}
/*else if (Street::Instance->GetCollistion(boundsBottomRightWorldOld, boundsBottomRightWorldNew, collisionPoint, collisionNormal))
{
if (m_speed > 4.0f)
{
static Randomizer random;
SoundManager::GetInstance()->PlaySound((SoundManager::Sound)random.GetInt(0, 2));
}
float dot = sm::Vec3::Dot(collisionNormal, m_carDirection.GetReversed());
if (dot > 0.8 && m_speed > 3.0f)
m_speed = -3.0f;
else
m_speed *= 1.0f - sm::Vec3::Dot(collisionNormal, m_carDirection.GetReversed());
collisionPoint += collisionNormal * 0.01f;
sm::Vec3 toCollisionTarget = collisionPoint - boundsBottomRightWorldOld;
sm::Vec3 fromCollisionTarget = sm::Vec3::Reflect(collisionNormal, toCollisionTarget);
sm::Vec3 correntPosition = boundsBottomRightWorldOld + toCollisionTarget + fromCollisionTarget;
sm::Vec3 deltaMove = collisionPoint - boundsBottomRightWorldOld;
m_carDirection = (boundsTopRightWorldOld - collisionPoint).GetNormalized();
m_position = oldPos + deltaMove;
m_worldMatrix =
sm::Matrix::TranslateMatrix(m_position) *
sm::Matrix::CreateLookAt(m_carDirection.GetReversed(), sm::Vec3(0, 1, 0));
}*/
else if (Street::Instance->GetCollistion(boundsBottomRightWorldOld, boundsBottomRightWorldNew, collisionPoint, collisionNormal))
{
if (m_speed > 4.0f)
{
static Randomizer random;
SoundManager::GetInstance()->PlaySound((SoundManager::Sound)random.GetInt(0, 2));
}
m_position = oldPos + collisionNormal * 0.1f;
m_speed = 0.0f;
m_worldMatrix =
sm::Matrix::TranslateMatrix(m_position) *
sm::Matrix::CreateLookAt(m_carDirection.GetReversed(), sm::Vec3(0, 1, 0));
}
else if (Street::Instance->GetCollistion(boundsBottomLeftWorldOld, boundsBottomLeftWorldNew, collisionPoint, collisionNormal))
{
if (m_speed > 4.0f)
{
static Randomizer random;
SoundManager::GetInstance()->PlaySound((SoundManager::Sound)random.GetInt(0, 2));
}
m_position = oldPos + collisionNormal * 0.1f;
m_speed = 0.0f;
m_worldMatrix =
sm::Matrix::TranslateMatrix(m_position) *
sm::Matrix::CreateLookAt(m_carDirection.GetReversed(), sm::Vec3(0, 1, 0));
}
else
m_worldMatrix = newWorldMatrix;
m_frontRightWheel->Transform() =
m_frontRightWheel->m_worldMatrix *
sm::Matrix::RotateAxisMatrix(m_wheelsAngle, 0, 1, 0) *
m_frontRightWheel->m_worldInverseMatrix;
m_frontLeftWheel->Transform() =
m_frontLeftWheel->m_worldMatrix *
sm::Matrix::RotateAxisMatrix(m_wheelsAngle, 0, 1, 0) *
m_frontLeftWheel->m_worldInverseMatrix;
}
/**
* Can this device be borrowed?
*
* May only be called from the main thread.
*
* @see Borrow()
*/
bool CanBorrow() const {
assert(InMainThread());
return device != nullptr && GetState() == PortState::READY &&
!IsOccupied();
}
~DeviceDescriptor() {
assert(!IsOccupied());
}
inline bool StoneBoard::IsEmpty(HexPoint cell) const
{
BenzeneAssert(Const().IsLocation(cell));
return !IsOccupied(cell);
}
/**
* Can this device be borrowed?
*
* May only be called from the main thread.
*
* @see Borrow()
*/
bool CanBorrow() const {
return device != NULL && port != NULL && !IsOccupied();
}
