I have several examples:

I want the CTF goal flag to not slow down the player and I want to remove the particle trail. Removing the slowdown is very easy, because I just overwrite ReducePhysicals() and ResetPhysicals() with empty functions. For the particles I have to overwrite FxFlagCarriedTimer(). My proposed change would be:


// Checks whether the carrier has reached its base.
protected func FxFlagCarriedTimer(object target, effect)
{

  var controller = target->GetController();
  var ctrl_team = GetPlayerTeam(controller);

  var x = effect.x;
  var y = effect.y;
  var newx = target->GetX();
  var newy = target->GetY();
  // Draw partical line following the flag.
  if (Distance(x, y, newx, newy) > 5)
  {
    target->CreateParticle("SphereSpark", 0, 0, 0, 0, PV_Random(36 * 3, 36 * 3 + 10), effect.tracer_particles);
    effect.x=newx;
    effect.y=newy;
  }

  // Draw partical line following the flag.
  FxFlagCarriedParticleEffects(target, effect);

  // Search for nearby base to drop flag and score a point.

  var base = FindObject(Find_ID(Goal_FlagBase), Find_Func("FindTeam", ctrl_team), Find_Distance(20));
  if (base && base->IsBaseWithFlag())
  {
    var goal = FindObject(Find_ID(Goal_CaptureTheFlag));
    if (goal)
      goal->AddTeamScore(ctrl_team);
    Log("$MsgFlagCaptured$", GetTaggedTeamName(ctrl_team));
    BeamFlag(false);
    return -1;
  }
  return 1;

  if (DropFlagAtBase(target, effect))
  {
    return FX_Execute_Kill;
  }
  else
  {
    return FX_OK;
  }
}

protected func FxFlagCarriedParticleEffects(object target, effect)
{
  var x = effect.x;
  var y = effect.y;
  var newx = target->GetX();
  var newy = target->GetY();
  // Draw partical line following the flag.
  if (Distance(x, y, newx, newy) > 5)
  {
    target->CreateParticle("SphereSpark", 0, 0, 0, 0, PV_Random(36 * 3, 36 * 3 + 10), effect.tracer_particles);
    effect.x=newx;
    effect.y=newy;
  }
}

protected func DropFlagAtBase(object target, effect)
{
  var controller = target->GetController();
  var ctrl_team = GetPlayerTeam(controller);
  var base = FindBaseToDropAt(ctrl_team);
  if (base)
  {
    OnDropFlagAtBase(ctrl_team);
    return true;
  }
  return false;
}

protected func FindBaseToDropAt(int ctrl_team)
{
  return FindObject(Find_ID(Goal_FlagBase), Find_Func("FindTeam", ctrl_team), Find_Func("IsBaseWithFlag"), Find_Distance(20));
}

protected func OnDropFlagAtBase(int ctrl_team)
{
  var goal = FindObject(Find_ID(Goal_CaptureTheFlag));
  if (goal)
    goal->AddTeamScore(ctrl_team);
  Log("$MsgFlagCaptured$", GetTaggedTeamName(ctrl_team));
  BeamFlag(false);
}


Why did I add functions that find a base and functions that drop the flag? In case someone has a different base object or if he wants to implement different effects when the flag is dropped.

For another project I wanted the list of sellable contents to also contain stuff that is in the Clonk and any objects he is grabbing. So I had to overload a lot stuff in Library_Base:
* all calls UpdateSellList() to UpdateSellList(pClonk)
* UpdateSellList: GetSellableContents() => GetSellableContents(pClonk)
* DoSell: Remove some lines such as the object entering the base on selling, and adding some stuff for the new behaviour.
=> in this case I would not change the base functions

Also I wanted object interactions to be displayed by the GUI_Controller even if the Clonk is contained in a vehicle or structure. For my overload it would have been useful if the lines marked by comments in FxIntSearchInteractionObjectsTimer() were separate functions:
// add extra-interactions Priority 0
// add interactables (script interface)   
// add extra-interactions Priority 1
// add extra-interactions Priority 2

Since I am cleaning up the libraries, and the hammer is based on a library maybe I can have a look some time soonish. Maybe you can attach a copy of the bridge (or the latest version of Clonkomotive) here and I can have a look.

Three comments:

* What about the speed? And what would you use it for? Is there a reason for not doing this with arrays?
* Why not Vector(int x, int y, int z, int u, ...) instead of Vector_2D and Vector_3D?
* I did not see an outter product implemented.

I agree with Maikel that arrays seem more natural to me for this kind of math.

In either case, instead of polluting the global namespace, what about just naming the library "Vec" and then calling them as Vec->Add, etc.?

Update: As suggested, the same changes, with arrays instead of proplists, as an object, and with more functions.