C++ effect函数代码示例

void SubXP(int xp, bool quiet)
{
Weapon *weapon = &player->weapons[player->curWeapon];
bool leveled_down = false;

	weapon->xp -= xp;
	
	// leveling down...
	while(weapon->xp < 0)
	{
		if (weapon->level > 0)
		{
			weapon->level--;
			weapon->xp += weapon->max_xp[weapon->level];
			leveled_down = true;
		}
		else
		{
			weapon->xp = 0;
			break;
		}
	}
	
	if (player->curWeapon == WPN_SPUR)
		leveled_down = false;
	
	if (leveled_down && !quiet && !player->hide)
	{
		effect(player->CenterX(), player->CenterY(), EFFECT_LEVELDOWN);
	}
}

void Base_Effect_base_event2(PARTICLE* p) {
	if(p.alpha <= 1.000) {
		parted_temp_vec.x = 0.000;
		parted_temp_vec.y = 0.000;
		parted_temp_vec.z = 0.000;
		vec_add(parted_temp_vec,p.x);
		parted_temp2_vec.x = random(2.000)+(-1.000);
		parted_temp2_vec.y = random(2.000)+(-1.000);
		parted_temp2_vec.z = (1.000);
		if(!(total_frames % 25)) {
			p.skill_c += 3.000*time_step*6.25;
			if(p.skill_c >= 1){
				effect(New_child_child2,integer(p.skill_c),parted_temp_vec,parted_temp2_vec);
				p.skill_c -= integer(p.skill_c);
			}
		}
	}
	p.alpha = clamp(p.alpha-3.000* time_step,-1,100);
	if(p.size >= 11.000 || (p.skill_a & 2)) {
		p.skill_a |= 2;
		p.size -= 1.000* time_step;
	}
	if(p.size <= 3.000 || (p.skill_a & 4)) {
		p.skill_a |= 4;
		p.size += 1.000* time_step;
	}
	if(p.alpha < 0 || p.size < 0) p.lifespan = 0;
}

void emit_fountain1() {
	
	my._BEING_MANIPULATED = 0;
	
	my.emask |= ENABLE_CLICK;
	my.event = ObjectManipulationCore;
	
	var my_time;my_time = 0;
	var timetable_num;timetable_num = 0;
	var eff_frac; eff_frac = 0;
	wait(1);
	while(my) {
		my_time += time_step/16;
		if(my_time >= 0.000)my_time = 0;
		timetable_num = 1;
		parted_temp_vec.x = 0.000;
		parted_temp_vec.y = 0.000;
		parted_temp_vec.z = 0.000;
		vec_add(parted_temp_vec,my.x);
		eff_frac += 3.000*timetable_num*time_step*6.25;
		if(eff_frac >= 1){
			effect(Base_Effect3_base,integer(eff_frac),parted_temp_vec,nullvector);
			eff_frac -= integer(eff_frac);
		}
		wait(1);
	}
}

BOOL crLottiUpdateFly (ENTITY* e)
{
	VECTOR v, w;
	
	vec_set(&w, e->crAccel);
	vec_scale(&w, time_step);
	vec_add(e->crSpeed, &w);
	
	vec_set(&v, e->crSpeed);
	vec_scale(&v, time_step);
	vec_add(e->x, &v);
	
	VECTOR feet;
	
	feet.x = feet.y = 0;
	feet.z = 0.5 * e->min_z;
	
	vec_rotate(feet, e->pan);
	vec_add(feet, e->x);
	
	ent_animate(e, "drown", 5 * total_ticks + e->crInit, ANM_CYCLE);
	
	effect(credits_fire, 2, feet, e->crSpeed);
	
	// explode near screen border

	VECTOR v;
	vec_set(&v, e->x);
	
	vec_to_screen(&v, camera);
	
	return (v.x < e->crPercent * screen_size.x || v.x > (1 - e->crPercent) * screen_size.x ||
	        v.y < e->crPercent * screen_size.y || v.y > (1 - e->crPercent) * screen_size.y);
}

void eff_expl_flash() {
	int i;
	set(me, BRIGHT | TRANSLUCENT | LIGHT | ZNEAR | PASSABLE);
	my.alpha = 50;
	my.roll = random(360);
	while(my.alpha < 100) {
		my.alpha += time_step * (random(20)+20);
		my.roll += time_step * sign(ang(my.roll));
		vec_fill ( my.scale_x, my.alpha/13 );
		wait(1);		
	}
	for(i=0; i<4; i++) {
		ent_create("explFlash01.tga", my.x, eff_expl_flash_2);
		you = ent_create("explFlash02.tga", my.x, eff_expl_flash_2);		
		if (i == 0) set(you, LIGHT);
	}
	for(i=0; i<5; i++) {
		ent_create ("explSmoke01.tga", my.x, eff_expl_smoke2);
	}
	effect(p_eff_expl_particle, 200, my.x, NULL);
	vec_add(my.scale_x, vector(3,3,3));
	ent_create("explSmoke02.tga", my.x, eff_expl_smoke);
	while(my.alpha > 0) {
		my.alpha -= time_step * 25;
		my.roll += time_step * sign(ang(my.roll));
		wait(1);
	} 
	ent_remove(me);
}

int halo_impl::add(int x, int y, const std::string& image, const map_location& loc,
                   ORIENTATION orientation, bool infinite)
{
    const int id = halo_id++;
    animated<image::locator>::anim_description image_vector;
    std::vector<std::string> items = utils::square_parenthetical_split(image, ',');

    for(const std::string& item : items) {
        const std::vector<std::string>& sub_items = utils::split(item, ':');
        std::string str = item;
        int time = 100;

        if(sub_items.size() > 1) {
            str = sub_items.front();
            try {
                time = std::stoi(sub_items.back());
            } catch(std::invalid_argument) {
                ERR_DP << "Invalid time value found when constructing halo: " << sub_items.back() << "\n";
            }
        }
        image_vector.push_back(animated<image::locator>::frame_description(time,image::locator(str)));

    }
    haloes.insert(std::pair<int,effect>(id,effect(disp,x,y,image_vector,loc,orientation,infinite)));
    new_haloes.insert(id);
    if(haloes.find(id)->second.does_change() || !infinite) {
        changing_haloes.insert(id);
    }
    return id;
}

