Exemplo n.º 1
0
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*/
Exemplo n.º 2
0
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*/
Exemplo n.º 3
0
// 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;
}
Exemplo n.º 4
0
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
}
Exemplo n.º 5
0
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");

}
Exemplo n.º 6
0
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*/
Exemplo n.º 7
0
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 */
Exemplo n.º 8
0
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*/
Exemplo n.º 9
0
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 */
Exemplo n.º 10
0
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 */
Exemplo n.º 11
0
Arquivo: wtm.cpp Projeto: eidcraft/wtm
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;
}
Exemplo n.º 12
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 */
Exemplo n.º 13
0
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;
		}
	}
}
Exemplo n.º 14
0
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;
}
Exemplo n.º 15
0
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 */
Exemplo n.º 16
0
void StatusBar::Clear()
{
  Normal();
  docname->setText("");
  encname->setText("");
  Coords(0,0);
}
Exemplo n.º 17
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);
}
Exemplo n.º 18
0
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;
}
Exemplo n.º 19
0
 BasicBoardTransaction::BasicBoardTransaction(std::vector<BoardOp::Operation*>& ops) :
     from(Coords(0, 0)),
     to(from),
     accepted(false),
     stateCode(0),
     num(0),
     boardOps(ops) {
 }
Exemplo n.º 20
0
//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;
}
Exemplo n.º 21
0
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");
		}
	}
}
Exemplo n.º 22
0
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*/
Exemplo n.º 23
0
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);

  }
}
Exemplo n.º 24
0
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)));
}
Exemplo n.º 25
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;
}
Exemplo n.º 26
0
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;
}
Exemplo n.º 27
0
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();
}
Exemplo n.º 28
0
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*/
Exemplo n.º 29
0
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 */
Exemplo n.º 30
0
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;
}