Exemple #1
0
void calc_src_coef2(u32 *div_M, u32 *fac_N, u32 freq)
{
	u32 m, n;
	u64 temp;
	u32 temp_m = 0;
	u32 temp_n = 0;
	u64 cur_val = 0;

	if(freq > 4200000000UL) {
		freq = 4200000000UL;
		__wrn("warning: freq set is over 4200M\n");
	}

	for(n = 12; n < 256; n++)
		for(m = 0; m < 2; m++)
		{
			temp = n;
			temp = temp * 24000000;
			temp = temp / (m + 1);
			if(dif(temp, freq) < dif(cur_val, freq))
			{
				temp_m = m;
				temp_n = n;
				cur_val = temp;
			}
		}

		*div_M = temp_m;
		*fac_N = temp_n;
}
Exemple #2
0
void calc_pll8_coef(u32 *div_M, u32 *div_P, u32 *fac_N, u32 freq)
{
	u32 m, p, n;
	u64 temp;
	u32 temp_m = 0;
	u32 temp_p = 0;
	u32 temp_n = 0;
	u64 cur_val = 0;

	if(freq > 4200000000UL) {
		freq = 4200000000UL;
		__wrn("warning: freq set is over 4200M\n");
	}

	for(n = 12; n < 256; n++)
		for(m = 0; m < 2; m++)
			for(p = 0; p < 3; p++)
			{
				temp = n;
				temp = temp * 24000000;
				temp = temp / ((m + 1) * pow2(p));
				if(dif(temp, freq) < dif(cur_val, freq))
				{
					temp_m = m;
					temp_p = p;
					temp_n = n;
					cur_val = temp;
				}
			}

	*div_M = temp_m;
	*div_P = temp_p;
	*fac_N = temp_n;
}
Exemple #3
0
static status
centerArea(Area a, Point pos)
{ assign(a, x, dif(pos->x,a->w));
  assign(a, y, dif(pos->y,a->h));

  succeed;
}
Exemple #4
0
 void compute( const FUNC& f, const X & x, const o_t & o)
 {
   real_t tmptol = tol_;
   init(o, x);
   BOOST_AUTO_TPL(dif, nt2::abs(nt2::diff(nt2::rowvect(wpts_))));
   real_t tol1= tol_/nt2::globalasum1(dif);
   size_t l = numel(dif);
   res_.resize(extent(wpts_));
   res_(1) = nt2::Zero<value_t>();
   tol_ = tol1*dif(1);
   res_(2) = compute<true>(f, wpts_(1), wpts_(2));
   for(size_t i=2; i < l; ++i)
   {
     tol_ = tol1*dif(i);
     res_(i+1) = res_(i)+compute<false>(f, wpts_(i), wpts_(i+1));
   }
   if (l >= 2)
   {
     tol_ = tol1*dif(l);
     res_(l+1) = res_(l)+compute<true>(f, wpts_(l), wpts_(l+1));
   }
   tol_ = tmptol;
   if (!o.return_waypoints)
   {
     res_(begin_) = res_(end_);
     res_.resize(nt2::of_size(1, 1));
   }
 }
