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(); } }