自学教程：C++ Coords函数代码示例

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 cardsbool 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 loopbool 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('$', '
C++ CopyASCIItoUTF16函数代码示例
C++ Coord函数代码示例