void Sprite::Input() {
if (GLFW_PRESS == glfwGetKey(GameWindow, GLFW_KEY_W)) {
m_v3Position = m_v3Position + Vector3::Vector3(0.0f, 1.0f, 0.0f);
}
if (GLFW_PRESS == glfwGetKey(GameWindow, GLFW_KEY_A)) {
m_v3Position = m_v3Position + Vector3::Vector3(-1.0f, 0.0f, 0.0f);
}
if (GLFW_PRESS == glfwGetKey(GameWindow, GLFW_KEY_S)) {
m_v3Position = m_v3Position + Vector3::Vector3(0.0f, -1.0f, 0.0f);
}
if (GLFW_PRESS == glfwGetKey(GameWindow, GLFW_KEY_D)) {
m_v3Position = m_v3Position + Vector3::Vector3(1.0f, 0.0f, 0.0f);
}
if (GLFW_PRESS == glfwGetKey(GameWindow, GLFW_KEY_C)) {
m_fZoom *= (1 - getDeltaTime());
}
if (GLFW_PRESS == glfwGetKey(GameWindow, GLFW_KEY_V)) {
m_fZoom *= (1 + getDeltaTime());
}
if (GLFW_PRESS == glfwGetKey(GameWindow, GLFW_KEY_Z)) {
SetColor(
Vector4::Vector4((rand() % 255) / 255.0f, (rand() % 255) / 255.0f, (rand() % 255) / 255.0f, 1.0f),
Vector4::Vector4((rand() % 255) / 255.0f, (rand() % 255) / 255.0f, (rand() % 255) / 255.0f, 1.0f),
Vector4::Vector4((rand() % 255) / 255.0f, (rand() % 255) / 255.0f, (rand() % 255) / 255.0f, 1.0f),
Vector4::Vector4((rand() % 255) / 255.0f, (rand() % 255) / 255.0f, (rand() % 255) / 255.0f, 1.0f)
);
}
}
void CPlayerBase::orbitCameraDeath() {
PROFILE_FUNCTION("orbit camera dead base");
static float angle_orbit_player = 0.f;
angle_orbit_player += getDeltaTime();
float s = sin(angle_orbit_player);
float c = cos(angle_orbit_player);
// translate point back to origin:
TCompTransform* target_transform = myEntity->get<TCompTransform>();
CEntity * camera_e = camera;
//TCompCamera* camera_transform = camera_e->get<TCompCamera>();
TCompTransform* player_transform = camera_e->get<TCompTransform>();
TCompCameraMain* player_cam = camera_e->get<TCompCameraMain>();
VEC3 entPos = player_transform->getPosition();
entPos.x -= target_transform->getPosition().x;
entPos.z -= target_transform->getPosition().z;
// rotate point
float xnew = entPos.x * c - entPos.z * s;
float ynew = entPos.x * s + entPos.z * c;
// translate point back:
entPos.x = xnew + target_transform->getPosition().x;
entPos.z = ynew + target_transform->getPosition().z;
player_transform->setPosition(entPos);
player_cam->update(getDeltaTime());
}
void CPlayerBase::UpdateCinematic(float elapsed) {
static float time_out = 2.f;
time_out -= getDeltaTime();
TCompTransform* player_transform = myEntity->get<TCompTransform>();
float yaw, pitch;
transform->getAngles(&yaw, &pitch);
float dist = simpleDistXZ(cc->GetPosition(), cinematicTargetPos);
if (dist < epsilonPos || time_out <= 0.f) {
if (time_out <= 0.f) cc->teleport(cinematicTargetPos);
time_out = 2.f;
// Reach position
float deltaYaw = cinematicTargetYaw - yaw;
if (abs(deltaYaw) < epsilonYaw) {
//In position and Oriented
onCinematic = false;
logic_manager->throwUserEvent(cinematicEndCode);
ChangeCommonState("idle");
}
else {
//Orientation to target
transform->setAngles(yaw * 0.9f + 0.1f * cinematicTargetYaw, pitch);
}
}
else {
// Go to target
float deltaYaw = transform->getDeltaYawToAimTo(cinematicTargetPos);
if (deltaYaw > epsilonYaw) transform->setAngles(yaw + 0.1f * deltaYaw, pitch);
VEC3 dir = cinematicTargetPos - cc->GetPosition();
dir.y = 0;
dir.Normalize();
cc->AddMovement(dir, player_max_speed * getDeltaTime());
moving = true;
ChangeCommonState("moving");
}
}
void CPlayerBase::update(float elapsed) {
PROFILE_FUNCTION("update base");
if (camera.isValid()) {
if (onCinematic) {
UpdateCinematic(elapsed);
}
else if (controlEnabled || only_sense) {
bool alive = !checkDead();
if (alive && inputEnabled) {
energy_decrease = energy_default_decrease; // Default if nobody change that this frame
UpdateSenseVision();
if (!only_sense) {
UpdateMoves();
UpdateInputActions();
}
setLife(getLife() - getDeltaTime() * energy_decrease);
}
Recalc();
if (alive) {
//UpdateMoves();
myUpdate();
update_msgs();
}
}
//UpdateAnimation();
}
}
void aih_Run(float updateTime)
{
if (tmr_Updateh >= updateTime)
{
moneyh = p_AI.getMoney();
tmr_Updateh = 0.0f;
playerUnitsh = aih_CPU();
unitsh = aih_CU();
idleUnitsh = aih_CUDT(IDLE);
unitAttackersh = aih_CUDT(FIGHT_UNITS);
buildAttackersh = aih_CUDT(FIGHT_BUILDS);
trainingUnitsh = aih_CUIT();
barracksh = aih_CB();
aih_CalcUnits();
aih_CBS();
if (canBuildBarracksh) { aih_PB(); }
else if (canBuildTowerh) { aih_PT(); }
}
else { tmr_Updateh += getDeltaTime(); }
}
//for a given datetime object it calculates the difference between
//server time and arg and returns it in minutes
int JourneyProgressContainer::getEta(double prediction) const {
double deltaInMilliSec = getDeltaTime(prediction);
double deltaInSec = deltaInMilliSec /1000;
double deltaInMin = deltaInSec / 60;
int deltaRound = std::round(deltaInMin);
return deltaRound;
}
void CPlayerBase::UpdateMoves()
{
PROFILE_FUNCTION("update moves base");
TCompTransform* player_transform = myEntity->get<TCompTransform>();
VEC3 player_position = player_transform->getPosition();
VEC3 direction = directionForward + directionLateral;
CEntity * camera_e = camera;
TCompTransform* camera_comp = camera_e->get<TCompTransform>();
direction.Normalize();
float yaw, pitch;
camera_comp->getAngles(&yaw, &pitch);
float new_x, new_z;
new_x = direction.x * cosf(yaw) + direction.z*sinf(yaw);
new_z = -direction.x * sinf(yaw) + direction.z*cosf(yaw);
direction.x = new_x;
direction.z = new_z;
direction.Normalize();
float new_yaw = player_transform->getDeltaYawToAimDirection(direction);
clampAbs_me(new_yaw, player_rotation_speed * getDeltaTime());
player_transform->getAngles(&yaw, &pitch);
player_transform->setAngles(new_yaw + yaw, pitch);
//Set current velocity with friction
float drag = 2.5f*getDeltaTime();
float drag_i = (1 - drag);
if (moving) player_curr_speed = drag_i*player_curr_speed + drag*player_max_speed;
else player_curr_speed = drag_i*player_curr_speed - drag*player_max_speed;
if (player_curr_speed < 0) {
player_curr_speed = 0.0f;
directionForward = directionLateral = VEC3(0, 0, 0);
}
cc->AddMovement(direction, player_curr_speed*getDeltaTime());
if (moving) UpdateMovingWithOther();
}
void AnimSprite::PlayAnimation()
{
m_dElapsedTime += getDeltaTime();
// if the elapsed time is greater than desired frame duration:
if (m_dElapsedTime > m_dFrameDuration)
{
m_dElapsedTime = 0;
switch(currentCycle)
{
//case ONCE, if not at the end of the animation, advance one frame
case ONCE:
if (m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame] != m_mAnimations.at(m_sCurrentAnimation).back())
{
iCurrentFrame++;
m_sCurrentSlice = m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame];
}
break;
//case LOOP, if the animation is at last frame, change frame to "loop marker" frame
case LOOP:
if (m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame] == m_mAnimations.at(m_sCurrentAnimation).back())
{
iCurrentFrame = iLoopMarker;
m_sCurrentSlice = m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame];
}
else
{
iCurrentFrame++;
m_sCurrentSlice = m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame];
}
break;
case PINGPONG:
// if at the end of animation, change direction
if (m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame] == m_mAnimations.at(m_sCurrentAnimation).back())
{
iPlayDirection = -1;
iCurrentFrame += iPlayDirection;
m_sCurrentSlice = m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame];
}
// if at the beginning, change direction
else if (m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame] == m_mAnimations.at(m_sCurrentAnimation).front())
{
iPlayDirection = 1;
iCurrentFrame += iPlayDirection;
m_sCurrentSlice = m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame];
}
else
{
iCurrentFrame += iPlayDirection;
m_sCurrentSlice = m_mAnimations.at(m_sCurrentAnimation)[iCurrentFrame];
}
break;
}
SetSlice();
UVSetup();
}
}
void RandomFailure::RepairItem(FailureVariables& task)
{
double dUpPeriod = CalculateEvent(task.eFailureType, task.dAvgUptime, task.dUptimeStdDev);
if (task.dRepairsDone < 0) //This should only be called on the first iteration
task.dNextFailure = dCurrentTime - getDeltaTime() + dUpPeriod;
else
task.dNextFailure = task.dRepairsDone + dUpPeriod;
task.dRepairsDone = -1;
}
void android_main(struct android_app* state)
{
struct engine engine;
// Make sure glue isn't stripped.
app_dummy();
AndroidAssetManager::Inst(state->activity->assetManager);
AndroidAssetManager::Inst()->openDir((char*)"");
memset(&engine, 0, sizeof(engine));
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
engine.app = state;
if (state->savedState != NULL)
{
// We are starting with a previous saved state; restore from it.
engine.state = *(struct saved_state*)state->savedState;
}
// loop waiting for stuff to do.
while (1)
{
// Read all pending events.
int ident;
int events;
struct android_poll_source* source;
while ((ident=ALooper_pollAll(0, NULL, &events,
(void**)&source)) >= 0)
{
// Process this event.
if (source != NULL)
{
source->process(state, source);
}
// Check if we are exiting.
if (state->destroyRequested != 0)
{
engine_term_display(&engine);
return;
}
}
getDeltaTime();
engine_draw_frame(&engine);
}
}
void movePlayers()
{
if (getKey('w'))
{
player1.yPos -= playerSpeed * getDeltaTime();
}
if (getKey('s'))
{
player1.yPos += playerSpeed * getDeltaTime();
}
if (getKey('l'))
{
player2.yPos += playerSpeed * getDeltaTime();
}
if (getKey('o'))
{
player2.yPos -= playerSpeed * getDeltaTime();
}
}
void bt_scientist::moveFront(float movement_speed) {
SetMyEntity();
if (!myEntity) return;
TCompTransform* transform = myEntity->get<TCompTransform>();
VEC3 front = transform->getFront();
VEC3 position = transform->getPosition();
TCompCharacterController *cc = myEntity->get<TCompCharacterController>();
float dt = getDeltaTime();
cc->AddMovement(VEC3(front.x*movement_speed*dt, 0.0f, front.z*movement_speed*dt));
}
void CPlayerBase::StartFalling()
{
PROFILE_FUNCTION("start falling base");
updateFalling();
if (time_start_falling > max_time_start_falling) {
time_start_falling = 0.f;
ChangeState("falling");
}
else {
time_start_falling += getDeltaTime();
UpdateJumpState();
}
}
unsigned int SceneManager::getFpsForDisplay()
{
static float timeElapse = 0.0f;
timeElapse += getDeltaTime();
if(timeElapse > REFRESH_RATE_FPS)
{ //refresh fps every REFRESH_RATE_FPS_MS
fpsForDisplay = std::lround(fps);
timeElapse = 0.0f;
}
return fpsForDisplay;
}
void Animator::PlayAnimation()
{
elapsedTime += getDeltaTime();
if (elapsedTime > m_dFrames){
elapsedTime = 0;
m_Dirty = true;
switch (currentPlayType){
case ONCE:
if (mAnimations.at(currentAnimation)[currentFrame] != mAnimations.at(currentAnimation).back())
{
currentFrame++;
currentSprite = mAnimations.at(currentAnimation)[currentFrame];
}
break;
case LOOPSECTION:
case LOOP:
if (mAnimations.at(currentAnimation)[currentFrame] == mAnimations.at(currentAnimation).back())
{
currentFrame = loopFrame;
currentSprite = mAnimations.at(currentAnimation)[currentFrame];
}
else
{
currentFrame++;
currentSprite = mAnimations.at(currentAnimation)[currentFrame];
}
break;
case PINGPONG:
break;
case REVERSE:
currentFrame = mAnimations[currentAnimation].size();
loopFrame = currentFrame;
break;
case RANDOMLOOP:
case RANDOM:
/* srand(time(NULL));
currentFrame = rand() % mAnimations[currentAnimation].size();
loopFrame = currentFrame;
*/break;
case SINGLE:
break;
default:
break;
}
SetSprite();
}
}
bool CPlayerBase::turnTo(VEC3 target)
{
float yaw, pitch;
transform->getAngles(&yaw, &pitch);
float deltaYaw = transform->getDeltaYawToAimTo(target);
if (abs(deltaYaw) > epsilonYaw) {
float yaw_added = deltaYaw * getDeltaTime() * player_rotation_speed;
clampAbs_me(yaw_added, abs(deltaYaw));
float new_yaw = yaw + yaw_added;
transform->setAngles(new_yaw, pitch);
return abs(yaw_added) >= (abs(deltaYaw) - epsilonYaw);
}
return true;
}
void shootTarget(Unit &u)
{
if (u.getLastAtk() >= u.getAttackSpeed())
{
PosDim blerg;
PosDim temp = u.getPosDim();
bool inited = false;
float r = u.getAtkRad();
switch (u.getUnitType())
{
case 1:
if (r_Targeted == r_Empty) { u.setTargetStatus(false); u.setTargetInRange(false); }
else { blerg = r_Targeted.getPosDim(); inited = true; }
break;
default:
if (u.isTargetUnit())
{
if (u_Targeted == u_Empty || u.getOwner() == u_Targeted.getOwner()) { u.setTargetStatus(false); u.setTargetInRange(false); }
else { blerg = u_Targeted.getPosDim(); inited = true; }
}
else
{
if (b_Targeted == b_Empty || b_Targeted.getOwner() == u.getOwner()) { u.setTargetStatus(false); u.setTargetInRange(false); }
else { blerg = b_Targeted.getPosDim(); inited = true; }
}
}
if (inited)
{
float dist = sqrt(expo<float>(abs(temp.x - blerg.x), 2) + expo<float>(abs(temp.y - blerg.y), 2));
if (dist <= r)
{
u.setLastAttack(0.0f);
spawnBullet(u, blerg.x, blerg.y);
}
else
{
u.setTargetInRange(false);
u.setTargetCoords(blerg.x, blerg.y);
}
}
}
else
{
u.setLastAttack(u.getLastAtk() + getDeltaTime());
if (u.getLastAtk() < 0.0f) { u.setLastAttack(0.0f); }
}
}
int bt_scientist::actionWaitWpt() {
PROFILE_FUNCTION("scientist: actionwaitwpt");
if (!myParent.isValid()) return false;
stuck = false;
stuck_time = 0.f;
if (t_waitInPos > keyPoints[curkpt].time) {
t_waitInPos = 0;
return OK;
}
else {
t_waitInPos += getDeltaTime();
SET_ANIM_SCI_BT(AST_IDLE);
return STAY;
}
}
void is::Common::tick() {
if ( keyboard->isDown( is::Keyboard::Escape ) || keyboard->isDown( is::Keyboard::Q ) ) {
m_running = false;
return;
}
if ( !window->isOpen() ) {
m_running = false;
return;
}
float dt = getDeltaTime();
states->tick( dt );
window->tick();
world->tick( dt );
gui->tick( dt );
render->tick();
render->draw();
}
bool bt_scientist::aimToTarget(VEC3 target) {
SetMyEntity();
if (!myEntity) return false;
TCompTransform* transform = myEntity->get<TCompTransform>();
float delta_yaw = transform->getDeltaYawToAimTo(target);
if (abs(delta_yaw) > 0.001f) {
float yaw, pitch;
transform->getAngles(&yaw, &pitch);
transform->setAngles(yaw + delta_yaw*SPEED_ROT*getDeltaTime(), pitch);
return false;
}
else {
return true;
}
}
void TouchGrabber::recordTouch(CCTouch *pTouch, TouchEvent event)
{
/// We use the screen coordinate (origin is the upper-left corner) and not the OpenGL coordinate (origin is the top-left corner)
CCPoint pos = pTouch->getLocationInView();
TouchRecord record;
record.x = pos.x;
record.y = pos.y;
record.event = event;
/// Figures out the delta time since the recording started
struct timeval curTime;
gettimeofday(&curTime, NULL);
record.time = getDeltaTime(&mStartRecordTime, &curTime);
mTouchesRecVector.push_back(record);
}
void AnimatedSprite::PlayAnimation() {
m_dElapsedTime += getDeltaTime();
if (m_dElapsedTime > m_dFrames) {
switch (CurrentPlayType) {
case ONCE:
if (mAnimations.at(sCurrentAnimation)[iCurrentFrame] != mAnimations.at(sCurrentAnimation).back()) {
iCurrentFrame++;
sCurrentSprite = mAnimations.at(sCurrentAnimation)[iCurrentFrame];
}
break;
case LOOPSECTION:
case LOOP:
if (mAnimations.at(sCurrentAnimation)[iCurrentFrame] == mAnimations.at(sCurrentAnimation).back()) {
iCurrentFrame = iLoopFrame;
sCurrentSprite = mAnimations.at(sCurrentAnimation)[iCurrentFrame];
} else {
iCurrentFrame++;
sCurrentSprite = mAnimations.at(sCurrentAnimation)[iCurrentFrame];
}
break;
case REVERSE:
iCurrentFrame = mAnimations[sCurrentAnimation].size();
iLoopFrame = iCurrentFrame;
break;
case RANDOMLOOP:
case RANDOM:
srand(time(NULL));
iCurrentFrame = rand() % mAnimations[sCurrentAnimation].size();
iLoopFrame = iCurrentFrame;
break;
default:
break;
}
SetSprite();
SetUVData();
}
}
void SceneManager::display()
{
ScopeProfiler profiler("3d", "sceneMgrDisplay");
//fps
computeFps();
float dt = getDeltaTime();
//renderer
for (auto &activeRenderer : activeRenderers)
{
if(activeRenderer)
{
activeRenderer->display(dt);
}
}
GLenum err;
while((err = glGetError()) != GL_NO_ERROR)
{
throw std::runtime_error("OpenGL error: " + std::to_string(err));
}
}
int bt_scientist::actionWaitInWorkstation() {
PROFILE_FUNCTION("scientist: waitinworkbench");
if (!myParent.isValid()) return false;
stuck = false;
stuck_time = 0.f;
// Turn to the workstation
if (!turnToYaw(ws_yaw)) {
return STAY;
}
// Execute the workstation animation
//animController.setAnim(ws_anim);
// we add a randomly generated offset to the waiting time
int sign = rand() % 100;
int offset = rand() % (int)ws_wait_time_offset;
float total_wait_time = ws_wait_time;
if (sign < 50)
total_wait_time -= offset;
else
total_wait_time += offset;
if (ws_time_waited > total_wait_time) {
ws_time_waited = 0.f;
return OK;
}
else {
ws_time_waited += getDeltaTime();
SET_ANIM_SCI_BT(AST_IDLE);
return STAY;
}
return OK;
}
void CThrowBomb::throwMovement() {
PxTransform tmx;
float speed_real = speed - speed * (lcurrent / lmax)*(lcurrent / lmax)*0.5;
if (lcurrent > lmax) speed_real *= 0.5f;
lcurrent = lcurrent + speed_real * getDeltaTime();
//static int i = 0;
//physics->setKinematic(i++ % 5 != 0);
//TODO if ()speed_real <?)
if (lcurrent < lmax) {
hcurrent = sinf(lcurrent * M_PI / lmax) * hmax;
}
else {
nextState = true;
rd->addForce(PhysxConversion::Vec3ToPxVec3(dir_throw * speed_real * 100.f));
return;
}
nextState = false;
dbg("Lcur = %f, Hcur = %f\n", lcurrent, hcurrent);
tmx = PxTransform(
PhysxConversion::Vec3ToPxVec3(initial_pos + lcurrent * dir_throw + hcurrent * VEC3_UP),
PhysxConversion::CQuaternionToPxQuat(transform->getRotation()));
//rd->setKinematicTarget(tmx);
rd->setGlobalPose(tmx);
}
/*void AnimatedSprite::LoadAnimations(const char* a_pAnimationSheet)
{
tinyxml2::XMLDocument doc;
tinyxml2::XMLNode *rootNode, *currentNode;
tinyxml2::XMLElement *childElement, *child;
std::string str,aniName;
doc.LoadFile(a_pAnimationSheet);
rootNode = doc.FirstChildElement("animation");
currentNode = rootNode;
for (childElement = currentNode->ToElement();
childElement != NULL; childElement = childElement->NextSiblingElement())
{
aniName = childElement->Attribute("name");
int i = 0;
for (child = childElement->FirstChildElement();
child != NULL; child = child->NextSiblingElement())
{
str = child->Attribute("name");
mAnimations[aniName].push_back(str);
i++;
}
}
std:printf("done");
}
void AnimatedSprite::SetAnimation(std::string animation,PlayType type)
{
//Set currentAnimation to animation
currentAnimation = animation;
//Set currentFrame and loopFrame to 0
currentFrame = 0;
loopFrame = 0;
//Set currentPlayType to type
currentPlayType = type;
//Make a switch for type
switch (type)
{
//Case ONCE
case ONCE:
break;
//Case LOOP
case LOOP:
loopFrame = 0;
break;
//Case PINGPONG
case PINGPONG:
break;
//Case REVERSE
case REVERSE:
currentFrame = mAnimations[currentAnimation].size();
loopFrame = currentFrame;
break;
//Case RANDOMLOOP
case RANDOMLOOP:
//Case RANDOM
case RANDOM:
srand(time(NULL));
currentFrame = (unsigned int)(rand() % mAnimations[currentAnimation].size());
loopFrame = currentFrame;
break;
//Case LOOPSECTION
case LOOPSECTION:
SetAnimation(animation,type, 0);
//Case SINGLE
case SINGLE:
break;
//Default
default:
break;
}
//Set currentSprite to currentAnimation's currentFrame
currentSprite = mAnimations.at(currentAnimation)[currentFrame];
//Call SetSprite
SetSprite();
//Call SetUVData
SetUVData();
}
void AnimatedSprite::SetAnimation(std::string animation,PlayType type, int frame)
{
//Make a switch for type
switch(type)
{
//Case LOOPSECTION
case LOOPSECTION:
currentAnimation = animation;
currentFrame = 0;
currentPlayType = type;
loopFrame = frame;
break;
//Default
default:
SetAnimation(animation,type);
break;
}
}*/
void AnimatedSprite::PlayAnimation()
{
//Add getDeltaTime to elapsedTime
elapsedTime += getDeltaTime();
//If elapsedTime is greater than m_dFrames
if(elapsedTime > m_dFrames)
{
// Reset elapsed time
elapsedTime = 0;
//Make currentFrame equal 1
if(currentFrame == 1)
{
currentFrame = 0;
}
else
{
currentFrame = 1;
}
//Call SetSprite
SetSprite();
//Call SetUVData
SetUVData();
}
}
void RandomFailure::EvalCtrlActions(eScdCtrlTasks Tasks)
{
RevalidateDataFields();
dCurrentTime += getDeltaTime();
for (int i = 0; i < tasks.size(); i++)
{
if (!bOn)
{
tasks.at(i)->bRunning = true;
}
else
try
{
while (true)
{
if (tasks.at(i)->dRepairsDone < 0) //Item is running
{
if (tasks.at(i)->dNextFailure < 0) //Item has not been initialized
RepairItem(*tasks.at(i));
if (tasks.at(i)->dNextFailure < dCurrentTime) //Item will go down in this iteration
FailItem(*tasks.at(i));
else
break;
}
else //Item is being repaired
{
if (tasks.at(i)->dRepairsDone < dCurrentTime) //Item will be repaired in this iteration
RepairItem(*tasks.at(i));
else
break;
}
}
bool bNowRunning = tasks.at(i)->dBackedUpDowntime < getDeltaTime();
if (tasks.at(i)->TagSubs.IsActive)
{
if (bNowRunning &! tasks.at(i)->bRunning) //Task is starting up again, set tag to OnValue
tasks.at(i)->TagSubs.DoubleSI = tasks.at(i)->dOnValue;
if (!bNowRunning && tasks.at(i)->bRunning) //Task is shutting down, set tag to 0
tasks.at(i)->TagSubs.DoubleSI = tasks.at(i)->dOffValue;
}
tasks.at(i)->bRunning = bNowRunning;
if (!tasks.at(i)->bRunning)
{
tasks.at(i)->dTotalDowntime += getDeltaTime();
tasks.at(i)->dBackedUpDowntime -= getDeltaTime();
}
}
catch (MMdlException &ex)
{
Log.Message(MMsg_Error, ex.Description);
}
catch (MFPPException &e)
{
e.ClearFPP();
Log.Message(MMsg_Error, e.Description);
}
catch (MSysException &e)
{
Log.Message(MMsg_Error, e.Description);
}
catch (...)
{
Log.Message(MMsg_Error, "Some Unknown Exception occured");
}
}
}
void moveUnit(Unit &u)
{
PosDim temp = u.getPosDim();
float n[] = { u.getTargetX(), u.getTargetY(), temp.x - n[0], temp.y - n[1] };
if (u.getTarget() != NOTHING)
{
if (u.doesUnitHaveTarget())
{
float r = u.getAtkRad();
bool inited = false;
PosDim blerg;
switch (u.getUnitType())
{
case 1:
if (r_AllDynam[u.getTargetedResource()] == r_Empty) { u.setTargetStatus(false); u.setTargetInRange(false); }
else { blerg = r_AllDynam[u.getTargetedResource()].getPosDim(); inited = true; }
break;
default:
if (u.isTargetUnit())
{
if (u_AllDynam[u.getTargetedUnit()] == u_Empty) { u.setTargetStatus(false); u.setTargetInRange(false); }
else { blerg = u_AllDynam[u.getTargetedUnit()].getPosDim(); inited = true; }
}
else
{
if (b_AllDynam[u.getTargetedBuild()] == b_Empty) { u.setTargetStatus(false); u.setTargetInRange(false); }
else { blerg = b_AllDynam[u.getTargetedBuild()].getPosDim(); inited = true; }
}
}
if (inited)
{
float dist = sqrt(expo<float>(abs(temp.x - blerg.x), 2) + expo<float>(abs(temp.y - blerg.y), 2));
if (dist <= r)
{
u.stopMoving();
u.setTargetInRange(true);
}
else
{
u.setTargetInRange(false);
u.setTargetCoords(blerg.x, blerg.y);
}
}
}
}
if (n[2] <= 1 && n[2] >= -1 && n[3] <= 1 && n[3] >= -1)
{
u.stopMoving();
}
else if (u.doesUnitHaveSlope() && !u.isTargetInRange())
{
if (n[0] < temp.x) { temp.x -= u.getSpeedX() * getDeltaTime(); }
else { temp.x += u.getSpeedX() * getDeltaTime(); }
if (n[1] < temp.y) { temp.y -= u.getSpeedY() * getDeltaTime(); }
else { temp.y += u.getSpeedY() * getDeltaTime(); }
}
else
{
float time = (sqrt(expo<float>(n[2], 2) + expo<float>(n[3], 2))) / (u.getSpeed());
u.setAxisSpeeds(abs(n[2]) / time, abs(n[3]) / time);
if (n[0] < temp.x) { temp.x -= u.getSpeedX() * getDeltaTime(); }
else if (n[0] > temp.x) { temp.x += u.getSpeedX() * getDeltaTime(); }
if (n[1] < temp.y) { temp.y -= u.getSpeedY() * getDeltaTime(); }
else if (n[1] > temp.y) { temp.y += u.getSpeedY() * getDeltaTime(); }
}
u.setPosDim(temp);
}
MStatus
simpleFluidEmitter::fluidEmitter(
const MObject& fluidObject,
const MMatrix& worldMatrix,
int plugIndex
)
//==============================================================================
//
// Description:
//
// Callback function that gets called once per frame by each fluid
// into which this emitter is emitting. Emits values directly into
// the fluid object. The MFnFluid object passed to this routine is
// not pointing to a DAG object, it is pointing to an internal fluid
// data structure that the fluid node is constructing, eventually to
// be set into the fluid's output attribute.
//
// Parameters:
//
// fluid: fluid into which we are emitting
// worldMatrix: object->world matrix for the fluid
// plugIndex: identifies which fluid connected to the emitter
// we are emitting into
//
// Returns:
//
// MS::kSuccess if the method wishes to override the default
// emitter behaviour
// MS::kUnknownParameter if the method wishes to have the default
// emitter behaviour execute after this routine
// exits.
//
// Notes:
//
// The method first does some work common to all emitter types, then
// calls one of 4 different methods to actually do the emission.
// The methods are:
//
// omniEmitter: omni-directional emitter from a point,
// or from the vertices of an owner object.
//
// volumeEmitter: emits from the surface of an exact cube, sphere,
// cone, cylinder, or torus.
//
// surfaceEmitter: emits from the surface of an owner object.
//
//==============================================================================
{
// make sure the fluid is valid. If it isn't, return MS::kSuccess, indicating
// that no work needs to be done. If we return a failure code, then the default
// fluid emitter code will try to run, which is pointless if the fluid is not
// valid.
//
MFnFluid fluid( fluidObject );
if( fluid.object() != MObject::kNullObj )
{
return MS::kSuccess;
}
// get a data block for the emitter, so we can get attribute values
//
MDataBlock block = forceCache();
// figure out the time interval for emission for the given fluid
//
double dTime = getDeltaTime( plugIndex, block ).as(MTime::kSeconds);
if( dTime == 0.0 )
{
// shouldn't happen, but if the time interval is 0, then no fluid should
// be emitted
return MS::kSuccess;
}
// if currentTime <= startTime, return. The startTime is connected to
// the target fluid object.
//
MTime cTime = getCurrentTime( block );
MTime sTime = getStartTime( plugIndex, block );
// if we are at or before the start time, reset the random number
// state to the appropriate seed value for the given fluid
//
if( cTime < sTime )
{
resetRandomState( plugIndex, block );
return MS::kSuccess;
}
// check to see if we need to emit anything into the target fluid.
// if the emission rate is 0, or if the fluid doesn't have a grid
// for one of the quantities, then we needn't do any emission
//
// emission rates
double density = fluidDensityEmission( block );
double heat = fluidHeatEmission( block );
double fuel = fluidFuelEmission( block );
bool doColor = fluidEmitColor( block );
// fluid grid settings
MFnFluid::FluidMethod densityMode, tempMode, fuelMode;
MFnFluid::ColorMethod colorMode;
MFnFluid::FluidGradient grad;
MFnFluid::FalloffMethod falloffMode;
fluid.getDensityMode( densityMode, grad );
fluid.getTemperatureMode( tempMode, grad );
fluid.getFuelMode( fuelMode, grad );
fluid.getColorMode( colorMode );
fluid.getFalloffMode( falloffMode );
// see if we need to emit density, heat, fuel, or color
bool densityToEmit = (density != 0.0) && ((densityMode == MFnFluid::kDynamicGrid)||(densityMode == MFnFluid::kStaticGrid));
bool heatToEmit = (heat != 0.0) && ((tempMode == MFnFluid::kDynamicGrid)||(tempMode == MFnFluid::kStaticGrid));
bool fuelToEmit = (fuel != 0.0) && ((fuelMode == MFnFluid::kDynamicGrid)||(fuelMode == MFnFluid::kStaticGrid));
bool colorToEmit = doColor && ((colorMode == MFnFluid::kDynamicColorGrid)||(colorMode == MFnFluid::kStaticColorGrid));
bool falloffEmit = (falloffMode == MFnFluid::kStaticFalloffGrid);
// nothing to emit, do nothing
//
if( !densityToEmit && !heatToEmit && !fuelToEmit && !colorToEmit && !falloffEmit )
{
return MS::kSuccess;
}
// get the dropoff rate for the fluid
//
double dropoff = fluidDropoff( block );
// modify the dropoff rate to account for fluids that have
// been scaled in worldspace - larger scales mean slower
// falloffs and vice versa
//
MTransformationMatrix xform( worldMatrix );
double xformScale[3];
xform.getScale( xformScale, MSpace::kWorld );
double dropoffScale = sqrt( xformScale[0]*xformScale[0] +
xformScale[1]*xformScale[1] +
xformScale[2]*xformScale[2] );
if( dropoffScale > 0.1 )
{
dropoff /= dropoffScale;
}
// retrieve the current random state from the "randState" attribute, and
// store it in the member variable "randState". We will use this member
// value numerous times via the randgen() method. Once we are done emitting,
// we will set the random state back into the attribute via setRandomState().
//
getRandomState( plugIndex, block );
// conversion value used to map user input emission rates into internal
// values.
//
double conversion = 0.01;
MEmitterType emitterType = getEmitterType( block );
switch( emitterType )
{
case kOmni:
omniFluidEmitter( fluid, worldMatrix, plugIndex, block, dTime,
conversion, dropoff );
break;
case kVolume:
volumeFluidEmitter( fluid, worldMatrix, plugIndex, block, dTime,
conversion, dropoff );
break;
case kSurface:
surfaceFluidEmitter( fluid, worldMatrix, plugIndex, block, dTime,
conversion, dropoff );
break;
default:
break;
}
// store the random state back into the datablock
//
setRandomState( plugIndex, block );
return MS::kSuccess;
}
// tag::updateSimulation[]
void updateSimulation(double simLength = 0.02) //update simulation with an amount of time to simulate for (in seconds)
{
dt = getDeltaTime();
player->movement();
player->animFrameBuffer++;
player->rect.x += moveX * moveSpeed * simLength;
int deletedSpritesCount = 0;
for (int i = 0; i < sprites.size() - deletedSpritesCount; i++)//auto object : sprites)
{
checkCollision(sprites[i], i);
}
for (auto hen : hens)
{
if (boundaryCollide(hen))
{
//player die
player->rect.x = 50;
player->rect.y = 540;
player->playerLives -= 1;
lifeCount->setLife(ren, player->playerLives);
}
float startPoint = hen->rect.x;
float endPoint = hen->xTarget1;
if (hen->rect.x < endPoint)
{
hen->rect.x += 25 * simLength;
}
else
{
hen->rect.x -= 25 * simLength;
}
}
//hen1->animateEnemy();
#pragma region On Ladder Move Check
if (onLadder)
{
gravity = 0.0f;
player->rect.y += moveY * simLength * moveSpeed; // This should work for now
}
else
{
player->rect.y += gravity * simLength * moveSpeed / 2; // This will need chagning up a bit to account for player jumping and stuff
}
#pragma endregion
#pragma region Platform collision
// Check that the player doesnt fall out of the screen
if ((player->rect.y + player->rect.h) >= screenH - 1)
{
gravity = 0.0f;
//std::cout << "Collision Detected" << std::endl;
}
else
{
gravity = 10.0f;
}
#pragma endregion
onLadder = false;
Mix_VolumeMusic(volume);
if (isMusPaused)
{
Mix_PauseMusic();
}
else
{
Mix_ResumeMusic();
}
}