main(int ac,char *av[])
{
	ImageData *img,*outimg;
	int res;
	int x,y,mx,my;

	if(ac<3) {
		printf("パラメータが足りません");
		return;
	}

	// ファイルより画像データの読み込み
	res=readBMPfile(av[1],&img);
	if(res<0) {
		printf("画像が読めません");
		return;
	}

	// 結果格納用画像データ作成
	outimg=createImage(img->width,img->height,24);
	
	effect(img,outimg);

	writeBMPfile(av[2],outimg);
	disposeImage(img);
	disposeImage(outimg);

}

void player_particles()
{
	VECTOR particle_pos[3];
	vec_set (particle_pos.x, player.x);
	particle_pos.z += 70; // place the healing particles above the characters' heads		
	effect(particle_void, 1, particle_pos, nullvector);
}

int halo_impl::add(int x, int y, const std::string& image, const map_location& loc,
		ORIENTATION orientation, bool infinite)
{
	const int id = halo_id++;
	animated<image::locator>::anim_description image_vector;
	std::vector<std::string> items = utils::square_parenthetical_split(image, ',');
	std::vector<std::string>::const_iterator itor = items.begin();
	for(; itor != items.end(); ++itor) {
		const std::vector<std::string>& items = utils::split(*itor, ':');
		std::string str;
		int time;

		if(items.size() > 1) {
			str = items.front();
			time = atoi(items.back().c_str());
		} else {
			str = *itor;
			time = 100;
		}
		image_vector.push_back(animated<image::locator>::frame_description(time,image::locator(str)));

	}
	haloes.insert(std::pair<int,effect>(id,effect(disp,x,y,image_vector,loc,orientation,infinite)));
	new_haloes.insert(id);
	if(haloes.find(id)->second.does_change() || !infinite) {
		changing_haloes.insert(id);
	}
	return id;
}

void emit_fire1() {
	
	my._BEING_MANIPULATED = 0;
	
	my.emask |= ENABLE_CLICK;
	my.event = ObjectManipulationCore;
	
	var my_time;my_time = 0;
	var timetable_num;timetable_num = 0;
	var eff_frac; eff_frac = 0;
	wait(1);
	while(my) {
		my_time += time_step/16;
		if(my_time >= 0.000)my_time = 0;
		timetable_num = 1;
		parted_temp_vec.x = random(20.000)+-10.000;
		parted_temp_vec.y = random(20.000)+-10.000;
		parted_temp_vec.z = random(5.098)+-0.098;
		vec_add(parted_temp_vec,my.x);
		parted_temp2_vec.x = random(0.600)+(-0.300);
		parted_temp2_vec.y = random(0.600)+(-0.300);
		parted_temp2_vec.z = random(0.239)+(0.261);
		eff_frac += 2.000*timetable_num*time_step*6.25;
		if(eff_frac >= 1){
			effect(Base_Effect_base2,integer(eff_frac),parted_temp_vec,parted_temp2_vec);
			eff_frac -= integer(eff_frac);
		}
		wait(1);
	}
}

main(int ac,char *av[])
{
	ImageData *img,*outimg;
	int res;
	int x,y,mx,my;

	if(ac<4) {
		printf("パ??ータが足りません");
		return;
	}


	res=readBMPfile(av[1],&img);
	if(res<0) {
		printf("画?が読めません");
		return;
	}


	outimg=createImage(img->width,img->height,24);
	
	effect(img,outimg,atoi(av[3]));

	writeBMPfile(av[2],outimg);
	disposeImage(img);
	disposeImage(outimg);

}

void EffectView::editControls()
{
	if( m_subWindow )
	{
		if( !m_subWindow->isVisible() )
		{
			m_subWindow->show();
			m_subWindow->raise();
			effect()->controls()->setViewVisible( true );
		}
		else
		{
			m_subWindow->hide();
			effect()->controls()->setViewVisible( false );
		}
	}
}

//Fonction qui calcule les dommages d'une attaque du pokemon 1 sur le pokemon 2, et l'affiche
int hit (Attaque att, Pokemon pok1, Pokemon pok2)
{
  //Divise par 2 pour contrer le fois 2 de effect
  int N = effect(pok2, att) * (pok1.ATK + att.Force) / (2 * pok2.DEF);
  printf("%s a utilise %s.\n", pok1.Nom, att.Nom);
  //Affiche l'efficacité de l'attaque
  if (effect(pok2, att) == 4)
    {
      printf("C'est tres efficace !\n");
    }
  else if (effect(pok2, att) == 1)
    {
      printf("Ce n'est pas tres efficace.\n");
    }
  printf("%s a pris %d points de dégats.\n\n", pok2.Nom, N);
  return(N);
}

void ai_hey_spawner(Object *o)
{
	if (!o->state)
	{
		effect(o->x, o->y - (8<<CSF), EFFECT_HEY);
		o->state = 1;
	}
}

bool Animation::isCandidateForAnimationOnCompositor(double playerPlaybackRate) const
{
    if (!effect()
        || !m_target
        || (m_target->renderStyle() && m_target->renderStyle()->hasMotionPath()))
        return false;

    return CompositorAnimations::instance()->isCandidateForAnimationOnCompositor(specifiedTiming(), *effect(), playerPlaybackRate);
}