Exemple #5
0
void calc_src_coef3(u32 *div_M, u32 *fac_K, u32 *fac_N, u32 src_freq, u32 freq)
{
	u32 m, k, n;
	u64 temp;
	u32 temp_m = 0;
	u32 temp_k = 0;
	u32 temp_n = 0;
	u64 cur_val = 0;

	freq = freq > 1440000000 ? 1440000000 : freq;

	for(n = 0; n < 16; n++)
		for(k = 0; k < 4; k++)
			for(m = 0; m < 16; m++)
			{
				temp = src_freq;
				temp = temp * (n + 1) * (k + 1) / (m + 1);
				if(dif(temp, freq) < dif(cur_val, freq))
				{
					temp_m = m;
					temp_k = k;
					temp_n = n;
					cur_val = temp;
				}
			}

	*div_M = temp_m;
	*fac_K = temp_k;
	*fac_N = temp_n;
}
Exemple #6
0
void calc_src_coef2(u32 *div_M, u32 *fac_N, u32 freq)
{
	u32 m, n;
	u64 temp;
	u32 temp_m = 0;
	u32 temp_n = 0;
	u64 cur_val = 0;

	freq = freq > 1440000000 ? 1440000000 : freq;

	for(n = 0; n < 128; n++)
		for(m = 0; m < 16; m++)
		{
			temp = 24000000 * (n + 1) / (m + 1);
			if(dif(temp, freq) < dif(cur_val, freq))
			{
				temp_m = m;
				temp_n = n;
				cur_val = temp;
			}
		}

		*div_M = temp_m;
		*fac_N = temp_n;
}
int main()
{
    int L;
    char h[2000001];
    while (scanf("%d ", &L) && L)
    {
        gets(h);
        int ur = INF, ud = INF, dist = INF, dist_a;
        for (int i = 0; i < L; i++)
        {
            if (h[i] == 'Z')
            {
                dist = 0;
                break;
            }
            else if (h[i] == 'R')
            {
                ur = i;
                if ((dist_a = dif(ur, ud)) < dist)
                    dist = dist_a;
            }
            else if (h[i] == 'D')
            {
                ud = i;
                if ((dist_a = dif(ur, ud)) < dist)
                    dist = dist_a;
            }
        }
        printf("%d\n", dist);
    }
    return 0;
}
Exemple #8
0
// Distance between 2 points
_inline int GetDistance(int xp, int yp, int xp2, int yp2)
{
	// Allow decimal calculation
	double x = xp;
	double y = yp;
	double x2 = xp2;
	double y2 = yp2;

	return (int)sqrt((dif (x,x2) * dif (x,x2))+(dif (y,y2) * dif (y,y2)));
}
Exemple #9
0
/*
 *  handles the "directive" state after the "ignore" state
 */
static int direce(lex_t *t)
{
    int i = NELEM(dtab), ign;

    assert(cond_ignore());
    ign = cond_list->f.ignore;

    NEXTSP(t);    /* consumes # */
    if (t->id == LEX_ID) {
        const char *n = LEX_SPELL(t);
        for (i = 0; i < NELEM(dtab); i++)
            if (strcmp(n, dtab[i].name) == 0)
                break;
        switch(i) {
            case DINCLUDE:
            case DDEFINE:
            case DUNDEF:
            case DLINE:
            case DERROR:
            case DPRAGMA:
            default:
                i = NELEM(dtab);
                break;
            case DIF:
                t = dif(t->pos, COND_KIF, 1);
                break;
            case DIFDEF:
                t = dif(t->pos, COND_KIFDEF, 1);
                break;
            case DIFNDEF:
                t = dif(t->pos, COND_KIFNDEF, 1);
                break;
            case DELIF:
                t = delif(t->pos);
                break;
            case DELSE:
                t = delse(t->pos);
                break;
            case DENDIF:
                t = dendif(t->pos);
                break;
        }
    }

    if (warnxtra[i] && ign != 2) {
        SKIPSP(t);
        if (t->id != LEX_NEWLINE)
            t = xtratok(t);
    }
    SKIPNL(t);
    lst_discard(1);
    lex_direc = 0;

    return 0;
}
Exemple #10
0
void title::sceneChange() {
  if (state_ > Blink3) {
    clear_ ? data::reStart(dif(click_mode_ - Easy)) :
      data::newGame(dif(click_mode_ - Easy));
    data::system.scene_[play::Next] = scene::Politics;
  }

  if (click_mode_ == Continue && state_ > Blink2) {
    data::system.scene_[play::Last] = scene::Title;
    data::system.scene_[play::Next] = scene::Load;
  }
}
Exemple #11
0
void test(){

    std::cout << sum_of_2_numbers(3,5,999) << std::endl;
    std::cout << sum_of_fib(4000000) << std::endl;
    factorize(13195);
    factorize(600851475143);
    std::cout << findPalindrom() << std::endl;
    std::cout << dif(10) << std::endl;
    std::cout.precision(20);
    std::cout << dif(100) << std::endl;
    //std::cout << prime10001() << std::endl;
    std::cout << biggestProduct("/home/paulina/ClionProjects/EulerProb1/Problem8") << std::endl;
}
void CGeoSquareProjectile::Draw(void)
{
	inArray=true;
	unsigned char col[4];
	col[0]=(unsigned char) (r*a*255);
	col[1]=(unsigned char) (g*a*255);
	col[2]=(unsigned char) (b*a*255);
	col[3]=(unsigned char) (a*255);

	float3 dif(p1-camera->pos);
	dif.Normalize();
	float3 dir1(dif.cross(v1));
	dir1.Normalize();
	float3 dif2(p2-camera->pos);
	dif2.Normalize();
	float3 dir2(dif2.cross(v2));
	dir2.Normalize();

	if(w2!=0){
		va->AddVertexTC(p1-dir1*w1,1.0/16,1.0/8,col);
		va->AddVertexTC(p1+dir1*w1,1.0/16,0.0/8,col);
		va->AddVertexTC(p2+dir2*w2,1.0/16,0.0/8,col);
		va->AddVertexTC(p2-dir2*w2,1.0/16,1.0/8,col);
	} else {
		va->AddVertexTC(p1-dir1*w1,1.0/16,1.0/8,col);
		va->AddVertexTC(p1+dir1*w1,1.0/16,0.0/8,col);
		va->AddVertexTC(p2+dir2*w2,1.0/16,0.5/8,col);
		va->AddVertexTC(p2-dir2*w2,1.0/16,1.5/8,col);
	}
}
    int trap(int A[], int n) {
	vector<int> left(n,0),right(n,0);

	int max=0;
	for(int i=0;i<n;++i) {
	    left[i] = max;
	    if(max<A[i])
		max=A[i];
	}

	max = 0;
	for(int i=n-1;i>=0;--i) {
	    right[i] = max;
	    if(max<A[i])
		max=A[i];
	}

	vector<int> filled(n,0),dif(n,0);
	int ret = 0;
	for(int i=0;i<n;++i) {
	    filled[i] = min(left[i],right[i]);
	    dif[i] = filled[i]-A[i];
	    if(dif[i]>0)
		ret += dif[i];
	}

	return ret;
    }
