FaToDFA::FaToDFA(modes _mode, AlgorithmWidget* _algorithm_widget, FA_widget* _not_dfa_widget, FA_widget* _dfa_widget, QLabel* _var_widget, QObject* parrent)
: Algorithm(parrent), mode(_mode), algorithm_widget(_algorithm_widget), not_dfa_widget(_not_dfa_widget), dfa_widget(_dfa_widget), var_widget(_var_widget)
{
actInstruction = HEADER;
prewInstruction = HEADER;
instruction_count = WHILE_NEW+1;
initInstructions();
initBreakpoints(instruction_count);
this->setColumnCount(1);
this->setRowCount(instructions.count());
var_widget->setText("");
for(int i = 0; i < instructions.count();i++)
{
QModelIndex index = this->index(i,0,QModelIndex());
setData(index,instructions[i],Qt::EditRole);
setData(index,true,Algorithm::HasBreakpoint_Role);
setData(index,false,Algorithm::Breakpoint_Role);
switch(i)
{
case HEADER:
setData(index,false,Algorithm::HasBreakpoint_Role);
break;
}
}
//
// Connect algorithm buttons.
//
connect(this->algorithm_widget,SIGNAL(playPressed(int)),this,SLOT(runAlgorithm(int)));
connect(this->algorithm_widget,SIGNAL(stopPressed()),this,SLOT(stop()));
connect(this->algorithm_widget,SIGNAL(prewPressed()),this,SLOT(prevStep()));
connect(this->algorithm_widget,SIGNAL(nextPressed()),this,SLOT(nextStep()));
connect(this->algorithm_widget, SIGNAL(checkSolutionPressed()), this, SLOT(checkSolution()));
connect(this->algorithm_widget, SIGNAL(showCorrectSolutionPressed()), this, SLOT(showCorrectSolution()));
connect(this->algorithm_widget, SIGNAL(showUserSolutionPressed()), this, SLOT(showUserSolution()));
connect(this->algorithm_widget, SIGNAL(beginPressed()), this, SLOT(toBegin()));
connect(this->algorithm_widget, SIGNAL(endPressed()), this, SLOT(toEnd()));
//
// Connect timers.
//
connect(play_timer, SIGNAL(timeout()), this, SLOT(nextStep()));
connect(check_step_timer, SIGNAL(timeout()), this, SLOT(checkSolution()));
// Connect Finite Automata widgets
connect(not_dfa_widget,SIGNAL(FA_changed(FiniteAutomata*)),this,SLOT(setFA(FiniteAutomata*)));
connect(dfa_widget,SIGNAL(FA_changed(FiniteAutomata*)),this,SLOT(setDFA(FiniteAutomata*)));
not_dfa_widget->setFA(new FiniteAutomata());
algorithm_widget->enableShowButton();
}
int jump(vector<int>& nums) {
vector<int>toEnd(nums.size(), 0);
for(int i = nums.size()-2; i >= 0; i--){
int minCand = toEnd[i+1];
for(int j = 1; j <= nums[i]; j++){
minCand = min(minCand, toEnd[i+j]);
}
toEnd[i] = 1 + minCand;
}
return toEnd[0];
}
/* nowdat, setday */
int func(struct ymd *nowday, struct ymd *setday)
{
int y = nowday->year;
int m = nowday->month;
int d = nowday->day;
int yy = setday->year;
int mm = setday->month;
int dd = setday->day;
int returnday = 0;
if( (y > yy) || (y == yy && m > mm) || (y == yy && m == mm && d > dd) )
{
if (y > yy)
returnday = hasR(y, yy) + 365 *(y - yy -1) + toEnd(yy, mm, dd) + toStart(y, m, d);
else if (y == yy)
returnday = toEnd(yy, mm, dd) - toEnd(y, m, d);
}
else if ( y == yy && m == mm && d == dd )
{
return 0;
}
else
{
if (yy > y)
returnday = hasR(yy, y) + 365 *(yy - y -1) + toEnd(y ,m, d) + toStart(yy, mm, dd);
else if (y == yy)
returnday = toEnd(y, m, d) - toEnd(yy, mm, dd);
}
return returnday;
}
void List::concat(const List& other) {
ListBox* current = other.start;
while (current) {
toEnd(current->info);
current = current->pointer;
}
}
fs::path make_relative(fs::path a_From, fs::path a_To)
{
a_From = fs::absolute(a_From); a_To = fs::absolute(a_To);
fs::path ret;
fs::path::const_iterator itrFrom(a_From.begin()), itrTo(a_To.begin());
// Find common base
for (fs::path::const_iterator toEnd(a_To.end()), fromEnd(a_From.end());
itrFrom != fromEnd && itrTo != toEnd && *itrFrom == *itrTo; ++itrFrom, ++itrTo);
// Navigate backwards in directory to reach previously found base
for (fs::path::const_iterator fromEnd(a_From.end());
itrFrom != fromEnd; ++itrFrom)
{
if( (*itrFrom) != "." )
ret /= "..";
}
// Now navigate down the directory branch
ret.append( itrTo, a_To.end() );
return ret;
}
// Return path when appended to from will resolve to same as to
boost::filesystem::path makeRelativePath(boost::filesystem::path from, boost::filesystem::path to)
{
boost::filesystem::path ret;
boost::filesystem::path::const_iterator itrFrom(from.begin()), itrTo(to.begin());
from = boost::filesystem::absolute(from);
to = boost::filesystem::absolute(to);
// Find common base
for (boost::filesystem::path::const_iterator toEnd(to.end()), fromEnd(from.end()); itrFrom != fromEnd && itrTo != toEnd && *itrFrom == *itrTo; ++itrFrom, ++itrTo) ;
// Navigate backwards in directory to reach previously found base
for (boost::filesystem::path::const_iterator fromEnd(from.end()); itrFrom != fromEnd; ++itrFrom) {
if ((*itrFrom) != ".")
ret /= "..";
}
// Now navigate down the directory branch
ret.append(itrTo, to.end());
return ret;
}
/* y is now, yy is the set day */
int func(int y, int m, int d, int yy, int mm, int dd)
{
int returnday = 0;
if( (y > yy) || (y == yy && m > mm) || (y == yy && m == mm && d > dd) )
{
if (y > yy)
returnday = hasR(y, yy) + 365 *(y - yy -1) + toEnd(yy, mm, dd) + toStart(y, m, d);
else if (y == yy)
returnday = toEnd(yy, mm, dd) - toEnd(y, m, d);
}
else if ( y == yy && m == mm && d == dd )
{
return 0;
}
else
{
if (yy > y)
returnday = hasR(yy, y) + 365 *(yy - y -1) + toEnd(y ,m, d) + toStart(yy, mm, dd);
else if (y == yy)
returnday = toEnd(y, m, d) - toEnd(yy, mm, dd);
}
return returnday;
}
dialog::RESULT fileSelect::run()
{
if (!init(size_))
{
return dialog::R_NCREAT;
}
refresh();
// Handle keyboard.
keyMapping::KEYLABEL label;
bool cont = true;
while (cont)
{
label = handleKeyboard();
switch (label)
{
case keyMapping::K_HELP:
{
if (showHelp() == dialog::R_RESIZE)
{
// Resized window.
return dialog::R_RESIZE;
}
break;
}
case keyMapping::K_QUIT:
{
cont = false;
break;
}
case keyMapping::K_DOWN:
{
moveDown();
refresh();
break;
}
case keyMapping::K_UP:
{
moveUp();
refresh();
break;
}
case keyMapping::K_LIST_START:
{
toStart();
refresh();
break;
}
case keyMapping::K_LIST_END:
{
toEnd();
refresh();
break;
}
case keyMapping::K_MARK:
{
handleMark();
moveDown();
refresh();
break;
}
case keyMapping::K_SELECT:
{
pressed_select_key_ = true;
cont = false;
break;
}
case keyMapping::K_MARK_ALL:
{
handleMarkAll();
break;
}
case keyMapping::K_RESIZE:
{
// Close this window, and make the parent
// resize its window.
return dialog::R_RESIZE;
break;
}
default:
{
refresh();
break;
}
}
}
return dialog::R_QUIT;
}
// Move along the path. Return false if end of path reached.
CCSBot::PathResult CCSBot::UpdatePathMovement(bool allowSpeedChange)
{
if (m_pathLength == 0)
return PATH_FAILURE;
if (cv_bot_walk.value != 0.0f)
Walk();
// If we are navigating a ladder, it overrides all other path movement until complete
if (UpdateLadderMovement())
return PROGRESSING;
// ladder failure can destroy the path
if (m_pathLength == 0)
return PATH_FAILURE;
// we are not supposed to be on a ladder - if we are, jump off
if (IsOnLadder())
Jump(MUST_JUMP);
assert(m_pathIndex < m_pathLength);
// Check if reached the end of the path
bool nearEndOfPath = false;
if (m_pathIndex >= m_pathLength - 1)
{
Vector toEnd(pev->origin.x, pev->origin.y, GetFeetZ());
Vector d = GetPathEndpoint() - toEnd; // can't use 2D because path end may be below us (jump down)
const float walkRange = 200.0f;
// walk as we get close to the goal position to ensure we hit it
if (d.IsLengthLessThan(walkRange))
{
// don't walk if crouching - too slow
if (allowSpeedChange && !IsCrouching())
Walk();
// note if we are near the end of the path
const float nearEndRange = 50.0f;
if (d.IsLengthLessThan(nearEndRange))
nearEndOfPath = true;
const float closeEpsilon = 20.0f;
if (d.IsLengthLessThan(closeEpsilon))
{
// reached goal position - path complete
DestroyPath();
// TODO: We should push and pop walk state here, in case we want to continue walking after reaching goal
if (allowSpeedChange)
Run();
return END_OF_PATH;
}
}
}
// To keep us moving smoothly, we will move towards
// a point farther ahead of us down our path.
int prevIndex = 0; // closest index on path just prior to where we are now
const float aheadRange = 300.0f;
int newIndex = FindPathPoint(aheadRange, &m_goalPosition, &prevIndex);
// BOTPORT: Why is prevIndex sometimes -1?
if (prevIndex < 0)
prevIndex = 0;
// if goal position is near to us, we must be about to go around a corner - so look ahead!
const float nearCornerRange = 100.0f;
if (m_pathIndex < m_pathLength - 1 && (m_goalPosition - pev->origin).IsLengthLessThan(nearCornerRange))
{
ClearLookAt();
InhibitLookAround(0.5f);
}
// if we moved to a new node on the path, setup movement
if (newIndex > m_pathIndex)
{
SetPathIndex(newIndex);
}
if (!IsUsingLadder())
{
// Crouching
// if we are approaching a crouch area, crouch
// if there are no crouch areas coming up, stand
const float crouchRange = 50.0f;
bool didCrouch = false;
for (int i = prevIndex; i < m_pathLength; i++)
{
const CNavArea *to = m_path[i].area;
// if there is a jump area on the way to the crouch area, don't crouch as it messes up the jump
// unless we are already higher than the jump area - we must've jumped already but not moved into next area
if ((to->GetAttributes() & NAV_JUMP)/* && to->GetCenter()->z > GetFeetZ()*/)
break;
Vector close;
to->GetClosestPointOnArea(&pev->origin, &close);
if ((close - pev->origin).Make2D().IsLengthGreaterThan(crouchRange))
break;
if (to->GetAttributes() & NAV_CROUCH)
{
Crouch();
didCrouch = true;
break;
}
}
if (!didCrouch && !IsJumping())
{
// no crouch areas coming up
StandUp();
}
// end crouching logic
}
// compute our forward facing angle
m_forwardAngle = UTIL_VecToYaw(m_goalPosition - pev->origin);
// Look farther down the path to "lead" our view around corners
Vector toGoal;
if (m_pathIndex == 0)
{
toGoal = m_path[1].pos;
}
else if (m_pathIndex < m_pathLength)
{
toGoal = m_path[m_pathIndex].pos - pev->origin;
// actually aim our view farther down the path
const float lookAheadRange = 500.0f;
if (!m_path[m_pathIndex].ladder && !IsNearJump() && toGoal.Make2D().IsLengthLessThan(lookAheadRange))
{
float along = toGoal.Length2D();
int i;
for (i = m_pathIndex + 1; i < m_pathLength; i++)
{
Vector delta = m_path[i].pos - m_path[i - 1].pos;
float segmentLength = delta.Length2D();
if (along + segmentLength >= lookAheadRange)
{
// interpolate between points to keep look ahead point at fixed distance
float t = (lookAheadRange - along) / (segmentLength + along);
Vector target;
if (t <= 0.0f)
target = m_path[i - 1].pos;
else if (t >= 1.0f)
target = m_path[i].pos;
else
target = m_path[i - 1].pos + t * delta;
toGoal = target - pev->origin;
break;
}
// if we are coming up to a ladder or a jump, look at it
if (m_path[i].ladder || (m_path[i].area->GetAttributes() & NAV_JUMP))
{
toGoal = m_path[i].pos - pev->origin;
break;
}
along += segmentLength;
}
if (i == m_pathLength)
{
toGoal = GetPathEndpoint() - pev->origin;
}
}
}
else
{
toGoal = GetPathEndpoint() - pev->origin;
}
m_lookAheadAngle = UTIL_VecToYaw(toGoal);
// initialize "adjusted" goal to current goal
Vector adjustedGoal = m_goalPosition;
// Use short "feelers" to veer away from close-range obstacles
// Feelers come from our ankles, just above StepHeight, so we avoid short walls, too
// Don't use feelers if very near the end of the path, or about to jump
// TODO: Consider having feelers at several heights to deal with overhangs, etc.
if (!nearEndOfPath && !IsNearJump() && !IsJumping())
{
FeelerReflexAdjustment(&adjustedGoal);
}
// draw debug visualization
if ((cv_bot_traceview.value == 1.0f && IsLocalPlayerWatchingMe()) || cv_bot_traceview.value == 10.0f)
{
DrawPath();
const Vector *pos = &m_path[m_pathIndex].pos;
UTIL_DrawBeamPoints(*pos, *pos + Vector(0, 0, 50), 1, 255, 255, 0);
UTIL_DrawBeamPoints(adjustedGoal, adjustedGoal + Vector(0, 0, 50), 1, 255, 0, 255);
UTIL_DrawBeamPoints(pev->origin, adjustedGoal + Vector(0, 0, 50), 1, 255, 0, 255);
}
// dont use adjustedGoal, as it can vary wildly from the feeler adjustment
if (!IsAttacking() && IsFriendInTheWay(&m_goalPosition))
{
if (!m_isWaitingBehindFriend)
{
m_isWaitingBehindFriend = true;
const float politeDuration = 5.0f - 3.0f * GetProfile()->GetAggression();
m_politeTimer.Start(politeDuration);
}
else if (m_politeTimer.IsElapsed())
{
// we have run out of patience
m_isWaitingBehindFriend = false;
ResetStuckMonitor();
// repath to avoid clump of friends in the way
DestroyPath();
}
}
else if (m_isWaitingBehindFriend)
{
// we're done waiting for our friend to move
m_isWaitingBehindFriend = false;
ResetStuckMonitor();
}
// Move along our path if there are no friends blocking our way,
// or we have run out of patience
if (!m_isWaitingBehindFriend || m_politeTimer.IsElapsed())
{
// Move along path
MoveTowardsPosition(&adjustedGoal);
// Stuck check
if (m_isStuck && !IsJumping())
{
Wiggle();
}
}
// if our goal is high above us, we must have fallen
bool didFall = false;
if (m_goalPosition.z - GetFeetZ() > JumpCrouchHeight)
{
const float closeRange = 75.0f;
Vector2D to(pev->origin.x - m_goalPosition.x, pev->origin.y - m_goalPosition.y);
if (to.IsLengthLessThan(closeRange))
{
// we can't reach the goal position
// check if we can reach the next node, in case this was a "jump down" situation
if (m_pathIndex < m_pathLength - 1)
{
if (m_path[m_pathIndex + 1].pos.z - GetFeetZ() > JumpCrouchHeight)
{
// the next node is too high, too - we really did fall of the path
didFall = true;
}
}
else
{
// fell trying to get to the last node in the path
didFall = true;
}
}
}
// This timeout check is needed if the bot somehow slips way off
// of its path and cannot progress, but also moves around
// enough that it never becomes "stuck"
const float giveUpDuration = 5.0f; // 4.0f
if (didFall || gpGlobals->time - m_areaEnteredTimestamp > giveUpDuration)
{
if (didFall)
{
PrintIfWatched("I fell off!\n");
}
// if we havent made any progress in a long time, give up
if (m_pathIndex < m_pathLength - 1)
{
PrintIfWatched("Giving up trying to get to area #%d\n", m_path[m_pathIndex].area->GetID());
}
else
{
PrintIfWatched("Giving up trying to get to end of path\n");
}
Run();
StandUp();
DestroyPath();
return PATH_FAILURE;
}
return PROGRESSING;
}