LOCAL void verbose_ses_print_curve_states( CURVE *curve, SESAME_TABLE_TYPE eos_type, SESAME_EOS *seos) { BOND *bb; (void) printf("EOS states on curve %llu\n",curve_number(curve)); verbose_ses_print_state("Left state",Coords(curve->start->posn), left_start_state(curve),eos_type,seos); verbose_ses_print_state("Right state",Coords(curve->start->posn), right_start_state(curve),eos_type,seos); for (bb = curve->first; bb != NULL; bb = bb->next) { verbose_ses_print_state("Left state",Coords(bb->end), left_state_at_point_on_curve(bb->end,bb, curve), eos_type,seos); verbose_ses_print_state("Right state",Coords(bb->end), right_state_at_point_on_curve(bb->end,bb, curve), eos_type,seos); } (void) printf("End of EOS states on curve %llu\n",curve_number(curve)); } /*end verbose_ses_print_curve_states*/
LOCAL void EnforceFlowSpecifedStates1d( Front *fr) { INTERFACE *intfc; HYPER_SURF *hs; POINT **p; Locstate sl, sr; if ((fr==NULL) || (Fsr_list(fr)==NULL) || (fr->rect_grid->dim!=1)) return; intfc = fr->interf; for (p = intfc->points; p && *p; ++p) { hs = Hyper_surf(*p); if (BothSidesActive(hs,fr) == NO) { slsr(*p,NULL,Hyper_surf(*p),&sl,&sr); (void) RegionIsFlowSpecified(sl,NULL,Coords(*p), negative_component(hs),NO_COMP,fr); (void) RegionIsFlowSpecified(sr,NULL,Coords(*p), positive_component(hs),NO_COMP,fr); } } } /*end EnforceFlowSpecifedStates1d*/
// Notes: 8x8 is best for AGP cards // 16x16 is best for PCI cards bool Sum::makeStrategy(GLuint w, GLuint h, int numReduce ) { sizes.push_back(Coords(w,h)); while( w > 16 || h > 16 ) { unsigned int newW, newH; // pick the larger dimension if ( w >= h ) { newW = getBestFold(w,2); newH = getBestFold(h,2); } else { newW = getBestFold(w,2); newH = getBestFold(h,2); } //make sure dimensions were divisible at least by two //assert( newW != w ); //assert( newH != h ); if( newW == w || newH == h ) break; w = newW; h = newH; sizes.push_back(Coords(w,h)); if( numReduce != -1 && sizes.size() > numReduce ) break; } cerr<<"Strategy for is: "<<endl; cerr<<"====="<<endl; for( unsigned int i=0 ; i<sizes.size() ; i++ ) { cerr<<sizes[i].x()<<"x"<<sizes[i].y()<<endl; } cerr<<"====="<<endl; return true; }
TetrominoZ::TetrominoZ(std::vector<std::shared_ptr<Block>> blocks) : BasicShape(3, {Coords(0, 0), Coords(0, 1), Coords(1, 1), Coords(1, 2)}, blocks) { //ctor }
LOCAL void gview_plot_curve2d( FILE *fp, CURVE *c, float *color) { BOND *b; b = c->first; fprintf(fp,"{ \n"); fprintf(fp,"appearance{*linewidth 2}\n"); fprintf(fp,"VECT\n"); fprintf(fp,"%1d %1d %1d\n", 1, c->num_points, 1); fprintf(fp,"%1d\n%1d\n", c->num_points,1); while (b) { fprintf(fp,"%f %f %f \n", Coords(b->start)[0], Coords(b->start)[1] , 1.0); if (b == c->last) break; b = b->next; } fprintf(fp,"%f %f %f \t\n", Coords(b->end)[0], Coords(b->end)[1] , 1.0); fprintf(fp,"%f %f %f %f \t\n",color[0],color[1],color[2],color[3]); fprintf(fp,"}\n"); }
EXPORT boolean f_sort_bond_tris( INTERFACE *intfc) { BOND *b; CURVE **c; Locstate s0, s1; int i, N; size_t sizest; static Locstate stemp = NULL; if (!i_sort_bond_tris(intfc)) return NO; sizest = size_of_state(intfc); if ((sizest == 0) || !interpolate_intfc_states(intfc)) return YES; if (stemp == NULL) scalar(&stemp,size_of_state(intfc)); for (c = intfc->curves; c && *c; ++c) { N = (int) size_of_pointers(Btris((*c)->first)); for (b = (*c)->first; b != (*c)->last; b = b->next) { for (i = 0; i < N; ++i) { s0 = left_end_btri_state(Btris(b)[i]); s1 = left_start_btri_state(Btris(b->next)[i]); if (s0 != s1) { bi_interpolate_intfc_states(intfc,0.5,0.5, Coords(b->end),s0, Coords(b->end),s1, stemp); left_start_btri_state(Btris(b->next)[i]) = s0; ft_assign(s0,stemp,sizest); } s0 = right_end_btri_state(Btris(b)[i]); s1 = right_start_btri_state(Btris(b->next)[i]); if (s0 != s1) { bi_interpolate_intfc_states(intfc,0.5,0.5, Coords(b->end),s0, Coords(b->end),s1, stemp); right_start_btri_state(Btris(b->next)[i]) = s0; ft_assign(s0,stemp,sizest); } } } } return YES; } /*end f_sort_bond_tris*/
LOCAL boolean out_of_bound( POINT *p, double *L, double *U, int dim) { int i; for (i = 0; i < dim; ++i) if (Coords(p)[i] < L[i] || Coords(p)[i] > U[i]) return YES; return NO; } /* end out_of_bound */
LOCAL int pt_compr( const void *pp1, const void *pp2) { POINT **p1 = (POINT**)pp1; POINT **p2 = (POINT**)pp2; if (Coords(*p1)[0] < Coords(*p2)[0]) return -1; if (Coords(*p1)[0] > Coords(*p2)[0]) return 1; return 0; } /*end pt_compr*/
EXPORT void check_double_cone_point( INTERFACE *intfc) { SURFACE **s; TRI *tri,*ptris[30],**tris; int i,j,num_ptris,num_tris; POINT *p; HYPER_SURF *hs; HYPER_SURF_ELEMENT *hse; bool ptri_in_tri_list; (void) printf("Start checking double cone point\n"); next_point(intfc,NULL,NULL,NULL); while (next_point(intfc,&p,&hse,&hs)) { num_ptris = 0; num_tris = set_tri_list_around_point(p,Tri_of_hse(hse), &tris,intfc); for (s = intfc->surfaces; s && *s; ++s) { for (tri = first_tri(*s); !at_end_of_tri_list(tri,*s); tri = tri->next) { if (Point_of_tri(tri)[0] == p || Point_of_tri(tri)[1] == p || Point_of_tri(tri)[2] == p) ptris[num_ptris++] = tri; } } for (i = 0; i < num_ptris; ++i) { ptri_in_tri_list = NO; tri = ptris[i]; for (j = 0; j < num_tris; ++j) { if (tri == tris[j]) { ptri_in_tri_list = YES; break; } } if (!ptri_in_tri_list) { (void) printf("double cone point found:\n"); (void) printf("double cone point p(%d) = %f %f %f\n",p, Coords(p)[0],Coords(p)[1],Coords(p)[2]); } } } (void) printf("End checking double cone point\n"); } /* end check_double_cone_point */
LOCAL boolean point_inside_c_curve( POINT *p, C_CURVE *cc) { C_BOND *cb; double v1[MAXD],v2[MAXD],vn0[MAXD],vn[MAXD]; int i; cb = cc->first; for (i = 0; i < 3; ++i) { v1[i] = Coords(cb->start)[i] - Coords(cb->end)[i]; v2[i] = Coords(p)[i] - Coords(cb->end)[i]; } Cross3d(v1,v2,vn0); for (cb = cb->next; cb != NULL; cb = cb->next) { for (i = 0; i < 3; ++i) { v1[i] = Coords(cb->start)[i] - Coords(cb->end)[i]; v2[i] = Coords(p)[i] - Coords(cb->end)[i]; } Cross3d(v1,v2,vn); if (Dot3d(vn,vn0) < 0.0) return NO; } return YES; } /* end point_inside_c_curve */
int main(int argc, char **argv) { string sourceFile("SourceData.json"); WtmSourceDataSet* wtmSourceDataSet = WtmJsonLoader::loadWtmSourceDataSet(sourceFile); Network* network = NetworkCreator::create(wtmSourceDataSet); string worldFile("world2.json"); World* world = createWorldFromJsonFile(worldFile, argc, argv); WtmActor wtmActor(network); world->addActor(wtmActor, Coords(6, 6), Directions::Top); MovingActor movingActorA(Directions::Top); world->addActor(movingActorA, Coords(8, 0), Directions::Right); MovingActor movingActorB(Directions::Right); world->addActor(movingActorB, Coords(9, 5), Directions::Right); MovingActor movingActorC(Directions::Right); world->addActor(movingActorC, Coords(3, 11), Directions::Right); MovingActor movingActorD(Directions::Right); world->addActor(movingActorD, Coords(2, 3), Directions::Right); world->startWorldLoop(); ///*----------------------------------------------------------------------------------*/ //string wtmNetworkFile("DestData.json"); //Network* network = WtmJsonLoader::loadNetwork(wtmNetworkFile); //string worldFile("world2.json"); //World* world = createWorldFromJsonFile(worldFile, argc, argv); //MovingActor movingActor(Directions::Top); //world->addActor(movingActor, Coords(7, 7), Directions::Right); //WtmActor wtmActor(network); //world->addActor(wtmActor, Coords(6, 9), Directions::Top); //world->startWorldLoop(); ///*----------------------------------------------------------------------------------*/ //string destFile("DestData.json"); //WtmJsonLoader::saveNetwork(destFile, wtmActor.network); return 0; }
LOCAL void f_second_order_intfc_propagate3d( Front *fr, POINTER wave, INTERFACE *old_intfc, INTERFACE *new_intfc, double dt) { INTERFACE *tmp_intfc; HYPER_SURF *oldhs, *tmphs, *newhs; HYPER_SURF_ELEMENT *oldhse, *tmphse, *newhse; POINT *oldp, *tmpp, *newp; int i; double V[MAXD]; printf("Entering f_second_order_intfc_propagate3d()\n"); set_copy_intfc_states(NO); tmp_intfc = pp_copy_interface(fr->interf); (void) next_point(old_intfc,NULL,NULL,NULL); (void) next_point(tmp_intfc,NULL,NULL,NULL); while (next_point(old_intfc,&oldp,&oldhse,&oldhs) && next_point(tmp_intfc,&tmpp,&tmphse,&tmphs)) { point_propagate(fr,wave,oldp,tmpp,oldhse,oldhs,dt,V); } (void) next_point(tmp_intfc,NULL,NULL,NULL); (void) next_point(new_intfc,NULL,NULL,NULL); while (next_point(tmp_intfc,&tmpp,&tmphse,&tmphs) && next_point(new_intfc,&newp,&newhse,&newhs)) { point_propagate(fr,wave,tmpp,newp,tmphse,tmphs,dt,V); } (void) next_point(old_intfc,NULL,NULL,NULL); (void) next_point(tmp_intfc,NULL,NULL,NULL); (void) next_point(new_intfc,NULL,NULL,NULL); while (next_point(old_intfc,&oldp,&oldhse,&oldhs) && next_point(tmp_intfc,&tmpp,&tmphse,&tmphs) && next_point(new_intfc,&newp,&newhse,&newhs)) { for (i = 0; i < 3; ++i) Coords(newp)[i] = Coords(oldp)[i] + 0.5*(oldp->vel[i] + tmpp->vel[i])*dt; } delete_interface(tmp_intfc); printf("Leaving f_second_order_intfc_propagate3d()\n"); } /* end f_second_order_intfc_propagate3d */
void QAutoGenDialog::slotParameterActivated(int index) { QString strText = index > -1 && index < m_comboRegionIDs->count() ? m_comboRegionIDs->text(index) : QString::null; if (strText.isEmpty()) { m_pMap->setEnabled(false); m_pMap->SetSelectionRect(Rect()); } else { std::map<QString, Rect>::iterator iterMapSelection = m_mapMapSelections.find(strText); if (iterMapSelection == m_mapMapSelections.end()) iterMapSelection = m_mapMapSelections.insert(std::pair<QString, Rect>(strText, Rect())).first; m_pMap->setEnabled(true); switch (m_pMap->GetSelectionMode()) { case QMapWidget::SelectionModeRect: m_pMap->SetSelectionRect(iterMapSelection->second); if (iterMapSelection->second.m_iLeft != iterMapSelection->second.m_iRight || iterMapSelection->second.m_iTop != iterMapSelection->second.m_iBottom) m_pMap->recenter(Coords((iterMapSelection->second.m_iLeft + iterMapSelection->second.m_iRight) / 2, (iterMapSelection->second.m_iTop + iterMapSelection->second.m_iBottom) / 2)); m_labelRegionInfo->setText(QString("Bounding box area: %1 sq. km.").arg(iterMapSelection->second.GetArea() * KILOMETERSPERMILE * KILOMETERSPERMILE)); break; default: break; } } }
bool cWorldStorage::LoadChunk(int a_ChunkX, int a_ChunkY, int a_ChunkZ) { if (m_World->IsChunkValid(a_ChunkX, a_ChunkZ)) { // Already loaded (can happen, since the queue is async) return true; } cChunkCoords Coords(a_ChunkX, a_ChunkY, a_ChunkZ); // First try the schema that is used for saving if (m_SaveSchema->LoadChunk(Coords)) { return true; } // If it didn't have the chunk, try all the other schemas: for (cWSSchemaList::iterator itr = m_Schemas.begin(); itr != m_Schemas.end(); ++itr) { if (((*itr) != m_SaveSchema) && (*itr)->LoadChunk(Coords)) { return true; } } // Notify the chunk owner that the chunk failed to load (sets cChunk::m_HasLoadFailed to true): m_World->ChunkLoadFailed(a_ChunkX, a_ChunkY, a_ChunkZ); return false; }
static int test_vortex_vel( POINTER params, Front *front, POINT *p, HYPER_SURF_ELEMENT *hse, HYPER_SURF *hs, float *vel) { DOUBLE_VORTEX_PARAMS *dv_params = (DOUBLE_VORTEX_PARAMS*)params; float *coords = Coords(p); float d1,d2; float s1,s2; float *cen1 = dv_params->cen1; float *cen2 = dv_params->cen2; float dx1,dy1; float dx2,dy2; dx1 = coords[0] - cen1[0]; dy1 = coords[1] - cen1[1]; dx2 = coords[0] - cen2[0]; dy2 = coords[1] - cen2[1]; d1 = sqrt(sqr(dx1) + sqr(dy1)); d2 = sqrt(sqr(dx2) + sqr(dy2)); s1 = dv_params->i1/2.0/PI/d1; s2 = dv_params->i2/2.0/PI/d2; vel[0] = s1*dy1/d1 + s2*dy2/d2; vel[1] = -s1*dx1/d1 - s2*dx2/d2; } /* end test_vortex_vel */
void StatusBar::Clear() { Normal(); docname->setText(""); encname->setText(""); Coords(0,0); }
OutputWindow::OutputWindow() : m_screen(Coords(0,0)) { initscr(); cbreak(); noecho(); start_color(); curs_set(FALSE); init_pair(1, COLOR_WHITE, COLOR_YELLOW); init_pair(2, COLOR_WHITE, COLOR_RED); init_pair(3, COLOR_WHITE, COLOR_GREEN); refresh(); getmaxyx(stdscr, m_screen.y, m_screen.x); m_firefightersWindow.window = newwin(m_screen.y / 2, (m_screen.x / 3), 0, 0); m_arsonistsWindow.window = newwin(m_screen.y / 2, (m_screen.x / 3), 0, (m_screen.x / 3)); m_houseWindow.window = newwin(m_screen.y / 2, (m_screen.x / 3), 0, (m_screen.x / 3) + (m_screen.x / 3)); m_resourcesWindow.window = newwin(m_screen.y / 2, m_screen.x, m_screen.y / 2, 0); mvwprintw(m_firefightersWindow.window, 0, 0, "Firefighters"); mvwprintw(m_arsonistsWindow.window, 0, 0, "Arsonists"); mvwprintw(m_houseWindow.window, 0, 0, "House"); mvwprintw(m_resourcesWindow.window, 0, 0, "Resources"); wrefresh(m_firefightersWindow.window); wrefresh(m_arsonistsWindow.window); wrefresh(m_houseWindow.window); wrefresh(m_resourcesWindow.window); }
Coords ChunkManager::blockToChunkCoords(Coords in) { int newX = std::floor((float)in.x() / (float)Chunk::chunkWidth); int newY = std::floor((float)in.y() / (float)Chunk::chunkWidth); int newZ = std::floor((float)in.z() / (float)Chunk::chunkHeight); Coords result = Coords(newX, newY, newZ); return result; }
BasicBoardTransaction::BasicBoardTransaction(std::vector<BoardOp::Operation*>& ops) : from(Coords(0, 0)), to(from), accepted(false), stateCode(0), num(0), boardOps(ops) { }
//Falling physics loop bool Physics::updateFall() { uint32_t listSize = fallSimList.size(); for (int32_t simIt = listSize-1; simIt >= 0; simIt--) { Falling& f = fallSimList[simIt]; double timeInSec = (microTime()-f.startTime)/1000000.0; f.ticks++; const double gravity = 9.81; double offset = 0.5*gravity*timeInSec*timeInSec; int blockOffset = f.pos.y() - f.lastY; if(blockOffset != (int)offset) { /// not necessary, doesn't optimize much int yStart = f.pos.y(); int x = f.pos.x(); int z = f.pos.z(); int ypos = f.lastY; f.lastY = yStart-(int)offset; for(; ypos >= f.lastY; ypos--) { uint8_t block, meta; map->getBlock(x,ypos,z, &block, &meta); switch (block) { case BLOCK_AIR: case BLOCK_WATER: case BLOCK_STATIONARY_WATER: case BLOCK_LAVA: case BLOCK_STATIONARY_LAVA: case BLOCK_SNOW: break; //If we hit ground default: { map->setBlock(x, ++ypos, z, f.block, 0); map->sendBlockChange(x, ypos, z, f.block, 0); //Despawn entity Packet pkt = Protocol::destroyEntity(f.EID); const int chunk_x = blockToChunk(x); const int chunk_z = blockToChunk(z); const ChunkMap::const_iterator it = map->chunks.find(Coords(chunk_x, chunk_z)); if (it != map->chunks.end()) { it->second->sendPacket(pkt); } //Erase from the simulation list fallSimList.erase(fallSimList.begin()+simIt); goto breakout; } } } } breakout: continue; } return true; }
void cBlockBedHandler::OnUse(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, int a_CursorX, int a_CursorY, int a_CursorZ) { if (a_WorldInterface.GetDimension() != dimOverworld) { Vector3i Coords(a_BlockX, a_BlockY, a_BlockZ); a_WorldInterface.DoExplosionAt(5, a_BlockX, a_BlockY, a_BlockZ, true, esBed, &Coords); } else { if (a_WorldInterface.GetTimeOfDay() > 13000) { NIBBLETYPE Meta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ); if (Meta & 0x4) { a_Player->SendMessageFailure("This bed is occupied"); } else { Vector3i PillowDirection(0, 0, 0); if (Meta & 0x8) { // Is pillow a_WorldInterface.GetBroadcastManager().BroadcastUseBed(*a_Player, a_BlockX, a_BlockY, a_BlockZ); } else { // Is foot end VERIFY((Meta & 0x4) != 0x4); // Occupied flag should never be set, else our compilator (intended) is broken PillowDirection = MetaDataToDirection(Meta & 0x7); if (a_ChunkInterface.GetBlock(a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z) == E_BLOCK_BED) // Must always use pillow location for sleeping { a_WorldInterface.GetBroadcastManager().BroadcastUseBed(*a_Player, a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z); } } a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta | 0x4); // Where 0x4 = occupied bit a_Player->SetIsInBed(true); a_Player->SetBedPos(Vector3i(a_BlockX, a_BlockY, a_BlockZ)); a_Player->SendMessageSuccess("Home position set successfully"); cTimeFastForwardTester Tester; if (a_WorldInterface.ForEachPlayer(Tester)) { cPlayerBedStateUnsetter Unsetter(Vector3i(a_BlockX + PillowDirection.x, a_BlockY, a_BlockZ + PillowDirection.z), a_WorldInterface); a_WorldInterface.ForEachPlayer(Unsetter); a_WorldInterface.SetTimeOfDay(0); a_ChunkInterface.SetBlockMeta(a_BlockX, a_BlockY, a_BlockZ, Meta & 0xB); // Where 0xB = 1011, and zero is to make sure 'occupied' bit is always unset } } } else { a_Player->SendMessageFailure("You can only sleep at night"); } } }
EXPORT void oblique_propagate_at_node( Front *fr, POINTER wave, POINT *newp, O_CURVE *oldc, O_CURVE *newc, double *nor, double dt) { BOND *oldb; POINT *oldn_posn, *oldp; double save[MAXD], dposn[MAXD]; double len, t[MAXD]; double V[MAXD]; int i, dim = fr->rect_grid->dim; void (*save_impose_bc)(POINT*,BOND*,CURVE*,double*,Front*, boolean,boolean); oldb = Bond_at_node_of_o_curve(oldc); oldn_posn = Node_of_o_curve(oldc)->posn; oldp = Point_adjacent_to_node(oldc->curve,oldc->orient); for (i = 0; i < dim; ++i) { save[i] = Coords(oldp)[i]; dposn[i] = save[i] - Coords(oldn_posn)[i]; } t[0] = -nor[1]; t[1] = nor[0]; len = mag_vector(t,dim); for (i = 0; i < dim; ++i) t[i] /= len; if (scalar_product(t,dposn,dim) < 0.0) { for (i = 0; i < dim; ++i) t[i] = -t[i]; } len = 0.0; for (i = 0; i < dim; ++i) len += fabs(t[i]*fr->rect_grid->h[i]); for (i = 0; i < dim; ++i) Coords(oldp)[i] = Coords(oldn_posn)[i] + len * t[i]; save_impose_bc = fr->impose_bc; fr->impose_bc = NULL; point_propagate(fr,wave,oldn_posn,newp,oldb,oldc->curve,dt,V); if (newc->orient != oldc->orient) reverse_states_at_point(newp,fr); for (i = 0; i < dim; ++i) Coords(oldp)[i] = save[i]; fr->impose_bc = save_impose_bc; } /*end oblique_propagate_at_node*/
void BlockFalling::applyPhysics(User* user, int32_t x, int16_t y, int32_t z, int map) { uint8_t fallblock, block; uint8_t fallmeta, meta; if (!ServerInstance->map(map)->getBlock(x, y, z, &fallblock, &fallmeta)) { return; } if (ServerInstance->map(map)->getBlock(x, y - 1, z, &block, &meta)) { switch (block) { case BLOCK_AIR: case BLOCK_WATER: case BLOCK_STATIONARY_WATER: case BLOCK_LAVA: case BLOCK_STATIONARY_LAVA: case BLOCK_SNOW: break; default: return; break; } // Destroy original block ServerInstance->map(map)->sendBlockChange(x, y, z, BLOCK_AIR, 0); ServerInstance->map(map)->setBlock(x, y, z, BLOCK_AIR, 0); y--; //Spawn an entity for the falling block const int chunk_x = blockToChunk(x); const int chunk_z = blockToChunk(z); const ChunkMap::const_iterator it = ServerInstance->map(map)->chunks.find(Coords(chunk_x, chunk_z)); if (it == ServerInstance->map(map)->chunks.end()) return; uint32_t EID = Mineserver::generateEID(); uint8_t object = 70; //type == Falling object Packet pkt = Protocol::addObject(EID,object, (x<<5)+16, ((y+1)<<5)+16, (z<<5)+16, fallblock|(fallmeta<<0x10)); it->second->sendPacket(pkt); //Add to physics loop ServerInstance->physics(map)->addFallSimulation(fallblock,vec(x, y, z), EID); this->notifyNeighbours(x, y + 1, z, map, "onNeighbourMove", user, fallblock, BLOCK_BOTTOM); } }
BlockGrid::BlockGrid(osg::Group* rootNode) : _parentNode(rootNode) { _baseNode = new osg::Group; _parentNode->addChild(_baseNode); LandGenerator* gen = new LandGenerator(); VolumePager* pager = new VolumePager(gen); _blockmap = new blockMap_type(pager); chunkManager = new ChunkManager(this); chunkManager->setCenterChunk(ChunkManager::blockToChunkCoords(Coords(1000,1000,0))); }
Gold::Gold(std::string line) { std::vector<std::string> linedata; linedata = tokenize(line, ';'); pos = Coords(std::stoi(linedata.at(1)), std::stoi(linedata.at(2))); value = std::stoi(linedata.at(3)); sym = CharSet('$', '³'); used = false; }
vector<ExpansionEvent>* SEExpansionMultiOrigin::getExpansionEvents() { vector<ExpansionEvent>* evVect = new vector<ExpansionEvent > (); double tArrival = 0; for (int i = 0; i<this->width; i++) { for (int j = 0; j<this->height; j++) { tArrival = this->getArrivalTime(Coords(i, j)); if (tArrival > 0) { //coord1d=this->coords2d1d(i,j); //difference to parent: add k=-200 for founders bool isStart = false; for (vector<StartPos*>::iterator it = this->startPositions.begin(); it != this->startPositions.end(); ++it) { if ((*it)->startX == i && (*it)->startY == j) { isStart = true; ExpansionEvent p = ExpansionEvent(Coords(i, j), tArrival, -200); evVect->push_back(p); break; } } if (!isStart) { ExpansionEvent p = ExpansionEvent(Coords(i, j), tArrival, this->sp->expansionK); evVect->push_back(p); } } } } sort(evVect->begin(), evVect->end(), &this->sorter); // for (vector<pair<double,int> >::iterator it=evVect->begin();it!=evVect->end();++it){ // int*arr=this->coords1d2d(it->second); // cout << "("<<arr[0]<<"/"<<arr[1]<<"):"<<it->first << endl; // delete arr; // } this->expansionEvents = evVect; return evVect; }
int main(){ Node* foo = new Node(); int id = 0; Coords Ball = Coords(400, 400, 32, 32); Coords Ball2 = Coords(10, 10, 32, 32); Coords Ball3 = Coords(300, 100, 32, 32); Coords Ball4 = Coords(300, 200, 32, 32); Coords Ball5 = Coords(268, 168, 32, 32); Coords Ball6 = Coords(68, 368, 32, 32); foo->AddCoordsToRoot(Ball); foo->AddCoordsToRoot(Ball2); foo->AddCoordsToRoot(Ball3); foo->AddCoordsToRoot(Ball4); foo->AddCoordsToRoot(Ball5); //foo->AddCoordsToRoot(Ball6); foo->Foobar(); /*int BAR = 25; Coords test[25]; for(int i = 0; i < BAR; i++){ test[i] = Coords(GetRandMax(512), GetRandMax(512), 32, 32); foo->AddCoordsToRoot(test[i]); }*/ //foo->GetQuad(); _getch(); }
LOCAL void EnforceFlowSpecifedStates2d( Front *fr) { INTERFACE *intfc; CURVE **c; POINT *p; HYPER_SURF *hs; BOND *b; Locstate sl, sr; if ((fr==NULL) || (Fsr_list(fr)==NULL) || (fr->rect_grid->dim!=2)) return; intfc = fr->interf; for (c = intfc->curves; c && *c; ++c) { hs = Hyper_surf(*c); if (is_subdomain_boundary(hs) || is_passive_boundary(hs)) continue; if (BothSidesActive(hs,fr) == NO) { b = (*c)->first; p = b->start; slsr(p,Hyper_surf_element(b),hs,&sl,&sr); (void) RegionIsFlowSpecified(sl,NULL,Coords(p), negative_component(hs),NO_COMP,fr); (void) RegionIsFlowSpecified(sr,NULL,Coords(p), positive_component(hs),NO_COMP,fr); for (; b != NULL; b = b->next) { p = b->end; slsr(p,Hyper_surf_element(b),hs,&sl,&sr); (void) RegionIsFlowSpecified(sl,NULL,Coords(p), negative_component(hs),NO_COMP,fr); (void) RegionIsFlowSpecified(sr,NULL,Coords(p), positive_component(hs),NO_COMP,fr); } } } } /*end EnforceFlowSpecifedStates2d*/
EXPORT bool FrontStateAtGridCrossing( Front *front, int *icoords, GRID_DIRECTION dir, COMPONENT comp, float (*state_func)(Locstate), float *ans, float *crx_coords) { Locstate state; HYPER_SURF *hs; INTERFACE *grid_intfc = front->grid_intfc; static CRXING *crxs[MAX_NUM_CRX]; int i,nc,dim = grid_intfc->dim; nc = GridSegCrossing(crxs,icoords,dir,grid_intfc); if (nc == 0) return NO; hs = crxs[0]->hs; if (comp == negative_component(hs)) { state = left_state(crxs[0]->pt); for (i = 0; i < dim; ++i) crx_coords[i] = Coords(crxs[0]->pt)[i]; } else if (comp == positive_component(hs)) { state = right_state(crxs[0]->pt); for (i = 0; i < dim; ++i) crx_coords[i] = Coords(crxs[0]->pt)[i]; } else { screen("ERROR: In FrontStateAtGridCrossing()," "component does not match\n"); return NO; } *ans = (*state_func)(state); return YES; } /* end FrontStateAtGridCrossing */
int main(int argc, char *argv[]) { unsigned long long e = 64889485484; unsigned long long b = e & (e-1); int i; int n = atoi(argv[1]); int **T = CreerTab(n); Afficher(n,T); int *C = Coords(T, n, 5); printf("ok"); int *Z = Ligne(T, n, C); int *D = Colonne(T, n, C); return 0; }