void Camera::Move3D() { if (m_moveState.forward) { Walk(m_speed * m_msec); } if (m_moveState.back) { Walk(-m_speed * m_msec); } if (m_moveState.left) { Strafe(m_speed * m_msec); } if (m_moveState.right) { Strafe(-m_speed * m_msec); } if (m_moveState.up) { Lift(m_speed * m_msec); } if (m_moveState.down) { Lift(-m_speed * m_msec); } }
void BatRunThink (objtype *obj) { id0_int_t deltax,deltay; deltax=player->tilex - obj->tilex; deltay=player->tiley - obj->tiley; if (deltax>=0) deltax = 0; else deltax = 2; if (deltay>=0) deltay = 0; else deltay = 2; obj->dir = dirtable[deltay*3+deltax]; if (Walk(obj)) return; obj->dir = dirtable[3+deltax]; if (Walk(obj)) return; obj->dir = dirtable[deltay*3+1]; Walk(obj); }
HRESULT Camera::HandleMessages(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch(uMsg) { case WM_KEYDOWN: { switch( wParam ) { case 'A': case VK_LEFT: Strafe(-0.1f) ; return TRUE ; case 'D': case VK_RIGHT: Strafe(0.1f) ; return TRUE ; case 'W': case VK_UP: Walk(0.1f) ; return TRUE ; case 'S': case VK_DOWN: Walk(-0.1f) ; return TRUE ; } } } return FALSE ; }
void BatChaseThink (objtype *obj) { id0_int_t deltax,deltay; deltax=player->tilex - obj->tilex; deltay=player->tiley - obj->tiley; if (deltax>0) deltax = 2; else if (deltax<0) deltax = 0; else deltax = 1; if (deltay>0) deltay = 2; else if (deltay<0) deltay = 0; else deltay = 1; obj->dir = dirtable[deltay*3+deltax]; if (Walk(obj)) return; obj->dir = dirtable[3+deltax]; if (Walk(obj)) return; obj->dir = dirtable[deltay*3+1]; if (Walk(obj)) return; obj->dir = nodir; }
HRESULT STDMETHODCALLTYPE TextAreaTextRange::MoveEndpointByUnit(_In_ TextPatternRangeEndpoint endpoint, _In_ TextUnit unit, _In_ int count, _Out_ int *retVal) { if (!IsWindow(_hwnd)) { return UIA_E_ELEMENTNOTAVAILABLE; } *retVal = 0; if (endpoint == TextPatternRangeEndpoint_Start) { _range.begin = Walk(_range.begin, count > 0, unit, 0, abs(count), retVal); if (QuickCompareEndpoints(_range.begin, _range.end) > 0) { _range.end = _range.begin; } } else { _range.end = Walk(_range.end, count > 0, unit, 0, abs(count), retVal); if (QuickCompareEndpoints(_range.begin, _range.end) > 0) { _range.begin = _range.end; } } return S_OK; }
HRESULT STDMETHODCALLTYPE TextAreaTextRange::Move(_In_ TextUnit unit, _In_ int count, _Out_ int *retVal) { if (!IsWindow(_hwnd)) { return UIA_E_ELEMENTNOTAVAILABLE; } *retVal = 0; bool isDegenerate = (QuickCompareEndpoints(_range.begin, _range.end) == 0); int walked; EndPoint back = Walk(_range.begin, false, unit, 0, 0, &walked); EndPoint destination = Walk(back, count > 0, unit, 0, abs(count), retVal); _range.begin = destination; _range.end = destination; if (!isDegenerate) { return ExpandToEnclosingUnit(unit); } return S_OK; }
void FPS_Cam::UpdateInput(double dt) //update if inputs available { /* Strafe */ if (CU::input.IsKeyPressed(Input::A) && !CU::input.IsKeyPressed(Input::D)) { Strafe(-dt); } if (!CU::input.IsKeyPressed(Input::A) && CU::input.IsKeyPressed(Input::D)) { Strafe(dt); } /* walk */ if (CU::input.IsKeyPressed(Input::W) && !CU::input.IsKeyPressed(Input::S)) { Walk(dt); } if (!CU::input.IsKeyPressed(Input::W) && CU::input.IsKeyPressed(Input::S)) { Walk(-dt); } /* Fly */ if (CU::input.IsKeyPressed(Input::K)) { Fly(dt); } else if (CU::input.IsKeyPressed(Input::L)) { Fly(-dt); } }
int main() { /** Initally there are walls everywhere, each move breaks walls */ int N=0; scanf("%d",&N); for(int k=1;k<=N;k++) { scanf("%s %s",path[0],path[1]); POINT minpt(0,0), maxpt(0,0); POINT dir(0,-1); POINT pos(0,1); Walk(path[0],pos,dir, minpt,maxpt); dir=-dir; Walk(path[1],pos,dir, minpt,maxpt); printf("Case #%d:\n",k); for(int y=maxpt.imag();y>=minpt.imag();y--) { for(int x=minpt.real();x<=maxpt.real();x++) printf("%x",maze[std::make_pair(x,y)]); printf("\n"); } maze.clear(); } return 0; }
void Camera3::Update(double dt, bool* myKeys) {/* Vector3 view = (target - position).Normalized(); Vector3 right = view.Cross(up); right.y = 0; Inertia: instant dir change * strafe */ if(myKeys[KEY_A] && !myKeys[KEY_D]) Strafe(-dt); else if(straftMovingLeft) DecelerateLeft(-dt); if(myKeys[KEY_D] && !myKeys[KEY_A]) Strafe(dt); else if(straftMovingRight) DecelerateRight(dt); /* walk */ if(myKeys[KEY_W] && !myKeys[KEY_S]) Walk(dt); else if(walkMovingForward) DecelerateForward(dt); if(myKeys[KEY_S] && !myKeys[KEY_W]) Walk(-dt); else if(walkMovingBackward) DecelerateBackward(-dt); if(myKeys[KEY_C] && !croutching) croutching = true; croutch(dt); /* fly */ if(myKeys[KEY_K]) Fly(dt); if(myKeys[KEY_L]) Fly(-dt); if(myKeys[KEY_SPACE] && !jump) //com runs too fast, spacebar 2 times setJump(dt); if(myKeys[KEY_T]) //reset { Reset(); } /** update jump **/ if(jump) Jump(dt); /** mouse **/ Yaw(dt); Pitch(dt); }
/** * Walk a tree, calling action once on each node. * * Operation: * This routine walks through the specified sub_tree and invokes action * action at each node as follows: * action(context, data, level) * data the data contents of the node being visited, * level is the level of the node in the tree with the root being level 0. * @param tree root of the tree being walked. * @param action action to be performed at every node * @param context action's context * @param sub_tree ptr to root of subtree to be walked * @param level current level in the tree for this node */ void Walk(KDTREE *tree, void_proc action, void *context, KDNODE *sub_tree, inT32 level) { (*action)(context, sub_tree->Data, level); if (sub_tree->Left != NULL) Walk(tree, action, context, sub_tree->Left, NextLevel(tree, level)); if (sub_tree->Right != NULL) Walk(tree, action, context, sub_tree->Right, NextLevel(tree, level)); }
// Determines the start point where the comparison of the current cluster must begin // for the orientation "rotSym" Pt StartPt(int rotSym, int name) { Pt p = Walk(minP, 1, rotSym) ; Pt res = minP ; if( p.x < minP.x ) res.x = maxP.x ; if( p.y < minP.y ) res.y = maxP.y ; while( get(res) != name ) res = Walk(res, 0, rotSym) ; return res ; }
// Compares two clusters according to the orientation "rotSym" int CompareX(Pt p, Pt q, int arrow, int rotSym) { int a ; Pt np = Walk(p, arrow, 0), nq = Walk(q, arrow, rotSym) ; if( get(np) == '0' ) return get(nq) == '0' ; if( get(np) == '1' ) return true ; set(np, '1') ; if( get(nq) == '0' ) return false ; for( a = 0 ; a < 8 ; a++ ) if( !CompareX(np, nq, a, rotSym) ) return false ; return true ; }
void Entity::GoSideToSide(float dt) { if (mGoUp) { Walk(dt*movementMult); if (mPosition.z > mOrigZ + mHeightToGo){ mGoUp = false; mGoDown = true; } } if (mGoDown) { Walk(-dt*movementMult); if (mPosition.z < mOrigZ - mHeightToGo){ mGoUp = true; mGoDown = false; } } }
/* Registra informações sobre os comodos de uma planta */ void SetRooms(CharMat** Ap, int* nRooms, Stack** RoomSizes){ int m = (*Ap)->lines; int n = (*Ap)->cols; int status; int roomSize; *nRooms = 0; for(int i=1; i<m-1; i++){ for(int j=1; j<n-1; j++){ status = IsRoomEdge(Ap, i, j); if(status > 0){ roomSize = 0; Walk(Ap, i, j, &roomSize); if(roomSize > 0){ (*nRooms)++; if(RoomSizes){ InOrderStack(RoomSizes, roomSize); } } } } } }
void ArrayUtil::Walk(VRefParam input, PFUNC_WALK walk_function, const void *data, bool recursive /* = false */, PointerSet *seen /* = NULL */, CVarRef userdata /* = null_variant */) { assert(walk_function); Variant k; Variant v; for (MutableArrayIter iter = input->begin(&k, v); iter.advance(); ) { if (recursive && v.is(KindOfArray)) { assert(seen); ArrayData *arr = v.getArrayData(); if (v.isReferenced()) { if (seen->find((void*)arr) != seen->end()) { raise_warning("array_walk_recursive(): recursion detected"); return; } seen->insert((void*)arr); } Walk(directRef(v), walk_function, data, recursive, seen, userdata); if (v.isReferenced()) { seen->erase((void*)arr); } } else { walk_function(directRef(v), k, userdata, data); } } }
void Walk(boost::filesystem::path p, unsigned short int top, std::string prefix, file_list& files) { boost::filesystem::directory_iterator end; if(!boost::filesystem::exists(p)) { std::cerr << "Could not open " << p.string() << std::endl; return; } top = AddFile(p, top, prefix, files); for(boost::filesystem::directory_iterator it(p); it != end; ++it) { if(!boost::filesystem::is_directory(it->status())) AddFile(it->path(), top, prefix, files); else { char* dirname; dirname = new char[strlen(it->path().string().c_str())+2]; strcpy(dirname, it->path().string().c_str()); Walk(dirname, top, prefix, files); delete[] dirname; } } }
int Ardb::ZRank(const DBID& db, const Slice& key, const Slice& member) { ZSetMetaValue meta; if (0 != GetZSetMetaValue(db, key, meta)) { return ERR_NOT_EXIST; } Slice empty; ZSetKeyObject start(key, empty, meta.min_score, db); struct ZRankWalk: public WalkHandler { int rank; ValueObject z_member; int foundRank; int OnKeyValue(KeyObject* k, ValueObject* v, uint32 cursor) { ZSetKeyObject* zko = (ZSetKeyObject*) k; std::string str; if (zko->value.Compare(z_member) == 0) { foundRank = rank; return -1; } rank++; return 0; } ZRankWalk(const Slice& m) : rank(0), foundRank(ERR_NOT_EXIST) { smart_fill_value(m, z_member); } } walk(member); Walk(start, false, &walk); return walk.foundRank; }
int Ardb::ZClear(const DBID& db, const Slice& key) { KeyLockerGuard keyguard(m_key_locker, db, key); ZSetMetaValue meta; if (0 != GetZSetMetaValue(db, key, meta)) { return 0; } Slice empty; ZSetKeyObject sk(key, empty, meta.min_score, db); BatchWriteGuard guard(GetEngine()); struct ZClearWalk: public WalkHandler { Ardb* z_db; int OnKeyValue(KeyObject* k, ValueObject* value, uint32 cursor) { ZSetKeyObject* sek = (ZSetKeyObject*) k; ZSetScoreKeyObject tmp(sek->key, sek->value, sek->db); z_db->DelValue(*sek); z_db->DelValue(tmp); return 0; } ZClearWalk(Ardb* db) : z_db(db) { } } walk(this); Walk(sk, false, &walk); KeyObject k(key, ZSET_META, db); DelValue(k); return 0; }
void KeyControlledTransitionBarbarian_cl::ProcessKeyboardEvents() { bool bUp = VAppImpl::GetInputMap()->GetTrigger(CHARACTER_MOVE_FORWARD)!=0; bool bRotLeft = VAppImpl::GetInputMap()->GetTrigger(CHARACTER_ROTATE_LEFT)!=0; bool bRotRight = VAppImpl::GetInputMap()->GetTrigger(CHARACTER_ROTATE_RIGHT)!=0; bool bShift = VAppImpl::GetInputMap()->GetTrigger(CHARACTER_RUN)!=0; if (bUp) { // Trigger the run/walk actions when CURSOR UP is pressed. // Allow rotating the entity while walking/running if (bShift) Run(); else Walk(); if (bRotLeft) RotateLeft(); else if (bRotRight) RotateRight(); } else { if (bRotLeft) RotateLeft(); else if (bRotRight) RotateRight(); else Stand(); } }
HRESULT STDMETHODCALLTYPE TextAreaTextRange::FindAttribute(_In_ TEXTATTRIBUTEID textAttributeId, _In_ VARIANT val, _In_ BOOL searchBackward, _Outptr_result_maybenull_ ITextRangeProvider **retVal) { HRESULT hr = S_OK; *retVal = NULL; EndPoint start = searchBackward ? _range.end : _range.begin; EndPoint finish = searchBackward ? _range.begin : _range.end; EndPoint current = start; // This will loop until 'current' passes or is equal to the end while (QuickCompareEndpoints(searchBackward ? finish : current, searchBackward ? current : finish) < 0) { int walked; EndPoint next = Walk(current, !searchBackward, TextUnit_Format, textAttributeId, 1, &walked); VARIANT curValue = _control->GetAttributeAtPoint(searchBackward ? current : next, textAttributeId); hr = VarCmp(&val, &curValue, LOCALE_NEUTRAL); if (hr == VARCMP_EQ) { Range found; found.begin = searchBackward ? next : current; // For line based attributes, the start character will be the end of the previous line // bump it up one to make it an even line for (int i = 0; i < ARRAYSIZE(lineVariableAttributes); i++) { if (textAttributeId == lineVariableAttributes[i]) { if (found.begin.character > 0) { found.begin.character = 0; found.begin.line++; } break; } } // If next is past the end of the current range, end at the end of the current range instead if (QuickCompareEndpoints(searchBackward ? finish : next, searchBackward ? next : finish) > 0) { found.end = finish; } else { found.end = searchBackward ? current : next; } *retVal = new TextAreaTextRange(_hwnd, _control, found); if (*retVal == NULL) { hr = E_OUTOFMEMORY; } break; } current = next; } return hr; }
int Ardb::ZRevRange(const DBID& db, const Slice& key, int start, int stop, ValueArray& values, QueryOptions& options) { ZSetMetaValue meta; if (0 != GetZSetMetaValue(db, key, meta)) { return ERR_NOT_EXIST; } if (start < 0) { start = start + meta.size; } if (stop < 0) { stop = stop + meta.size; } if (start < 0 || stop < 0 || (uint32) start >= meta.size) { return ERR_INVALID_ARGS; } Slice empty; ZSetKeyObject tmp(key, empty, meta.max_score, db); struct ZRevRangeWalk: public WalkHandler { int rank; int count; int z_start; int z_stop; ValueArray& z_values; QueryOptions& z_options; ZRevRangeWalk(int start, int stop, ValueArray& values, QueryOptions& options) : rank(0), count(0), z_start(start), z_stop(stop), z_values( values), z_options(options) { } int OnKeyValue(KeyObject* k, ValueObject* v, uint32 cursor) { ZSetKeyObject* zsk = (ZSetKeyObject*) k; if (rank >= z_start && rank <= z_stop) { z_values.push_back(zsk->value); if (z_options.withscores) { z_values.push_back(ValueObject(zsk->score)); } count++; } rank++; if (rank > z_stop) { return -1; } return 0; } } walk(start, stop, values, options); Walk(tmp, true, &walk); return walk.count; }
void XM_CALLCONV Camera::Update( float deltaTime ) { if( GetAsyncKeyState( VK_HOME ) ) { SetCamType(); } if( GetCamType()==1 ) { if( GetAsyncKeyState( VK_LEFT ) ) { RotateY( 5.0f * deltaTime ); } if( GetAsyncKeyState( VK_RIGHT ) ) { RotateY( -5.0f * deltaTime ); } if( GetAsyncKeyState( VK_UP ) ) { Walk( -15.0f * deltaTime ); } if( GetAsyncKeyState( VK_DOWN ) ) { Walk( 15.0f * deltaTime ); } if( GetAsyncKeyState( VK_PRIOR ) ) { Pitch( 1.0f * deltaTime ); } if( GetAsyncKeyState( VK_NEXT ) ) { Pitch( -1.0f * deltaTime ); } if( GetAsyncKeyState( VK_OEM_COMMA ) ) { Strafe( -15.0f * deltaTime ); } if( GetAsyncKeyState( VK_OEM_PERIOD ) ) { Strafe( 15.0f * deltaTime ); } } else { // default camera //XMStoreFloat3( &target1, goblin1Pos); //XMVECTOR posV = XMLoadFloat3( &pos ); //XMVECTOR targetV = goblin1Pos; //XMVECTOR upV = GetUpXM(); //LookAt( posV, targetV, upV ); } UpdateViewMatrix(); }
// Fills a cluster with the char "name" void Fill(Pt p, int arrow, int name) { int a ; Pt np = Walk(p, arrow, 0) ; if( get(np) != '0' && get(np) != name ) { set(np, name) ; for( a = 0 ; a < 8 ; a++ ) Fill(np, a, name) ; } }
void CTreeIterator::Erase(void) { _ASSERT(CheckValid()); m_CurrentObject.Reset(); _ASSERT(!m_Stack.empty()); m_Stack.back()->Erase(); Walk(); }
/////////////////////////////////////////////////////// // LevelCode /////////////////////////////////////////////////////// HRESULT LevelCode(void *v, DWORD s) { if(WalkOnMap) Walk(); else MapMenu(); return 0; }
void NPC::E_Update(const int delta) { if (!m_moving) { int direction = rand() % 240; if (direction < 4) Walk((E_Direction)direction); } Traveller::E_Update(delta); }
void wxMenuComboListWalker::FillComboListCtrl(wxMenuBar *p, wxComboBox *combo) { // these will be used in the recursive functions... m_pCategories = combo; // be sure that the given tree item is empty... m_pCategories->Clear(); // ...start !!! Walk(p, NULL); }
void wxMenuTreeWalker::FillTreeBranch(wxMenuBar *p, wxTreeCtrl *ctrl, wxTreeItemId branch) { // these will be used in the recursive functions... m_root = branch; m_pTreeCtrl = ctrl; // be sure that the given tree item is empty... m_pTreeCtrl->DeleteChildren(branch); // ...start !!! Walk(p, &branch); }
void EulerCamera::Collided(ObjectType colltype) { if (colltype == ObjectType::ENEMY) { printf("Enemy collision"); } else if (colltype == ObjectType::OBJECT) { printf("Object \n"); if (LastMove==Moves::Forward) Walk(-0.1f); else if (LastMove == Moves::Backward) Walk(0.1f); else if (LastMove == Moves::Left) Strafe(0.1f); else if (LastMove == Moves::Right) Strafe(-0.1f); } }
void T_Bat (objtype *ob) { id0_long_t move; id0_long_t deltax,deltay,size; move = ob->speed*tics; size = (id0_long_t)ob->size + player->size + move; do { deltax = ob->x - player->x; deltay = ob->y - player->y; if (deltax <= size && deltax >= -size && deltay <= size && deltay >= -size && !ob->temp1) { TakeDamage (4); ob->temp1 = 2; } if (move < ob->distance) { MoveObj (ob,move); break; } actorat[ob->tilex][ob->tiley] = 0; // pick up marker from goal if (ob->dir == nodir) ob->dir = north; ob->x = ((id0_long_t)ob->tilex<<TILESHIFT)+TILEGLOBAL/2; ob->y = ((id0_long_t)ob->tiley<<TILESHIFT)+TILEGLOBAL/2; move -= ob->distance; if (ob->temp1) { Walk (ob); // go straight if (!--ob->temp1) { ob->state = &s_batpast; ob->ticcount = ob->state->tictime; } } else BatChaseThink (ob); // head towards player actorat[ob->tilex][ob->tiley] = COMPAT_OBJ_CONVERT_OBJ_PTR_TO_DOS_PTR(ob); // set down a new goal marker //actorat[ob->tilex][ob->tiley] = ob; // set down a new goal marker } while (0); // just once CalcBounds (ob); }