Effekte

Einleitung

/* Invisibility spell without effect system */

local remaining_time; // time the spell is still in effect
local target;   // the clonk that has been made invisible
local old_visibility; // previous visibility
local old_modulation; // previous color modulation

func Activate(object caster, object caster2)
{
  // get caster
  if (caster2) caster = caster2; target = caster;

  // save previous visibility and color modulation of the caster
  old_visibility = caster.Visibility;
  old_modulation = caster->GetClrModulation();
  
  // make caster only visible to himself and allies, color him like a ghost
  caster.Visibility = VIS_Owner | VIS_Allies | VIS_God;
  caster->SetClrModulation(ModulateColor(old_modulation, RGBa(127,127,255,127)));
  
  // start timer: 30 seconds invisible
  remaining_time = 30;
}

func TimerCall()
{
  // count down
  if (remaining_time--) return;
  // done: remove object
  RemoveObject();
}

func Destruction()
{
  // spell is being removed: end invisibility
  target->SetClrModulation(old_modulation);
  target.Visibility = old_visibility;
}

Anwendung

/* Invisibility spell with effect system  */

// visibility - previous visibility
// old_mod - previous color modulation

func Activate(object caster, object caster2)
{
	// get caster
	if (caster2) caster = caster2;

	// start effect
	caster->CreateEffect(InvisPSpell, 200, 1111);
	// done - the spell object is not needed anymore
	RemoveObject();
	return true;
}

local InvisPSpell = new Effect {
	Start = func() {
		// Save the casters previous visibility
		this.visibility = Target.Visibility;
		this.old_mod = Target->GetClrModulation();
		// Make the caster invisible
		Target.Visibility = VIS_Owner | VIS_Allies | VIS_God;
		// Semitransparent and slightly blue for owner and allies
		Target->SetClrModulation(ModulateColor(this.old_mod, RGBa(127,127,255,127)));
	},
	Stop = func() {
		// restore previous values
		Target->SetClrModulation(this.old_mod);
		Target.Visibility = this.visibility;
	}
}

Timer = func()
{
	// return value of -1 means that the effect should be removed
	return -1;
}

Prioritäten

/* Spell of immunity against fire */

func Activate(object caster, object caster2)
{
	// get caster
	if (caster2) caster = caster2;

	// start effect
	caster->CreateEffect(BanBurnPSpell, 180, 1111);
  
	// done - the spell object is not needed anymore
	RemoveObject();
	return true;
}

local BanBurnPSpell = new Effect {
	Construction = func()
	{
		// On start of the effect: extinguish clonk
		Target->Extinguish();
	},
	Effect = func(string new_name)
	{
		// block fire
		if (WildcardMatch(new_name, "*Fire*")) return -1;
		// everything else is ok
		return 0;
	}
};

[...]
Effect = func(string new_name, var1, var2, var3, var4)
{
	// only handle fire
	if (!WildcardMatch(new_name, "*Fire*")) return 0;
	// with fire, the three extra parameters have the following meaning:
	// var1: caused_by           - player that is responsible for the fire
	// var2: blasted             - bool: if the fire has been created by an explosion
	// var3: burning_object      - object: incineratable object
	// extinguish burning object
	if (var3 && GetType(var3) == C4V_C4Object) var3->Extinguish();
	// block fire
	return -1;
}

Spezielle Add/Remove-Aufrufe

/* Resurrection spell */

func Activate(object caster, object caster2)
{
	// get caster
	if (caster2) caster = caster2;

	// start effect 
	caster->CreateEffect(ReincarnationPSpell, 180, 0);
	
	// done - the spell object is not needed anymore
	RemoveObject();
	return true;
}

local ReincarnationPSpell = new Effect {
	Construction = func() {
		// Only at the first start: message
		Target->Message("%s gets an extra life", Target->GetName());
		return true;
	},

	func Stop(int reason, bool temporary) {
		// only when the clonk died
		if (reason != 4) return true;
		
		// the clonk has already been resurrected
		if (Target->GetAlive()) return -1;
		// resurrect clonk
		Target->SetAlive(true);
		// give energy
		Target->DoEnergy(100);
		// message
		Target->Message("%s has been resurrected.", Target->GetName());

		// remove
		return true;
	}
};

