void PLAYBACK::restoreLastPosition()
{
if (getLastPosition() > currFrameCounter)
{
if (emuPausedState)
startSeekingToFrame(getLastPosition());
else
pauseEmulation();
}
}
// Gets the next position block (bitstring of positions) from the operator
PosBlock* DataSource::getNextPosBlock(int colIndex_) {
if (colIndex_!=0) return NULL;
if (valSorted && isROS) {
//Log::writeToLog("IntDataSource", 0, "getNextPosBlock(), called on valSorted col");
if (!posOutTripleOnPred->isNull()) return NULL;
if (posOutBlock==NULL) posOutBlock=new PosRLEBlock();
if (pred!=NULL) {
//Not sure how to write generalized code for this yet, so
//I'll leave unimplemented for now
throw new UnimplementedException("Figure out how to code this when it is actually needed");
}
else if (valFilter!=NULL)
throw new UnimplementedException("Value filtering still unimplemented");
else {
unsigned int minPos=1;
unsigned int maxPos=getLastPosition();
posOutTripleOnPred->setTriple(NULL, minPos, maxPos-minPos+1);
((PosRLEBlock*) posOutBlock)->setTriple(posOutTripleOnPred);
cout << "Returning posTriple" << endl;
return posOutBlock;
}
}
// The column is not value sorted or is a WOS column
else {
Block* b;
b = getNextValBlock(am);
if (b==NULL) return NULL;
else return currBlockWP->getPosBlockIter();
}
}
void Caret::moveToPosition(int position)
{
myLocation.setPositionIndex(boost::algorithm::clamp(position, 0,
getLastPosition()));
myLocation.setSelectionStart(myLocation.getPositionIndex());
onLocationChanged();
}
//-------------------------------------------------------------------------------------
void EntitySimple::addTime(Real deltaTime)
{
if(blocktime_ <= 0.f)
{
Ogre::Vector3 currpos = getLastPosition();
if(kbe_playerID() != mID)
{
Ogre::Vector3 movement = destPos_ - currpos;
float speed = mMoveSpeed * deltaTime;
movement.y = 0.f;
Real mlen = movement.length();
if(mlen < speed || (mLastAnimName != "Run" && mlen <= 1.0f))
{
if (mLastAnimName == "Run")
{
float y = currpos.y;
currpos = destPos_;
currpos.y = y;
playAnimation("Idle");
}
}
else
{
movement.normalise();
// Òƶ¯Î»ÖÃ
movement *= speed;
currpos += movement;
playAnimation("Run");
}
}
blocktime_ = 0.f;
setPosition(currpos.x, currpos.y, currpos.z);
KBEntity::addTime(deltaTime);
}
else
{
blocktime_ -= deltaTime;
playAnimation("Block");
}
if(mLastAnims)
mLastAnims->addTime(deltaTime);
}
void PLAYBACK::handleMiddleButtonClick()
{
if (emuPausedState)
{
// Unpause or start seeking
// works only when right mouse button is released
if (GetAsyncKeyState(GetSystemMetrics(SM_SWAPBUTTON) ? VK_LBUTTON : VK_RBUTTON) >= 0)
{
if (GetAsyncKeyState(VK_SHIFT) < 0)
{
// if Shift is held, seek to nearest Marker
int last_frame = markersManager.getMarkersArraySize() - 1; // the end of movie Markers
int target_frame = currFrameCounter + 1;
for (; target_frame <= last_frame; ++target_frame)
if (markersManager.getMarkerAtFrame(target_frame)) break;
if (target_frame <= last_frame)
startSeekingToFrame(target_frame);
} else if (GetAsyncKeyState(VK_CONTROL) < 0)
{
// if Ctrl is held, seek to Selection cursor or replay from Selection cursor
int selection_beginning = selection.getCurrentRowsSelectionBeginning();
if (selection_beginning > currFrameCounter)
{
startSeekingToFrame(selection_beginning);
} else if (selection_beginning < currFrameCounter)
{
int saved_currFrameCounter = currFrameCounter;
if (selection_beginning < 0)
selection_beginning = 0;
jump(selection_beginning);
startSeekingToFrame(saved_currFrameCounter);
}
} else if (getPauseFrame() < 0 && getLastPosition() >= greenzone.getSize())
{
restoreLastPosition();
} else
{
unpauseEmulation();
}
}
} else
{
pauseEmulation();
}
}
int blockSize()
{
return int(blockEnd->getLastPosition() - getLastPosition() - getSize());
}
void Caret::moveToEndPosition()
{
moveToPosition(getLastPosition());
}
//-------------------------------------------------------------------------------------
void EntityComplex::addTime(Real deltaTime)
{
if(mBodyNode)
{
if(mCamera)
updateBody(deltaTime);
updateAnimations(deltaTime);
}
Ogre::Vector3 currpos;
if(mCamera)
{
currpos = getPosition();
updateCamera(deltaTime);
}
else
{
currpos = getLastPosition();
if(kbe_playerID() != mID)
{
Ogre::Vector3 movement = destPos_ - currpos;
float speed = mMoveSpeed * deltaTime;
movement.y = 0.f;
Real mlen = movement.length();
if(mlen < speed || (mBaseAnimID != ANIM_RUN_BASE && mlen <= 1.0f))
{
if (mBaseAnimID == ANIM_RUN_BASE)
{
float y = currpos.y;
currpos = destPos_;
currpos.y = y;
setBaseAnimation(ANIM_IDLE_BASE);
if (mTopAnimID == ANIM_RUN_TOP)
setTopAnimation(ANIM_IDLE_TOP);
}
}
else
{
movement.normalise();
// 移动位置
movement *= speed;
currpos += movement;
if (mBaseAnimID == ANIM_IDLE_BASE)
{
setBaseAnimation(ANIM_RUN_BASE, true);
if (mTopAnimID == ANIM_IDLE_TOP)
{
setTopAnimation(ANIM_RUN_TOP, true);
}
}
}
}
}
setPosition(currpos.x, currpos.y, currpos.z);
KBEntity::addTime(deltaTime);
if(pWeaponTrailLeft_)
pWeaponTrailLeft_->onUpdate(deltaTime);
if(pWeaponTrailRight_)
pWeaponTrailRight_->onUpdate(deltaTime);
}
void PLAYBACK::update()
{
// controls:
// update < and > buttons
rewindButtonOldState = rewindButtonState;
rewindButtonState = ((Button_GetState(hwndRewind) & BST_PUSHED) != 0 || mustRewindNow);
if (rewindButtonState)
{
if (!rewindButtonOldState)
{
buttonHoldTimer = clock();
handleRewindFrame();
} else if (buttonHoldTimer + BUTTON_HOLD_REPEAT_DELAY < clock())
{
handleRewindFrame();
}
}
forwardButtonOldState = forwardButtonState;
forwardButtonState = (Button_GetState(hwndForward) & BST_PUSHED) != 0;
if (forwardButtonState && !rewindButtonState)
{
if (!forwardButtonOldState)
{
buttonHoldTimer = clock();
handleForwardFrame();
} else if (buttonHoldTimer + BUTTON_HOLD_REPEAT_DELAY < clock())
{
handleForwardFrame();
}
}
// update << and >> buttons
rewindFullButtonOldState = rewindFullButtonState;
rewindFullButtonState = ((Button_GetState(hwndRewindFull) & BST_PUSHED) != 0);
if (rewindFullButtonState && !rewindButtonState && !forwardButtonState)
{
if (!rewindFullButtonOldState)
{
buttonHoldTimer = clock();
handleRewindFull();
} else if (buttonHoldTimer + BUTTON_HOLD_REPEAT_DELAY < clock())
{
handleRewindFull();
}
}
forwardFullButtonOldState = forwardFullButtonState;
forwardFullButtonState = (Button_GetState(hwndForwardFull) & BST_PUSHED) != 0;
if (forwardFullButtonState && !rewindButtonState && !forwardButtonState && !rewindFullButtonState)
{
if (!forwardFullButtonOldState)
{
buttonHoldTimer = clock();
handleForwardFull();
} else if (buttonHoldTimer + BUTTON_HOLD_REPEAT_DELAY < clock())
{
handleForwardFull();
}
}
// update the Playback cursor
if (currFrameCounter != lastCursorPos)
{
// update gfx of the old and new rows
pianoRoll.redrawRow(lastCursorPos);
bookmarks.redrawChangedBookmarks(lastCursorPos);
pianoRoll.redrawRow(currFrameCounter);
bookmarks.redrawChangedBookmarks(currFrameCounter);
lastCursorPos = currFrameCounter;
// follow the Playback cursor, but in case of seeking don't follow it
pianoRoll.followPlaybackCursorIfNeeded(false); //pianoRoll.updatePlaybackCursorPositionInPianoRoll(); // an unfinished experiment
// enforce redrawing now
UpdateWindow(pianoRoll.hwndList);
// lazy update of "Playback's Marker text"
int current_marker = markersManager.getMarkerAboveFrame(currFrameCounter);
if (displayedMarkerNumber != current_marker)
{
markersManager.updateEditedMarkerNote();
displayedMarkerNumber = current_marker;
redrawMarkerData();
mustFindCurrentMarker = false;
}
}
// [non-lazy] update "Playback's Marker text" if needed
if (mustFindCurrentMarker)
{
markersManager.updateEditedMarkerNote();
displayedMarkerNumber = markersManager.getMarkerAboveFrame(currFrameCounter);
redrawMarkerData();
mustFindCurrentMarker = false;
}
// pause when seeking hits pause_frame
if (pauseFrame && currFrameCounter + 1 >= pauseFrame)
stopSeeking();
else if (currFrameCounter >= getLastPosition() && currFrameCounter >= currMovieData.getNumRecords() - 1 && mustAutopauseAtTheEnd && taseditorConfig.autopauseAtTheEndOfMovie && !isTaseditorRecording())
// pause at the end of the movie
pauseEmulation();
// update flashing pauseframe
if (oldPauseFrame != pauseFrame && oldPauseFrame)
{
// pause_frame was changed, clear old_pauseframe gfx
pianoRoll.redrawRow(oldPauseFrame-1);
bookmarks.redrawChangedBookmarks(oldPauseFrame-1);
}
oldPauseFrame = pauseFrame;
oldStateOfShowPauseFrame = showPauseFrame;
if (pauseFrame)
{
if (emuPausedState)
showPauseFrame = (int)(clock() / PAUSEFRAME_BLINKING_PERIOD_WHEN_PAUSED) & 1;
else
showPauseFrame = (int)(clock() / PAUSEFRAME_BLINKING_PERIOD_WHEN_SEEKING) & 1;
} else showPauseFrame = false;
if (oldStateOfShowPauseFrame != showPauseFrame)
{
// update pauseframe gfx
pianoRoll.redrawRow(pauseFrame - 1);
bookmarks.redrawChangedBookmarks(pauseFrame - 1);
}
// update seeking progressbar
emuPausedOldState = emuPausedState;
emuPausedState = (FCEUI_EmulationPaused() != 0);
if (pauseFrame)
{
if (oldStateOfShowPauseFrame != showPauseFrame) // update progressbar from time to time
// display seeking progress
setProgressbar(currFrameCounter - seekingBeginningFrame, pauseFrame - seekingBeginningFrame);
} else if (emuPausedOldState != emuPausedState)
{
// emulator got paused/unpaused externally
if (emuPausedOldState && !emuPausedState)
{
// externally unpaused - show empty progressbar
setProgressbar(0, 1);
} else
{
// externally paused - progressbar should be full
setProgressbar(1, 1);
}
}
// prepare to stop at the end of the movie in case user unpauses emulator
if (emuPausedState)
{
if (currFrameCounter < currMovieData.getNumRecords() - 1)
mustAutopauseAtTheEnd = true;
else
mustAutopauseAtTheEnd = false;
}
// this little statement is very important for adequate work of the "green arrow" and "Restore last position"
if (!emuPausedState)
// when emulating, lost_position_frame becomes unstable (which means that it's probably not equal to the end of current segment anymore)
lastPositionIsStable = false;
}