void GUIminimap::MoveView(int xpos, int ypos, int button)
{
	float dist=ground->LineGroundCol(camera->pos,camera->pos+camera->forward*9000);
	float3 dif(0,0,0);
	if(dist>0){
		dif=camera->forward*dist;
	}
	float camHeight=camera->pos.y-ground->GetHeight(camera->pos.x,camera->pos.z);
	float3 clickPos;
	
	float xrel=xpos/(float)w;
	float yrel=ypos/(float)h;
	
	// FIXME: magic number: is this 8 maybe SQUARE_SIZE?
	clickPos.x=xrel*gs->mapx*8;
	clickPos.z=yrel*gs->mapy*8;
	float3 finalPos=clickPos-dif;

	if(guiGameControl->DirectCommand(clickPos, button))
	{
		downInMinimap=false;
		return;
	}
	
	if(button!=1)
		return;

	mouse->currentCamController->SetPos(clickPos);
}
void CExploSpikeProjectile::Draw(void)
{
	inArray=true;

	float3 dif(pos-camera->pos2);
	dif.Normalize();
	float3 dir2(dif.cross(dir));
	dir2.Normalize();

	unsigned char col[4];
	float a=std::max(0.f,alpha-alphaDecay*gu->timeOffset)*255;
	col[0]=(unsigned char)(a*color.x);
	col[1]=(unsigned char)(a*color.y);
	col[2]=(unsigned char)(a*color.z);
	col[3]=1;

	float3 interpos=pos+speed*gu->timeOffset;
	float3 l=dir*length+lengthGrowth*gu->timeOffset;
	float3 w=dir2*width;

	va->AddVertexTC(interpos+l+w, ph->laserendtex.xend, ph->laserendtex.yend, col);
	va->AddVertexTC(interpos+l-w, ph->laserendtex.xend, ph->laserendtex.ystart, col);
	va->AddVertexTC(interpos-l-w, ph->laserendtex.xstart, ph->laserendtex.ystart, col);
	va->AddVertexTC(interpos-l+w, ph->laserendtex.xstart, ph->laserendtex.yend, col);
}
void CGeoSquareProjectile::Draw()
{
	inArray = true;
	unsigned char col[4];
	col[0] = (unsigned char) (r * a * 255);
	col[1] = (unsigned char) (g * a * 255);
	col[2] = (unsigned char) (b * a * 255);
	col[3] = (unsigned char) (    a * 255);

	float3 dif(p1 - camera->GetPos());
	dif.ANormalize();
	float3 dir1(dif.cross(v1));
	dir1.ANormalize();
	float3 dif2(p2 - camera->GetPos());
	dif2.ANormalize();
	float3 dir2(dif2.cross(v2));
	dir2.ANormalize();


	const float u = (projectileDrawer->geosquaretex->xstart + projectileDrawer->geosquaretex->xend) / 2;
	const float v0 = projectileDrawer->geosquaretex->ystart;
	const float v1 = projectileDrawer->geosquaretex->yend;

	if (w2 != 0) {
		va->AddVertexTC(p1 - dir1 * w1, u, v1, col);
		va->AddVertexTC(p1 + dir1 * w1, u, v0, col);
		va->AddVertexTC(p2 + dir2 * w2, u, v0, col);
		va->AddVertexTC(p2 - dir2 * w2, u, v1, col);
	} else {
		va->AddVertexTC(p1 - dir1 * w1, u, v1,                    col);
		va->AddVertexTC(p1 + dir1 * w1, u, v0,                    col);
		va->AddVertexTC(p2,             u, v0 + (v1 - v0) * 0.5f, col);
		va->AddVertexTC(p2,             u, v0 + (v1 - v0) * 1.5f, col);
	}
}
GMMExpectationMaximization::uint GMMExpectationMaximization::execute(const MatrixX & dataset)
{  
  const uint data_count = dataset.rows();
  const uint num_gaussians = m_means.size();
  const uint dim = dataset.cols();

  MatrixX pxi(data_count,num_gaussians);
  MatrixX pix(data_count,num_gaussians);
  VectorX pxidatatot(data_count);
  VectorX weights(num_gaussians);
  VectorX ex(data_count);
  MatrixX ts(dim,dim);
  VectorX dif(dim);

  Real prev_log_likelyhood = 1.0;
  
  uint it_num;
  for (it_num = 0; it_num < m_max_iterations; it_num++)
  {
    for (uint g = 0; g < num_gaussians; g++)
      weights[g] = m_weights[g];

    for (uint d = 0; d < data_count; d++)
      for (uint g = 0; g < num_gaussians; g++)
        pxi(d,g) = gauss(m_means[g],m_covs[g],dataset.row(d).transpose());

    pxidatatot = pxi * weights;
    Real log_likelyhood = pxidatatot.array().log().sum() / Real(data_count);

    if (it_num != 0 && (std::abs(log_likelyhood / prev_log_likelyhood - 1.0) < m_termination_threshold))
      break;
    prev_log_likelyhood = log_likelyhood;

    for (uint d = 0; d < data_count; d++)
      pix.row(d) = (pxi.row(d).transpose().array() * weights.array()).transpose() / pxidatatot[d];
    
    ex = pix.colwise().sum();

    for(uint g = 0; g < num_gaussians; g++)
    {
      m_weights[g] = ex[g] / Real(data_count);

      m_means[g] = (dataset.transpose() * pix.col(g)) / ex[g];

      ts = MatrixX::Zero(dim,dim);
      for (uint d = 0; d < data_count; d++)
      {
        dif = dataset.row(d).transpose() - m_means[g];
        ts.noalias() += (dif * dif.transpose()) * pix(d,g);
      }
      m_covs[g] = (ts / ex[g]) + MatrixX::Identity(dim,dim) * m_epsilon;
    }

    // interruption point here
    if (m_termination_handler && m_termination_handler->isTerminated())
      return it_num;
  }

  return it_num;
}
Exemple #18
0
void Loader::LoadMaterial(const aiScene *pScene, const char *file_name)
{
    //store material
    for(int i = 0 ;i<pScene->mNumMaterials;i++)
    {
        aiColor3D dif(0.f,0.f,0.f);
        aiColor3D amb(0.f,0.f,0.f);
        aiColor3D spec(0.f,0.f,0.f);
        aiMaterial * the_material = pScene->mMaterials[i];
        CMC_Material * material = new CMC_Material();
        the_material->Get(AI_MATKEY_COLOR_AMBIENT,amb);
        the_material->Get(AI_MATKEY_COLOR_DIFFUSE,dif);
        the_material->Get(AI_MATKEY_COLOR_SPECULAR,spec);

        material->ambientColor = QVector3D(amb.r,amb.g,amb.b);
        material->diffuseColor = QVector3D(dif.r,dif.g,dif.b);
        material->specularColor = QVector3D(spec.r,spec.g,spec.b);
        aiString normalPath;
        the_material->GetTexture (aiTextureType_NORMALS,0,&normalPath);
        //now ,we only use the first diffuse texture, will fix it later
        aiString diffuse_Path;
        the_material->GetTexture(aiTextureType_DIFFUSE,0,&diffuse_Path);
        if(diffuse_Path.length == 0 )
        {
            material->diffuseTexturePath = "INVALID";
        }else
        {
            material->diffuseTexturePath = diffuse_Path.C_Str ();
        }
        m_model->addMaterial (material);
    }
}
void CGenericParticleProjectile::Draw()
{
	inArray = true;

	if (directional) {
		float3 dif(pos-camera->GetPos());
		dif.ANormalize();
		float3 dir1(dif.cross(speed));
		dir1.ANormalize();
		float3 dir2(dif.cross(dir1));

		unsigned char color[4];

		colorMap->GetColor(color, life);

		va->AddVertexTC(drawPos - dir1 * size - dir2 * size, texture->xstart, texture->ystart, color);
		va->AddVertexTC(drawPos - dir1 * size + dir2 * size, texture->xend,   texture->ystart, color);
		va->AddVertexTC(drawPos + dir1 * size + dir2 * size, texture->xend,   texture->yend,   color);
		va->AddVertexTC(drawPos + dir1 * size - dir2 * size, texture->xstart, texture->yend,   color);
	} else {
		unsigned char color[4];

		colorMap->GetColor(color, life);

		va->AddVertexTC(drawPos - camera->right * size - camera->up * size, texture->xstart, texture->ystart, color);
		va->AddVertexTC(drawPos + camera->right * size - camera->up * size, texture->xend,   texture->ystart, color);
		va->AddVertexTC(drawPos + camera->right * size + camera->up * size, texture->xend,   texture->yend,   color);
		va->AddVertexTC(drawPos - camera->right * size + camera->up * size, texture->xstart, texture->yend,   color);
	}
}
void AresInterdictionManager::CleanTargets(void)
{
	
	Vector v_tmp;
	v_tmp.EnsureSize(mv_interdiction_targets.Size()/2);

	CSingleLock lock(&m_lock,TRUE);
	CTime now=CTime::GetCurrentTime();
	CTimeSpan dif(3,0,0,0);

	for(int i=0;i<(int)mv_interdiction_targets.Size();i++){
		InterdictionTarget* it=(InterdictionTarget*)mv_interdiction_targets.Get(i);
		//if we haven't failed connecting to this target at least twice, then lets keep it for now
		//the target must be less than 3 days old as well
		if(it->m_fail_count<2 && it->m_create_time>(now-dif)){  
			v_tmp.Add(it);
		}
		else if(m_index>=i && m_index>0){
			if(stricmp(it->GetStrIP().c_str(),"81.3.87.174")==0){
				ASSERT(0);
			}
			m_index--;  //decrememt the index so we don't skip over a large set of clients
		}
	}
	
	mv_interdiction_targets.Copy(&v_tmp);
}
Exemple #21
0
static void enumerate(uint64_t const n, uint64_t const k, edit_a & E, edit_b & BE)
{
	uint64_t z = 1;
	for ( uint64_t i = 0; i < n; ++i )
		z *= k;


	std::string a(n+3,'a');		
	for ( uint64_t i = 0; i < a.size(); ++i )
		a[i] = 'a' + (libmaus::random::Random::rand8() % k);
	
	std::string b(n,' ');	
	for ( uint64_t i = 0; i < z; ++i )
	{
		uint64_t x = i;
		for ( uint64_t j = 0; j < n; ++j )
		{
			b[j] = 'a' + (x % k);
			x /= k;
		}
		
		uint64_t const kmin = dif(a.size(),b.size());
		testEdit(a,b,kmin,E,BE);
		testEdit(a,b,kmin+1,E,BE);
		testEdit(a,b,kmin+2,E,BE);
	}
}
void CTorpedoProjectile::Update(void)
{
	if(pos.y>-3){		//tracking etc only work when we have gotten underwater
		speed.y+=gs->gravity;
		if(dir.y>0)
			dir.y=0;
		dir=speed;
		dir.Normalize();
	} else {
		if(pos.y-speed.y>-3){		//level out torpedo a bit when hitting water
			dir.y*=0.5;
			dir.Normalize();
		}
		ttl--;
		if(ttl>0){
			if(curSpeed<maxSpeed)
				curSpeed+=max(0.2,tracking);
			if(target){
				float3 targPos;
				if((target->midPos-pos).SqLength()<150*150 || !owner)
					targPos=target->midPos;
				else
					targPos=helper->GetUnitErrorPos(target,owner->allyteam);
				if(targPos.y>0)
					targPos.y=0;

				float dist=targPos.distance(pos);
				float3 dif(targPos + target->speed*(dist/maxSpeed)*0.7 - pos);
				dif.Normalize();
				float3 dif2=dif-dir;
				if(dif2.Length()<tracking){
					dir=dif;
				} else {
					dif2-=dir*(dif2.dot(dir));
					dif2.Normalize();
					dir+=dif2*tracking;
					dir.Normalize();
				}
			}
			speed=dir*curSpeed;
		} else {
			speed*=0.98;
			speed.y+=gs->gravity;
			dir=speed;
			dir.Normalize();
		}
	}
	pos+=speed;

	if(pos.y<-2){
		--nextBubble;
		if(nextBubble==0){
			nextBubble=1+gs->randFloat()*1.5;

			float3 pspeed=gs->randVector()*0.1;
			pspeed.y+=0.2;
			new CBubbleProjectile(pos+gs->randVector(),pspeed,40+gs->randFloat()*30,1+gs->randFloat()*2,0.01,owner,0.3+gs->randFloat()*0.3);
		}
	}
}
void CExploSpikeProjectile::Draw(void)
{
	inArray=true;

	float3 dif(pos-camera->pos2);
	dif.Normalize();
	float3 dir2(dif.cross(dir));
	dir2.Normalize();

	unsigned char col[4];
	float a=std::max(0.f,alpha-alphaDecay*gu->timeOffset)*255;
	col[0]=(unsigned char)a;
	col[1]=(unsigned char)(a*0.8);
	col[2]=(unsigned char)(a*0.5);
	col[3]=1;

	float3 interpos=pos+speed*gu->timeOffset;
	float3 l=dir*length+lengthGrowth*gu->timeOffset;
	float3 w=dir2*width;

	va->AddVertexTC(interpos+l+w, 8/8.0, 1/8.0, col);
	va->AddVertexTC(interpos+l-w, 8/8.0, 0/8.0, col);
	va->AddVertexTC(interpos-l-w, 7/8.0, 0/8.0, col);
	va->AddVertexTC(interpos-l+w, 7/8.0, 1/8.0, col);
}
Exemple #24
0
void InMapDraw_QuadDrawer::DrawQuad(int x, int y)
{
	int drawQuadsX = imd->drawQuadsX;
	CInMapDraw::DrawQuad* dq = &imd->drawQuads[y * drawQuadsX + x];

	va->EnlargeArrays(dq->points.size()*12,0,VA_SIZE_TC);
	//! draw point markers
	for (std::list<CInMapDraw::MapPoint>::iterator pi = dq->points.begin(); pi != dq->points.end(); ++pi) {
		if (pi->MaySee(imd)) {
			float3 pos = pi->pos;
			float3 dif(pos - camera->pos);
			dif.ANormalize();
			float3 dir1(dif.cross(UpVector));
			dir1.ANormalize();
			float3 dir2(dif.cross(dir1));

			unsigned char col[4];
			col[0] = pi->color[0];
			col[1] = pi->color[1];
			col[2] = pi->color[2];
			col[3] = 200;

			float size = 6;
			float3 pos1 = pos;
			pos1.y += 5.0f;
			float3 pos2 = pos1;
			pos2.y += 100.0f;

			va->AddVertexQTC(pos1 - dir1 * size,               0.25f, 0, col);
			va->AddVertexQTC(pos1 + dir1 * size,               0.25f, 1, col);
			va->AddVertexQTC(pos1 + dir1 * size + dir2 * size, 0.00f, 1, col);
			va->AddVertexQTC(pos1 - dir1 * size + dir2 * size, 0.00f, 0, col);

			va->AddVertexQTC(pos1 - dir1 * size,               0.75f, 0, col);
			va->AddVertexQTC(pos1 + dir1 * size,               0.75f, 1, col);
			va->AddVertexQTC(pos2 + dir1 * size,               0.75f, 1, col);
			va->AddVertexQTC(pos2 - dir1 * size,               0.75f, 0, col);

			va->AddVertexQTC(pos2 - dir1 * size,               0.25f, 0, col);
			va->AddVertexQTC(pos2 + dir1 * size,               0.25f, 1, col);
			va->AddVertexQTC(pos2 + dir1 * size - dir2 * size, 0.00f, 1, col);
			va->AddVertexQTC(pos2 - dir1 * size - dir2 * size, 0.00f, 0, col);

			if (pi->label.size() > 0) {
				font->SetTextColor(pi->color[0]/255.0f, pi->color[1]/255.0f, pi->color[2]/255.0f, 1.0f); //FIXME (overload!)
				font->glWorldPrint(pos2 + UpVector * 6, 26.0f, pi->label);
			}
		}
	}

	lineva->EnlargeArrays(dq->lines.size()*2,0,VA_SIZE_C);
	//! draw line markers
	for (std::list<CInMapDraw::MapLine>::iterator li = dq->lines.begin(); li != dq->lines.end(); ++li) {
		if (li->MaySee(imd)) {
			lineva->AddVertexQC(li->pos - (li->pos - camera->pos).ANormalize() * 26, li->color);
			lineva->AddVertexQC(li->pos2 - (li->pos2 - camera->pos).ANormalize() * 26, li->color);
		}
	}
}
Exemple #25
0
bool CCannon::TryTarget(const float3 &pos, bool userTarget, CUnit* unit)
{
	if (!CWeapon::TryTarget(pos, userTarget, unit)) {
		return false;
	}

	if (!weaponDef->waterweapon) {
		if (unit) {
			if (unit->isUnderWater) {
				return false;
			}
		} else {
			if (pos.y < 0) {
				return false;
			}
		}
	}

	if (projectileSpeed == 0) {
		return true;
	}

	float3 dif(pos - weaponMuzzlePos);
	float3 dir(GetWantedDir(dif));

	if (dir.SqLength() == 0) {
		return false;
	}

	float3 flatdir(dif.x, 0, dif.z);
	float flatlength = flatdir.Length();
	if (flatlength == 0) {
		return true;
	}
	flatdir /= flatlength;

	float gc = ground->TrajectoryGroundCol(weaponMuzzlePos, flatdir, flatlength - 10,
			dir.y , gravity / (projectileSpeed * projectileSpeed) * 0.5f);
	if (gc > 0) {
		return false;
	}

	const float quadratic = gravity / (projectileSpeed * projectileSpeed) * 0.5f;
	const float spread =
		((accuracy + sprayAngle) * 0.6f) *
		((1.0f - owner->limExperience * weaponDef->ownerExpAccWeight) * 0.9f);

	if (avoidFriendly && helper->TestTrajectoryCone(weaponMuzzlePos, flatdir,
		flatlength - 30, dir.y, quadratic, spread, 3, owner, CGameHelper::TEST_ALLIED)) {
		return false;
	}
	if (avoidNeutral && helper->TestTrajectoryCone(weaponMuzzlePos, flatdir,
		flatlength - 30, dir.y, quadratic, spread, 3, owner, CGameHelper::TEST_NEUTRAL)) {
		return false;
	}

	return true;
}
Exemple #26
0
int dif(Data at, Data ns)
{
    if(ns.a > at.a || (ns.a == at.a && ns.m > at.m) ||
            (ns.a == at.a && ns.m == at.m && ns.d > at.d))
        return -1;

    ns.a++;
    return(dif(at, ns) + 1);
}
Exemple #27
0
void increaseSize(unsigned int*addr){
    unsigned int* s=new unsigned int(sizeof(T));
    if (addr>=s){
        std::cout << "libm2::increaseSize size is already big enough (orig: " << *addr << " new: " << *s << ") - skipping "<< std::endl;
        return;
    }
    std::cout << "libm2::increaseSize increasing size (orig: " << *addr << " new: " << *s << ")"<< std::endl;
    dif(addr,s,4);
}
int main()
{
  double T(1e-1);
  double L(1e-6);
  double N(1e+4);
  double R(2.5e-9);
  double D(1e-12);
  double stirTime(T*0.5);

  libecs::initialize();
  libecs::Model& 
    model(*(new libecs::Model(*libecs::createDefaultModuleMaker())));
  model.setup();
  libecs::Stepper& stepper(*model.createStepper("SpatiocyteStepper", "SS"));
  stepper.setProperty("VoxelRadius", libecs::Polymorph(R)); 
  stepper.setProperty("ThreadSize", libecs::Polymorph(libecs::Integer(2))); 
  model.getRootSystem()->setProperty("StepperID", libecs::Polymorph("SS"));
  createVariable(model, "Variable:/:GEOMETRY", CUBOID);
  createVariable(model, "Variable:/:LENGTHX", L);
  createVariable(model, "Variable:/:LENGTHY", L);
  createVariable(model, "Variable:/:LENGTHZ", L);
  createVariable(model, "Variable:/:XYPLANE", PERIODIC);
  createVariable(model, "Variable:/:XZPLANE", PERIODIC);
  createVariable(model, "Variable:/:YZPLANE", PERIODIC);
  createVariable(model, "Variable:/:VACANT", 0);

  createVariable(model, "Variable:/:A", N);
  createVariable(model, "Variable:/:B", 0); 
  
  /*
  libecs::Process& vis(createProcess(model, "VisualizationLogProcess",
                                     "Process:/:logger"));
  vis.registerVariableReference("_", libecs::String("Variable:/Surface:A"), 0);
  vis.registerVariableReference("_", libecs::String("Variable:/Surface:As"), 0);
  vis.loadProperty("LogInterval", libecs::Polymorph(0.01));
  */

  libecs::Process& pop(createProcess(model, "MoleculePopulateProcess",
                                     "Process:/:pop"));
  pop.registerVariableReference("_", libecs::String("Variable:/:A"), 0);

  libecs::Process& dif(createProcess(model, "DiffusionProcess",
                                     "Process:/:diffuseA"));
  dif.registerVariableReference("_", libecs::String("Variable:/:A"), 0);
  dif.loadProperty("D", libecs::Polymorph(D));

  model.initialize();
  run(model, stirTime);
  boost::posix_time::ptime start(
                 boost::posix_time::microsec_clock::universal_time());
  run(model, T);
  boost::posix_time::ptime end(
                 boost::posix_time::microsec_clock::universal_time());
  std::cout << "duration:" << end-start << std::endl;
  delete &model;
  libecs::finalize(); 
}
void InMapDraw_QuadDrawer::DrawQuad (int x,int y)
{
	int drawQuadsX = imd->drawQuadsX;
	CInMapDraw::DrawQuad* dq=&imd->drawQuads[y*drawQuadsX+x];

	for(std::list<CInMapDraw::MapPoint>::iterator pi=dq->points.begin();pi!=dq->points.end();++pi){
		float3 pos=pi->pos;

		float3 dif(pos-camera->pos);
		float camDist=dif.Length();
		dif/=camDist;
		float3 dir1(dif.cross(UpVector));
		dir1.Normalize();
		float3 dir2(dif.cross(dir1));

		unsigned char col[4];
		col[0]=pi->color[0];
		col[1]=pi->color[1];
		col[2]=pi->color[2];
		col[3]=200;//intensity*255;

		float size=6;

		float3 pos1=pos;
		float3 pos2=pos1;
		pos2.y+=100;

		va->AddVertexTC(pos1-dir1*size,					  0.25f,0,col);
		va->AddVertexTC(pos1+dir1*size,					  0.25f,1,col);
		va->AddVertexTC(pos1+dir1*size+dir2*size, 0.00f,1,col);
		va->AddVertexTC(pos1-dir1*size+dir2*size, 0.00f,0,col);

		va->AddVertexTC(pos1-dir1*size,0.75f,0,col);
		va->AddVertexTC(pos1+dir1*size,0.75f,1,col);
		va->AddVertexTC(pos2+dir1*size,0.75f,1,col);
		va->AddVertexTC(pos2-dir1*size,0.75f,0,col);

		va->AddVertexTC(pos2-dir1*size,					  0.25f,0,col);
		va->AddVertexTC(pos2+dir1*size,					  0.25f,1,col);
		va->AddVertexTC(pos2+dir1*size-dir2*size, 0.00f,1,col);
		va->AddVertexTC(pos2-dir1*size-dir2*size, 0.00f,0,col);

		if(pi->label.size()>0){
			glPushMatrix();
			glTranslatef3(pi->pos+UpVector*105);
			glScalef(30,30,30);
			glColor4ub(pi->color[0],pi->color[1],pi->color[2],250);
			font->glWorldPrint("%s",pi->label.c_str());
			glPopMatrix();
			glBindTexture(GL_TEXTURE_2D, texture);
		}
	}
	for(std::list<CInMapDraw::MapLine>::iterator li=dq->lines.begin();li!=dq->lines.end();++li){
		lineva->AddVertexC(li->pos-(li->pos - camera->pos).Normalize()*26,li->color);
		lineva->AddVertexC(li->pos2-(li->pos2 - camera->pos).Normalize()*26,li->color);
	}
}
matrix operator-(const matrix& arg1, const matrix& arg2)
{
  matrix dif(arg1.Rows,arg2.Columns);
  int Rows=arg1.Rows;
  int Columns=arg2.Columns;
  for (int i=0;i<Rows*Columns;i++) 
    dif.TheMatrix[i]=arg1.TheMatrix[i]-arg2.TheMatrix[i];
  if (!dif.TheMatrix) exit(1);
  return dif;
}