Globale Effekte

/* Gravitation spell */

// grav - previous gravitation
// change - change by the spell

func Activate(object caster, object caster2)
{
  // start global effect
  AddEffect("GravChangeUSpell", nil, 150, 37, nil, GetID(), -10);
  // done - the spell object is not needed anymore
  RemoveObject();
  return true;
}

func FxGravChangeUSpellStart(object target, proplist effect, bool temporary, change)
{
  // search for other gravitation effects
  if (!temporary)
  {
    var otherEffect = GetEffect("GravChangeUSpell", target);
    if (otherEffect == num) iOtherEffect = GetEffect("GravChangeUSpell", target, 1);
    if (otherEffect)
    {
      // add gravitation change to other effect
      otherEffect.change += change;
      SetGravity(GetGravity() + change);
      // and remove self
      return -1;
    }
  }
  // save previous gravitation
  effect.grav = GetGravity();
  // for non-temporary calls change is passed and added to the changed value
  if (change) effect.change += change;
  // set gravitation change
  // the change can be not equal to change in temporary calls
  SetGravity(effect.grav + effect.change);

  return true;
}

func FxGravChangeUSpellTimer(object target, proplist effect)
{
  // slowly return to normal gravitation
  if (Inside(effect.change, -1, 1)) return -1;
  var iDir = -effect.change/Abs(effect.change);
  effect.change += iDir;
  SetGravity(GetGravity() + iDir);
  return true;
}

func FxGravChangeUSpellStop(object target, proplist effect)
{
  // restore gravitation
  SetGravity(effect.grav);

  return true;
}

Zusammenfassen von Effekten

[...]

func FxGravChangeUSpellEffect(string new_name)
{
  // If the newly added effect is also a gravitation change, ask to take over the effect
  if (new_name == "GravChangeUSpell") return -3;
}

func FxGravChangeUSpellAdd(object target, proplist effect, string new_name, int new_timer, change)
{
  // this is called when the effect has been taken over
  // add the gravitation change to this effect
  effect.change += change;
  SetGravity(GetGravity() + change);  

  return true;
}

Eigenschaften-Referenz

Benutzerdefinierte Eigenschaften

global func FxFireIsHot() { return true; }

// Function that removes all "hot" effects from the caller
global func RemoveAllHotEffects()
{
  var target = this;
  if(!this) return;
  
  var effect_num, i;
  while (effect = GetEffect("*", target, i++))
    if (EffectCall(target, effect, "IsHot"))
      RemoveEffect(nil, target, effect);
}

Blindeffekte

/* Earthquake spell */

func Activate(object caster, object caster2)
{
  // check effect
  var result;
  if (result = CheckEffect("EarthquakeNSpell", nil, 150))
  {
    RemoveObject();
    return result != -1;
  }
  // execute effect
  if (caster->GetDir() == DIR_Left)
    CastLeft();
  else
    CastRight();
	
  // remove spell object
  RemoveObject();
  return true;
}

Erweiterte Möglichkeiten

// The call CastleChange must be delayed so that the castle part is really gone when it is called
// otherwise, the FindObject()-calls would still find the castle part
func CastlePartDestruction()
{
  if (basement) basement->RemoveObject();
  // Global temporary effect, if not already there
  if (!GetEffect("IntCPW2CastleChange"))
  	AddEffect("IntCPW2CastleChange", nil, 1, 2, nil, CPW2);
  return true;
}

func FxIntCPW2CastleChangeStop()
{
  // notice all castle parts
  for(var obj in FindObjects(Find_OCF(OCF_Fullcon), Find_NoContainer())
    obj->~CastleChange();

  return true;
}

/* scenario script */

func Initialize()
{
  // manipulate all wipfs
  for(var obj in FindObjects(Find_ID(WIPF), Find_OCF(OCF_Alive)))
    AddEffect("ExplodeOnDeathCurse", obj, 20);
}

global func FxExplodeOnDeathCurseStop(object target, proplist effect, int reason)
{
  // died? boom!
  if (reason == 4) target->Explode(20);
  return true;
}

Benennung

Callback-Referenz

Start

Stop

Construction

Destruction

Timer

Effekt

Add

Damage

Funktions-Referenz