team.c-Dateireferenz

#include <living/team.h>
#include <properties.h>
#include <language.h>
#include <new_skills.h>
#include <ansi.h>
#include <wizlevels.h>
Include-Abhängigkeitsdiagramm für team.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define ME   this_object()
#define PO   previous_object()
#define TP   this_player()
#define TI   this_interactive()
#define AUTOINF_HP_MINUS   0x01
#define AUTOINF_HP_PLUS   0x02
#define AUTOINF_SP_MINUS   0x04
#define AUTOINF_SP_PLUS   0x08
#define AUTOINF_INSTANT   0x10

Funktionen

void _set_debug ()
static private void debug (string str)
void create ()
object * Members ()
object Leader ()
varargs string name (int casus, int demon)
varargs string Name (int casus, int demon)
varargs int remove (int silent)
static private void TryRemove ()
int CmpFirstArrayElement (mixed *a, mixed *b)
varargs static private void gtell (string str, string who, int tohist)
int IsMember (object ob)
int IsInteractiveMember (object ob)
varargs static private int * GetHpInfo (object ob, closure cl)
int CompareHp (object a, object b)
static private void UpdateActRow ()
static private void CheckFormation ()
static private void MakeFormation ()
static private void RemoveFromRow (object ob, int src)
static private void AddToRow (object ob, int dest)
static private void CycleRows (object ob, int src, int dest)
static private void RandomChangeRow ()
varargs static private string CountUpNames (object *obs, string zsing, string zplur)
static void DoChangeRow (object pl, int dest)
void UpdateFormation ()
int SwapRows (object ob1, object ob2)
static private int ChangeRow (string arg)
static private int ChangeWimpyRow (string arg)
mixed * PresentRows (object env)
mapping PresentPositions (mixed pres_rows)
varargs int FleeToRow (object ob)
static int ChangeFormation (string arg)
int Shout (string str)
int Hist (string str)
static private void DoChangeLeader (object ob)
static private int ChangeLeader (string arg)
varargs static private int CheckSecond (object pl, object *obs)
static int Allowed (object pl)
static private void DoAddMember (object ob)
int AddAssocMember (object caster, object npc)
static void AddMemberAndAssocs (object caster)
int AddMember (object ob)
static private string CAPITALIZE (string str)
static private void DoRemoveMember (object ob)
int RemoveAssocMember (object caster, object npc)
static void RemoveMemberAndAssocs (object caster)
static private void RemoveSingles ()
int RemoveMember (mixed arg)
static int ChangeName (string str)
void TeamInitAttack ()
int InitAttack_Callback (object enemy)
void TeamAttackExecuted_Callback (int success)
static private int StartAttack ()
void StartFollow (object env)
void ShowTeamInfo ()
varargs int ShowTeamHP (string arg)
varargs int ShowTeamRooms (string arg)
int ChangeColors (string arg)
int ChangeAutoInfo (string arg)
static private void DoNotifyHpChange ()
void NotifyHpChange ()
int TeamCmd (string cmd, string arg)
void reset ()

Variablen

static private mapping is_member
static private object leader
static private string tname
static private mapping wanted_row
static private mapping wimpy_row
static private mapping act_row
static private mapping autofollow
static private mapping attack_cmd
static private mapping assoc_mem
static private int * formin
static private int * formax
static private mixed * rows
static private int last_reorder
static private mapping h
static private object * att_exec
static private object * mis_attacked
static private mapping mis_init_att
static private mapping hp_info
static private int autoinf_flags
static private mapping autoinf_hp
static private mapping autoinf_sp
static private int autoinf_time
static private string * hist
static private object debugger

Makro-Dokumentation

#define AUTOINF_HP_MINUS   0x01

Definiert in Zeile 18 der Datei team.c.

Wird benutzt von ChangeAutoInfo() und NotifyHpChange().

#define AUTOINF_HP_PLUS   0x02

Definiert in Zeile 19 der Datei team.c.

Wird benutzt von ChangeAutoInfo() und NotifyHpChange().

#define AUTOINF_INSTANT   0x10

Definiert in Zeile 22 der Datei team.c.

Wird benutzt von ChangeAutoInfo() und NotifyHpChange().

#define AUTOINF_SP_MINUS   0x04

Definiert in Zeile 20 der Datei team.c.

Wird benutzt von ChangeAutoInfo() und NotifyHpChange().

#define AUTOINF_SP_PLUS   0x08

Definiert in Zeile 21 der Datei team.c.

Wird benutzt von ChangeAutoInfo() und NotifyHpChange().

#define ME   this_object()

Definiert in Zeile 13 der Datei team.c.

Wird benutzt von __auswerten(), _call_DoDecay(), _check_keep(), _check_unwear_restrictions(), _check_wear_restrictions(), _communicate(), _do_refresh(), _echo(), _equipment(), _examine(), _informunwear(), _informwear(), _inventory(), _normalfunction(), _query_attack_busy(), _query_internal_extralook(), _query_max_weight(), _query_questpoints(), _set_disable_attack(), _set_extern_attributes_modifier(), _set_extern_health_modifier(), _set_light(), _SetPursued(), _unwear(), _wear(), absteigen(), AddExtraLook(), AddPursuer(), Allowed(), ask_question(), AssocMember(), Attack(), buy(), CallFunc(), CannotSee(), catch_tell(), change_password3(), CheckDailyPlaytime(), CheckPlayerAttack(), CheckSensitiveAttack(), cmd_shoot(), command_me(), CommandScan(), create(), DeAssocMember(), DeepClean(), DeepTransferMoney(), Defend(), direct_move(), dirtesten(), do_call_efun(), do_cmd(), do_damage(), do_remove(), DoAddMember(), DoAttackChat(), DoChangeLeader(), DoChat(), DoList(), DoRemoveMember(), DoTeamAttack(), DoTeamFollow(), DoUnwear(), doUnwearMessage(), DoUnwield(), DoWear(), doWearMessage(), DoWield(), drink_alcohol(), drink_soft(), eat_food(), env_descr(), eval_anything(), evaluate(), ExecuteMissingAttacks(), ExitAttack(), FeelIt(), filter_users(), find_best_combat_command(), FindInStore(), FindPotion(), Flee(), gehen(), get_answer(), get_killer(), get_killer_object(), GetList(), give_money(), GiveQuest(), heart_beat(), InformRowChange(), init(), InitAttack(), InsertEnemyTeam(), InsertSensitiveObject(), InsertSingleEnemy(), int_long(), int_short(), InternalModifySkillAttribute(), IsEqual(), IsTeamLeader(), kampfende(), Kill(), kwho(), ListAwaited(), liste(), logaccess(), long(), MayAddObject(), MayAddWeight(), Message(), mixed_to_string(), mnpc_init(), mnpc_move(), modify_command(), ModifySkillAttribute(), ModifySkillAttributeOld(), move(), NetDead(), new_quit(), NotifyMove(), Pacify(), ParseRemote(), ParseRest(), present_objects(), PresentEnemies(), PresentPosition(), PresentTeamRows(), PreventInsert(), QueryDefend(), QueryPlAttacked(), QuerySkillAttribute(), quit(), raise(), really_buy(), Reconnect(), reduce_hit_points(), rein(), remove(), RemoveMember(), RemovePursuer(), RemoveSensitiveObjectFromList(), replacedisplay(), ReportPotion(), reset(), sag(), score(), secure(), security(), SelectNearEnemy(), SelectWhich(), self_delete2(), sell(), short(), show_hist(), Show_WaitFor_Reason(), ShowTeamHP(), ShowTeamInfo(), ShowTeamRooms(), shut(), stop_heart_beats(), StopHuntText(), team_aufnahme(), team_aufnahmewunsch(), team_list(), TeamCmd(), TeamFlee(), TeamMembers(), TryRemove(), unwield(), UpdateActRow(), wear_best_armours(), who(), wield_best_weapon(), Xclean(), Xdclean(), Xddes(), Xmtp(), Xprof(), Xtool() und Xwho().

#define PO   previous_object()

Definiert in Zeile 14 der Datei team.c.

#define TI   this_interactive()

Definiert in Zeile 16 der Datei team.c.

#define TP   this_player()

Definiert in Zeile 15 der Datei team.c.

Dokumentation der Funktionen

void _set_debug (  ) 

Definiert in Zeile 49 der Datei team.c.

Benutzt debugger, IS_LEARNER und TI.

00049                   {
00050   if (!debugger && IS_LEARNER(TI))
00051     debugger=TI;
00052   else if (debugger==TI)
00053     debugger=0;
00054 }

int AddAssocMember ( object  caster,
object  npc 
)

Definiert in Zeile 791 der Datei team.c.

Benutzt assoc_mem, DoAddMember(), IsMember() und PO.

Wird benutzt von AddMemberAndAssocs().

00791                                               {
00792   object *obs;
00793 
00794   if (extern_call() && PO!=caster)
00795     return 0;
00796   if (!IsMember(caster)
00797       || !objectp(npc)
00798       || query_once_interactive(npc)
00799       || IsMember(npc)
00800       || objectp(assoc_mem[caster])
00801       || assoc_mem[npc]
00802       || caster==npc)
00803     return 0;
00804   assoc_mem[npc]=caster;
00805   DoAddMember(npc);
00806   if (!pointerp(obs=assoc_mem[caster]))
00807     obs=({});
00808   obs=(obs-({npc,0}))+({npc});
00809   assoc_mem[caster]=obs;
00810   return 1;
00811 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int AddMember ( object  ob  ) 

Definiert in Zeile 825 der Datei team.c.

Benutzt AddMemberAndAssocs(), Allowed(), CheckSecond(), IsMember(), leader, notify_fail(), TP und WER.

00825                          {
00826   if (!Allowed(TP) || !Allowed(ob))
00827     return 0;
00828   if (TP!=ob && CheckSecond(ob,({TP}))) // Zweitiereglung bei Gruendung.
00829     return notify_fail(ob->Name(WER)+" ist Zweitspieler von Dir.\n"),0;
00830   if (!IsMember(leader))
00831     AddMemberAndAssocs(TP);
00832   if (TP!=leader)
00833     return notify_fail("Nur der Teamleiter kann Mitglieder aufnehmen.\n"),0;
00834   AddMemberAndAssocs(ob);
00835   return 1;
00836 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static void AddMemberAndAssocs ( object  caster  )  [static]

Definiert in Zeile 813 der Datei team.c.

Benutzt AddAssocMember(), DoAddMember() und P_TEAM_ASSOC_MEMBERS.

Wird benutzt von AddMember().

00813                                               {
00814   object *obs,ob;
00815   int i;
00816 
00817   DoAddMember(caster);
00818   if (!pointerp(obs=caster->QueryProp(P_TEAM_ASSOC_MEMBERS)))
00819     return;
00820   for (i=sizeof(obs)-1;i>=0;i--)
00821     if (objectp(ob=obs[i]) && !caster->IsEnemy(ob))
00822       AddAssocMember(caster,ob);
00823 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void AddToRow ( object  ob,
int  dest 
) [static]

Definiert in Zeile 316 der Datei team.c.

Benutzt formax, MAX_TEAMROWS und rows.

Wird benutzt von DoChangeRow().

00316                                                   {
00317   if (dest<0 || dest>=MAX_TEAMROWS)
00318     return;
00319   rows[dest]+=({ob});
00320   if (sizeof(rows[dest])<=formax[dest])
00321     return;
00322   // Falls vorne noch jemand hin kann, dorthin
00323   if (dest>0 && sizeof(rows[dest-1])+1<=formax[dest-1]) {
00324     rows[dest-1]+=rows[dest][0..];
00325     rows[dest]=rows[dest][1..];
00326     return;
00327   }
00328   // Falls hinten noch jemand hin kann, dorthin
00329   if (dest<MAX_TEAMROWS-1 && sizeof(rows[dest+1])+1<=formax[dest+1]) {
00330     // Dest: ({... <3, <2, ob});
00331     rows[dest+1]=rows[dest][<2..<2]+rows[dest+1];
00332     rows[dest]=rows[dest][0..<3]+({ob});
00333   }
00334 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int Allowed ( object  pl  )  [static]

Definiert in Zeile 744 der Datei team.c.

Benutzt CheckSecond(), MAX_TEAM_MEMBERS, ME, Members(), notify_fail(), P_GHOST, P_TEAM, TP, WER und x.

Wird benutzt von AddMember().

00744                               {
00745   mixed x;
00746   string nm;
00747 
00748   if (!objectp(pl))
00749     return notify_fail("WER soll ins Team aufgenommen werden?\n"),0;
00750   if (pl==TP)
00751     nm="Du b";
00752   else
00753     nm=pl->Name(WER)+" ";
00754   if (objectp(x=pl->QueryProp(P_TEAM)) && x!=ME)
00755     return notify_fail(nm+"ist schon in einem anderen Team.\n"),0;
00756   if (pl->QueryGuest())
00757     return notify_fail(nm+"ist ein Gast.\n"),0;
00758   if (pl->QueryProp(P_GHOST))
00759     return notify_fail(nm+"ist ein Geist.\n"),0;
00760   if (CheckSecond(pl))
00761     return notify_fail(nm+"ist Zweitspieler eines Teammitglieds.\n"),0;
00762   if (sizeof(filter(Members(),"IsInteractiveMember",ME))
00763       >=MAX_TEAM_MEMBERS)
00764     return notify_fail("Es sind schon zuviele Spieler im Team.\n"),0;
00765   return 1;
00766 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private string CAPITALIZE ( string  str  )  [static]

Definiert in Zeile 838 der Datei team.c.

Benutzt c.

Wird benutzt von DoRemoveMember().

00838                                              {
00839   int i,c;
00840 
00841   for (i=strlen(str)-1;i>=0;i--) {
00842     c=str[i];
00843     if (c>='a' && c<='z')
00844       str[i]=c+'A'-'a';
00845   }
00846   return str;
00847 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int ChangeAutoInfo ( string  arg  ) 

Definiert in Zeile 1242 der Datei team.c.

Benutzt autoinf_flags, AUTOINF_HP_MINUS, AUTOINF_HP_PLUS, AUTOINF_INSTANT, AUTOINF_SP_MINUS, AUTOINF_SP_PLUS, break_string(), leader, notify_fail(), old_explode() und TP.

Wird benutzt von TeamCmd().

01242                                {
01243   string *words,txt;
01244   int i,fl;
01245 
01246   if (TP!=leader)
01247     return notify_fail("Nur der Teamleiter kann automatisch "+
01248                        "informiert werden.\n"),0;
01249   words=old_explode(arg?arg:""," ");fl=0;
01250   for (i=sizeof(words)-1;i>=0;i--) {
01251     switch(words[i]) {
01252     case "aus":
01253       write("Du wirst nicht mehr automatisch informiert.\n");
01254       autoinf_flags=0;
01255       return 1;
01256     case "+kp":
01257       fl|=AUTOINF_SP_PLUS;
01258     case "kp":
01259       fl|=AUTOINF_SP_MINUS;
01260       break;
01261     case "+lp":
01262       fl|=AUTOINF_HP_PLUS;
01263     case "lp":
01264     case "ein":
01265     case "an":
01266       fl|=AUTOINF_HP_MINUS;
01267       break;
01268     case "sofort":
01269       fl|=AUTOINF_INSTANT;
01270       break;
01271     default:
01272       ;
01273     }
01274   }
01275   if (!fl)
01276     return notify_fail("WIE moechtest Du automatisch informiert werden?\n"),0;
01277   if (fl==AUTOINF_INSTANT) fl|=AUTOINF_HP_MINUS;
01278   autoinf_flags=fl;
01279   txt="Du wirst"+((fl&AUTOINF_INSTANT)?" sofort ":" ")+"informiert wenn";
01280   if (fl&(AUTOINF_HP_PLUS|AUTOINF_HP_MINUS)) {
01281     txt+=" die Lebenspunkte eines Teammitglieds";
01282     if (fl&(AUTOINF_HP_PLUS)) txt+=" sich aendern"; else txt+=" fallen";
01283     if (fl&(AUTOINF_SP_PLUS|AUTOINF_SP_MINUS)) txt+=" oder";
01284   }
01285   if (fl&(AUTOINF_SP_PLUS|AUTOINF_SP_MINUS)) {
01286     txt+=" die Konzentrationspunkte";
01287     if (fl&(AUTOINF_SP_PLUS)) txt+=" sich aendern"; else txt+=" fallen";
01288   }
01289   write(break_string(txt+".\n",78));
01290   return 1;
01291 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int ChangeColors ( string  arg  ) 

Definiert in Zeile 1222 der Datei team.c.

Benutzt F_MODE_AS, notify_fail(), P_TEAM_COLORS, SAVE und TP.

Wird benutzt von TeamCmd().

01222                              {
01223   int *col;
01224 
01225   notify_fail("team farben lp_rot lp_gelb [kp_rot kp_gelb]\n");
01226   if (!arg)
01227     return 0;
01228   col=({0,0,0,0});
01229   if (sscanf(arg,"%d %d %d %d",col[0],col[1],col[2],col[3])!=4) {
01230     if (sscanf(arg,"%d %d",col[0],col[1])!=2)
01231       return 0;
01232     col[2]=col[0];col[3]=col[1];
01233   }
01234   printf("Die Anzeige ist jetzt gelb unter %d LP, rot unter %d LP\n"+
01235          "                 bzw. gelb unter %d KP, rot unter %d KP.\n",
01236          col[1],col[0],col[3],col[2]);
01237   TP->SetProp(P_TEAM_COLORS,col);
01238   TP->Set(P_TEAM_COLORS,SAVE,F_MODE_AS);
01239   return 1;
01240 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int ChangeFormation ( string  arg  )  [static]

Definiert in Zeile 625 der Datei team.c.

Benutzt formax, formin, gtell(), MAX_TEAMROWS, min, old_explode() und UpdateFormation().

Wird benutzt von TeamCmd().

00625                                        {
00626   string *words;
00627   int i,min,max;
00628   mapping old_row;
00629 
00630   if (arg=="aus")
00631     arg="1-6 0-6 0-6 0-6 0-6";
00632   i=sizeof(words=old_explode(arg," "));
00633   if (i>MAX_TEAMROWS)
00634     i=MAX_TEAMROWS;
00635   for (--i;i>=0;i--) {
00636     if (sscanf(words[i],"%d-%d",min,max)==2) {
00637       formin[i]=min;
00638       formax[i]=max;
00639     } else if (sscanf(words[i],"%d",min)==1) {
00640       formin[i]=formax[i]=min;
00641     }
00642   }
00643 
00644   UpdateFormation();
00645 
00646   words=({});
00647   for (i=0;i<MAX_TEAMROWS;i++)
00648     words+=({sprintf("%d-%d",formin[i],formax[i])});
00649   gtell("Die Formation ist jetzt "+implode(words," / ")+".\n");
00650   return 1;
00651 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int ChangeLeader ( string  arg  )  [static]

Definiert in Zeile 683 der Datei team.c.

Benutzt DoChangeLeader(), find_player(), gtell(), IsMember(), leader, notify_fail(), TP und WER.

Wird benutzt von TeamCmd().

00683                                             {
00684   object ob;
00685 
00686   if (stringp(arg) && arg!="") {
00687     if (!objectp(ob=find_player(arg))
00688         && !objectp(ob=present(arg,environment(TP))))
00689       return notify_fail(capitalize(arg)+" nicht gefunden.\n"),0;
00690   } else {
00691     ob=TP;
00692   }
00693   if (objectp(leader)
00694       && TP!=leader
00695       && (!interactive(TP) || (interactive(leader) && query_idle(leader)<180)))
00696     return notify_fail("Der Teamleiter ist noch aktiv.\n"),0;
00697   if (objectp(leader)
00698       && query_once_interactive(leader)
00699       && !query_once_interactive(leader))
00700     return notify_fail("Nur ein Spieler kann das Team leiten.\n"),0;
00701   if (!IsMember(ob))
00702     return notify_fail(ob->Name(WER)+" ist kein Teammitglied.\n"),0;
00703   DoChangeLeader(ob);
00704   gtell(ob->Name(WER)+" leitet jetzt das Team.\n");
00705   return 1;
00706 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int ChangeName ( string  str  )  [static]

Definiert in Zeile 969 der Datei team.c.

Benutzt gtell(), leader, notify_fail(), TEAM_MASTER, tname, TP und WER.

Wird benutzt von TeamCmd().

00969                                   {
00970   if (leader && TP!=leader)
00971     return notify_fail("Nur der Teamleiter kann den Namen aendern.\n"),0;
00972   if (!str || str=="")
00973     return 0;
00974   str=str[0..19];
00975   if (!stringp(str=(TEAM_MASTER->RegisterTeam(str))))
00976     return notify_fail("Der Name ist schon vergeben.\n"),0;
00977   tname=str;
00978   if (objectp(TP))
00979     gtell(TP->Name(WER)+" aendert den Teamnamen auf \""+tname+"\".\n");
00980   return 1;
00981 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int ChangeRow ( string  arg  )  [static]

Definiert in Zeile 514 der Datei team.c.

Benutzt DoChangeRow(), MAX_TEAMROWS, notify_fail(), P_TEAM_WANTED_ROW, TP und wanted_row.

Wird benutzt von TeamCmd().

00514                                          {
00515   int num;
00516 
00517   if (!arg || sscanf(arg,"%d",num)!=1)
00518     return notify_fail("In welche Reihe willst Du denn wechseln?\n"),0;
00519   if (num<1 || num>MAX_TEAMROWS)
00520     return notify_fail("Die Reihenangabe ist ungueltig.\n"),0;
00521   TP->SetProp(P_TEAM_WANTED_ROW,wanted_row[TP]=num);
00522   printf("Du versuchst in Reihe %d zu wechseln.\n",num);
00523   DoChangeRow(TP,num);
00524   return 1;
00525 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int ChangeWimpyRow ( string  arg  )  [static]

Definiert in Zeile 527 der Datei team.c.

Benutzt MAX_TEAMROWS, notify_fail(), P_TEAM_WIMPY_ROW, TP und wimpy_row.

Wird benutzt von TeamCmd().

00527                                               {
00528   int num;
00529 
00530   if (!arg || sscanf(arg,"%d",num)!=1)
00531     return notify_fail("In welche Reihe willst Du fliehen?\n"),0;
00532   if (num<0 || num>MAX_TEAMROWS)
00533     return notify_fail("Die Reihenangabe ist ungueltig.\n"),0;
00534   TP->SetProp(P_TEAM_WIMPY_ROW,wimpy_row[TP]=num);
00535   if (num>1)
00536     printf("Bei der Flucht wirst Du in Reihe %d wechseln.\n",num);
00537   else
00538     write("Bei der Flucht wirst Du den Raum verlassen.\n");
00539   return 1;
00540 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void CheckFormation (  )  [static]

Definiert in Zeile 201 der Datei team.c.

Benutzt formax, formin, i, MAX_TEAM_ROWLEN, MAX_TEAMROWS und Members().

Wird benutzt von DoChangeRow() und MakeFormation().

00201                                      {
00202   int i,mincap,maxcap,d,num;
00203 
00204   mincap=maxcap=0;
00205   if (formin[0]<1)
00206     formin[0]=1;
00207   for (i=0;i<MAX_TEAMROWS;i++) {
00208     if (formin[i]<0) formin[i]=0;
00209     if (formax[i]<formin[i]) formax[i]=formin[i];
00210     if (formax[i]>MAX_TEAM_ROWLEN) formax[i]=MAX_TEAM_ROWLEN;
00211     if (formin[i]>formax[i]) formin[i]=formax[i];
00212     mincap+=formin[i];
00213     maxcap+=formax[i];
00214   }
00215   num=sizeof(Members());
00216   d=num-maxcap;
00217   for (i=0;i<MAX_TEAMROWS;i++) {
00218     if (d<=0)
00219       break;
00220     d-=(MAX_TEAM_ROWLEN-formax[i]);
00221     formax[i]=MAX_TEAM_ROWLEN;
00222     if (d<0)
00223       formax[i]+=d;
00224   }
00225   d=mincap-num;
00226   for (i=MAX_TEAMROWS-1;i>=0;i--) {
00227     if (d<=0)
00228       break;
00229     d-=formin[i];
00230     formin[i]=0;
00231     if (d<0)
00232       formin[i]-=d;
00233   }
00234 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs static private int CheckSecond ( object  pl,
object *  obs 
) [static]

Definiert in Zeile 708 der Datei team.c.

Benutzt ctime(), log_file, Members(), P_CALLED_FROM_IP, P_SECOND, TP und x.

Wird benutzt von AddMember() und Allowed().

00708                                                                {
00709   mixed x,ip;
00710   mapping second;
00711   object ob;
00712   int i;
00713 
00714   if (!objectp(pl))
00715     pl=TP;
00716   if (!query_once_interactive(pl))
00717     return 0;
00718   if (!pointerp(obs))
00719     obs=Members();
00720   obs-=({pl});
00721   second=([]);
00722   for (i=sizeof(obs)-1;i>=0;i--) {
00723     if (!objectp(ob=obs[i]) || !query_once_interactive(ob)) continue;
00724     second[getuid(ob)]=1;
00725     if (stringp(x=ob->QueryProp(P_SECOND)))
00726       second[lower_case(x)]=1;
00727   }
00728   if (second[getuid(pl)] ||
00729       (stringp(x=pl->QueryProp(P_SECOND)) && second[lower_case(x)]))
00730     return 1;
00731 
00732   if (!stringp(ip=pl->QueryProp(P_CALLED_FROM_IP)) || ip=="")
00733     return 0;
00734   for (i=sizeof(obs)-1;i>=0;i--) {
00735     if (!objectp(ob=obs[i]) || !query_once_interactive(ob)) continue;
00736     if (ob->QueryProp(P_CALLED_FROM_IP)!=ip) continue;
00737     log_file("rochus/zweitieverdacht",
00738              sprintf("%s %s,%s\n",ctime()[4..15],getuid(pl),getuid(ob)));
00739     break;
00740   }
00741   return 0;
00742 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int CmpFirstArrayElement ( mixed *  a,
mixed *  b 
)

Definiert in Zeile 122 der Datei team.c.

00122                                              {
00123   return(a[0]<b[0]);
00124 }

int CompareHp ( object  a,
object  b 
)

Definiert in Zeile 162 der Datei team.c.

Benutzt h.

00162                                   {
00163   return h[a]>h[b];
00164 }

varargs static private string CountUpNames ( object *  obs,
string  zsing,
string  zplur 
) [static]

Definiert in Zeile 380 der Datei team.c.

Benutzt i, ob() und WER.

Wird benutzt von DoChangeRow().

00380                                                       {
00381   string res;
00382   object ob;
00383   int i,sz;
00384 
00385   res="";
00386   if (!pointerp(obs)) return res;
00387   if (!stringp(zsing)) zsing="";
00388   if (!stringp(zplur)) zplur="";
00389   if (sz=sizeof(obs)) {
00390     for (i=0;i<sz;i++) {
00391       if (i)
00392                       res+=((i<sz-1)?", ":" und ");
00393       if (objectp(ob=obs[i]))
00394         res+=ob->name(WER);
00395     }
00396     if (sz>1)
00397       res+=zplur;
00398     else
00399       res+=zsing;
00400   }
00401   return res;
00402 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void create (  ) 

Definiert in Zeile 61 der Datei team.c.

Benutzt act_row, assoc_mem, att_exec, attack_cmd, autofollow, autoinf_flags, autoinf_hp, autoinf_sp, EMPTY_TEAMARRAY, formax, formin, h, hist, hp_info, is_member, leader, ME, mis_attacked, mis_init_att, rows, TEAM_MASTER, tname, wanted_row und wimpy_row.

00061               {
00062   autoinf_flags=0;
00063   autoinf_sp=([]);
00064   autoinf_hp=([]);
00065   is_member=([]);
00066   leader=0;
00067   wanted_row=([]);
00068   act_row=([]);
00069   wimpy_row=([]);
00070   autofollow=([]);
00071   attack_cmd=([]);
00072   assoc_mem=([]);
00073   formin=({1,0,0,0,0});
00074   formax=({5,4,3,2,1});
00075   rows=EMPTY_TEAMARRAY;
00076   h=([]);
00077   att_exec=({});
00078   mis_init_att=([]);
00079   mis_attacked=({});
00080   hp_info=([]);
00081   hist=({});
00082   if (object_name(ME)=="/p/daemon/team")
00083     return;
00084   if (!stringp(tname=TEAM_MASTER->RegisterTeam()))
00085     tname="?";
00086 }

static private void CycleRows ( object  ob,
int  src,
int  dest 
) [static]

Definiert in Zeile 336 der Datei team.c.

Benutzt formax, formin, i, MAX_TEAMROWS und rows.

Wird benutzt von DoChangeRow().

00336                                                             {
00337   int i;
00338 
00339   if (src<0 || src>=MAX_TEAMROWS || dest<0 || dest>=MAX_TEAMROWS)
00340     return;
00341   rows[src]-=({ob});
00342   if (sizeof(rows[src])<formin[src] || sizeof(rows[dest])>=formax[dest]) {
00343     if (src<dest) {             // (<- -X) <- <- <- <- (+X <-)
00344       for (i=src+1;i<=dest;i++) {
00345         rows[i-1]+=rows[i][0..0];
00346         rows[i]=rows[i][1..];
00347       }
00348     } else if (src>dest) {           // (-> +X) -> -> -> -> (-X ->)
00349       for (i=src-1;i>=dest;i--) {
00350         rows[i+1]=rows[i][<1..]+rows[i+1];
00351         rows[i]=rows[i][0..<2];
00352       }
00353     }
00354   }
00355   if (src<=dest)
00356     rows[dest]+=({ob});
00357   else
00358     rows[dest]=({ob})+rows[dest];
00359 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void debug ( string  str  )  [static]

Definiert in Zeile 56 der Datei team.c.

Benutzt debugger.

00056                                       {
00057   if (objectp(debugger) && stringp(str))
00058     tell_object(debugger,"#TEAM: "+str);
00059 }

static private void DoAddMember ( object  ob  )  [static]

Definiert in Zeile 768 der Datei team.c.

Benutzt assoc_mem, attack_cmd, autofollow, cl, DoChangeLeader(), DoChangeRow(), GetHpInfo(), gtell(), is_member, IsMember(), leader, ME, P_TEAM, P_TEAM_ATTACK_CMD, P_TEAM_AUTOFOLLOW, P_TEAM_NEWMEMBER, P_TEAM_WANTED_ROW, P_TEAM_WIMPY_ROW, wanted_row, WER und wimpy_row.

Wird benutzt von AddAssocMember() und AddMemberAndAssocs().

00768                                            {
00769   closure cl;
00770 
00771   if (!IsMember(leader))
00772     DoChangeLeader(ob);
00773   ob->SetProp(P_TEAM,ME);
00774   if (IsMember(ob))
00775     return;
00776   is_member[ob]=1;
00777   cl=symbol_function("QueryProp",ob);
00778   attack_cmd[ob]=funcall(cl,P_TEAM_ATTACK_CMD);
00779   autofollow[ob]=funcall(cl,P_TEAM_AUTOFOLLOW);
00780   wimpy_row[ob]=funcall(cl,P_TEAM_WIMPY_ROW);
00781   wanted_row[ob]=funcall(cl,P_TEAM_WANTED_ROW);
00782   if (!wanted_row[ob]) wanted_row[ob]=1;;
00783   ob->SetProp(P_TEAM_NEWMEMBER,0);
00784   GetHpInfo(ob,cl);
00785   if (query_once_interactive(ob)) ob->AddHpHook(ME);
00786   if (!objectp(assoc_mem[ob]))
00787     gtell(ob->Name(WER)+" wurde ins Team aufgenommen.\n");
00788   DoChangeRow(ob,wanted_row[ob]);
00789 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void DoChangeLeader ( object  ob  )  [static]

Definiert in Zeile 676 der Datei team.c.

Benutzt leader, ME und P_TEAM_LEADER.

Wird benutzt von ChangeLeader(), DoAddMember() und DoRemoveMember().

00676                                               {
00677   if (objectp(leader) && leader->QueryProp(P_TEAM_LEADER)==ME)
00678     leader->SetProp(P_TEAM_LEADER,0);
00679   leader=ob;
00680   leader->SetProp(P_TEAM_LEADER,ME);
00681 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static void DoChangeRow ( object  pl,
int  dest 
) [static]

Definiert in Zeile 404 der Datei team.c.

Benutzt act_row, AddToRow(), assoc_mem, break_string(), changed, CheckFormation(), CountUpNames(), CycleRows(), env(), gtell(), h, i, m_delete(), MakeFormation(), MAX_TEAMROWS, Members(), msg(), ob(), obs, RandomChangeRow(), RemoveFromRow(), UpdateActRow(), wanted_row und WER.

Wird benutzt von ChangeRow(), DoAddMember(), DoRemoveMember(), FleeToRow() und UpdateFormation().

00404                                              {
00405   mapping old_row,ec1,ec2,ecb;
00406   int i;
00407   object *obs,*envs,env;
00408   string *msg,str;
00409 
00410   dest--;
00411   CheckFormation();
00412   h=0;UpdateActRow(); // h=0 damit HP-Liste geupdated wird.
00413   old_row=deep_copy(act_row);
00414 
00415   obs=({});
00416   if (objectp(pl)) {
00417     obs=({pl});
00418     if (pointerp(assoc_mem[pl]))
00419       obs+=assoc_mem[pl];
00420   } else {
00421     RandomChangeRow();
00422   }
00423 
00424   foreach (object ob:obs) {
00425     if (!objectp(ob))
00426       continue;
00427     wanted_row[ob]=wanted_row[pl];
00428     UpdateActRow();
00429     int src=act_row[ob]-1;
00430 
00431     if (dest<0 || dest>=MAX_TEAMROWS)
00432       RemoveFromRow(ob,src);
00433     else if (src<0 || src>=MAX_TEAMROWS)
00434       AddToRow(ob,dest);
00435     else if (src!=dest)
00436       CycleRows(ob,src,dest);
00437   }
00438 
00439   MakeFormation();
00440 
00441   obs = Members(); // alle Members beruecksichtigen beim Abgleich!
00442   object *changed = allocate(0);
00443   foreach (object ob:obs)
00444     if (objectp(ob) && old_row[ob]!=act_row[ob]) {
00445       ob->InformRowChange(old_row[ob],act_row[ob]);
00446       changed += ({ob});
00447     }
00448 
00449   // Ab jetzt nur noch Ausgabe.
00450   if (get_eval_cost()<800000) return; // War schon teuer genug, Lagvermeidung
00451   msg=({});ec1=([]);ec2=([]);ecb=([]);
00452   foreach (object ob:changed) {
00453     tell_object(ob,sprintf("Du bist jetzt in Reihe %d.\n",act_row[ob]));
00454     msg+=({sprintf("%s->%d",ob->Name(WER),act_row[ob])});
00455     if (query_once_interactive(ob) && !interactive(ob)) continue;
00456     if (!objectp(env=environment(ob))) continue;
00457     if (old_row[ob]<=1) {
00458       if (!pointerp(envs=ec1[env])) envs=({});
00459       ec1[env]=envs+({ob});ecb[env]|=1;
00460     }
00461     if (act_row[ob]<=1) {
00462       if (!pointerp(envs=ec2[env])) envs=({});
00463       ec2[env]=envs+({ob});ecb[env]|=2;
00464     }
00465   }
00466   if (sizeof(msg))
00467     gtell(implode(msg,", ")); // Ausgabe an alle Gruppenmitglieder.
00468   efun::m_delete(ecb,find_object("/room/netztot")); // Das gaebe Mega-Lag :-)
00469   envs=m_indices(ecb);obs=Members();
00470   for (i=sizeof(envs)-1;i>=0;i--) {
00471     if (!objectp(env=envs[i])) continue;
00472     str="";
00473     str+=CountUpNames(ec1[env]," tritt zurueck"," treten zurueck");
00474     if (ecb[env]==3) str+=", ";
00475     str+=CountUpNames(ec2[env]," tritt vor"," treten vor");
00476     str+=".\n";
00477     tell_room(env,capitalize(break_string(str,78)),obs);
00478   }
00479 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void DoNotifyHpChange (  )  [static]

Definiert in Zeile 1293 der Datei team.c.

Benutzt autoinf_hp, autoinf_sp, autoinf_time, break_string(), IsMember(), leader, m_delete() und WER.

Wird benutzt von NotifyHpChange().

01293                                        {
01294   object *obs,ob;
01295   string str;
01296   int i;
01297 
01298   autoinf_time=time();
01299   str="";
01300   obs=m_indices(autoinf_hp);
01301   for (i=sizeof(obs)-1;i>=0;i--) {
01302     if (!objectp(ob=obs[i])) continue;
01303     if (str!="") str+=", ";
01304     str+=sprintf("%s: %d LP",ob->name(WER),autoinf_hp[ob]);
01305     if (member(autoinf_sp,ob))
01306       str+=sprintf(" / %d KP",autoinf_sp[ob]);
01307     efun::m_delete(autoinf_sp,ob);
01308   }
01309   obs=m_indices(autoinf_sp);
01310   for (i=sizeof(obs)-1;i>=0;i--) {
01311     if (!objectp(ob=obs[i])) continue;
01312     if (str!="") str+=", ";
01313     str+=sprintf("%s: %d KP",ob->name(WER),autoinf_sp[ob]);
01314   }
01315 
01316   if (str!="" && IsMember(leader))
01317     tell_object(leader,break_string(capitalize(str)+"\n",78));
01318   autoinf_hp=([]);
01319   autoinf_sp=([]);
01320 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void DoRemoveMember ( object  ob  )  [static]

Definiert in Zeile 849 der Datei team.c.

Benutzt act_row, assoc_mem, attack_cmd, autofollow, autoinf_hp, autoinf_sp, CAPITALIZE(), caster, DoChangeLeader(), DoChangeRow(), gtell(), hp_info, is_member, IsMember(), leader, m_delete(), ME, Members(), P_GHOST, P_TEAM, TryRemove(), wanted_row, WER und wimpy_row.

Wird benutzt von RemoveAssocMember() und RemoveMemberAndAssocs().

00849                                               {
00850   object *tmembers,caster;
00851   mixed asmem;
00852   int i;
00853 
00854   ob->SetProp(P_TEAM,0);
00855   efun::m_delete(is_member,ob);
00856   efun::m_delete(wanted_row,ob);
00857   efun::m_delete(act_row,ob);
00858   efun::m_delete(wimpy_row,ob);
00859   efun::m_delete(autofollow,ob);
00860   efun::m_delete(attack_cmd,ob);
00861   if (objectp(caster=assoc_mem[ob]) && pointerp(asmem=assoc_mem[caster]))
00862     assoc_mem[caster]=asmem-({ob,0});
00863   if (query_once_interactive(ob)) ob->RemoveHpHook(ME);
00864   efun::m_delete(hp_info,ob);
00865   efun::m_delete(autoinf_hp,ob);
00866   efun::m_delete(autoinf_sp,ob);
00867   DoChangeRow(ob,-1);
00868 
00869   if (!objectp(assoc_mem[ob])) {
00870     if (ob->QueryProp(P_GHOST)) {
00871       gtell(CAPITALIZE(ob->name(WER))+" HAT DAS TEAM VERLASSEN.","Tod");
00872     } else {
00873       tell_object(ob,"Du verlaesst das Team.\n");
00874       gtell(ob->Name(WER)+" hat das Team verlassen.\n");
00875     }
00876   }
00877   efun::m_delete(assoc_mem,ob);
00878 
00879   if (IsMember(leader)) // Hat das Team noch einen Leiter?
00880     return;
00881   tmembers=Members();ob=0;
00882   if (i=sizeof(tmembers)) {
00883     ob=tmembers[0];
00884     for (--i;i>=0;i--) {
00885       if (interactive(tmembers[i])) {
00886         ob=tmembers[i];
00887         break;
00888       }
00889       if (query_once_interactive(tmembers[i]))
00890         ob==tmembers[i];
00891     }
00892     DoChangeLeader(ob);
00893     gtell(leader->Name(WER)+" hat die Teamleitung uebernommen.\n");
00894     return;
00895   }
00896   TryRemove();
00897 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int FleeToRow ( object  ob  ) 

Definiert in Zeile 604 der Datei team.c.

Benutzt DoChangeRow(), h, IsMember(), MAX_TEAMROWS, P_TEAM_WANTED_ROW, PresentPositions(), TP, wanted_row und wimpy_row.

00604                                  {
00605   int num;
00606 
00607   if (!objectp(ob))
00608     ob=TP;
00609   if (!IsMember(ob))
00610     return 0;
00611   h=0; // Reihen bei naechster Abfrage neu sortieren
00612   num=wimpy_row[ob];
00613   if (num<2 || num>MAX_TEAMROWS) // Flucht in 1. Reihe nicht sinnvoll.
00614     return 0;
00615   if (num==wanted_row[ob]) // Ist schonmal nach hinten geflohen.
00616     return 0;
00617   tell_object(ob,sprintf("Du versuchst in Reihe %d zu fliehen.\n",num));
00618   ob->SetProp(P_TEAM_WANTED_ROW,wanted_row[ob]=num);
00619   DoChangeRow(ob,num);
00620   if (PresentPositions(environment(ob))[ob]<=1) // Flucht gescheitert?
00621     return 0;
00622   return 1;
00623 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs static private int* GetHpInfo ( object  ob,
closure  cl 
) [static]

Definiert in Zeile 151 der Datei team.c.

Benutzt hp_info, P_HP, P_MAX_HP, P_MAX_SP und P_SP.

Wird benutzt von DoAddMember(), NotifyHpChange() und ShowTeamHP().

00151                                                              {
00152   int *res;
00153 
00154   if (!closurep(cl)) cl=symbol_function("QueryProp",ob);
00155   if (!pointerp(res=hp_info[ob]) || sizeof(res)<4)
00156     res=({0,funcall(cl,P_MAX_HP),0,funcall(cl,P_MAX_SP)});
00157   res[0]=funcall(cl,P_HP);
00158   res[2]=funcall(cl,P_SP);
00159   return hp_info[ob]=res;
00160 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs static private void gtell ( string  str,
string  who,
int  tohist 
) [static]

Definiert in Zeile 126 der Datei team.c.

Benutzt break_string(), ctime(), find_player(), hist, i, Members(), msg() und name.

Wird benutzt von ChangeFormation(), ChangeLeader(), ChangeName(), DoAddMember(), DoChangeRow(), DoRemoveMember(), RemoveSingles(), Shout(), StartAttack() und SwapRows().

00126                                                                       {
00127   int i;
00128   object *tmembers,rochus;
00129   string prefix,msg;
00130 
00131   tmembers=Members();
00132   prefix=sprintf("[%s:%s] ",name(),stringp(who)?who:"");
00133   msg=break_string(str,78,prefix);
00134   for (i=sizeof(tmembers)-1;i>=0;i--)
00135     tell_object(tmembers[i],msg);
00136   if (objectp(rochus=find_player("rochus"))
00137       && rochus->QueryProp("debug_team"))
00138     tell_object(rochus,msg);
00139   if (tohist)
00140     hist=(hist+({break_string(str+" <"+ctime()[11..15]+">",78,prefix)}))[-100..];
00141 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int Hist ( string  str  ) 

Definiert in Zeile 660 der Datei team.c.

Benutzt hist, IsInteractiveMember() und TP.

Wird benutzt von TeamCmd().

00660                      {
00661   int i,anz,maximal;
00662 
00663   // non-interactive oder Nicht-Mitglieder sollten die Hist nicht abfragen.
00664   if (!IsInteractiveMember(TP)) return -1;
00665 
00666   maximal=sizeof(hist);
00667   if (str && sscanf(str,"%d",anz)==1)
00668     i=maximal-anz;
00669   if (i<0)
00670     i=0;
00671 
00672   TP->More(sprintf("%@s",hist[i..maximal])||"");
00673   return 1;
00674 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int InitAttack_Callback ( object  enemy  ) 

Definiert in Zeile 1017 der Datei team.c.

Benutzt att_exec, IsMember(), mis_attacked, mis_init_att und PO.

01017                                       {
01018   object *arr;
01019 
01020   if (!IsMember(PO) || member(att_exec,PO)<0)
01021     return 0;
01022   if (!pointerp(arr=mis_init_att[enemy]))
01023     arr=({});
01024   mis_init_att[enemy]=arr+({PO});
01025   if (member(mis_attacked,PO)<0)
01026     mis_attacked+=({PO});
01027   return 1;
01028 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int IsInteractiveMember ( object  ob  ) 

Definiert in Zeile 147 der Datei team.c.

Benutzt is_member.

Wird benutzt von Hist().

00147                                    {
00148   return (objectp(ob) && is_member[ob] && query_once_interactive(ob));
00149 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int IsMember ( object  ob  ) 

Definiert in Zeile 143 der Datei team.c.

Benutzt is_member.

Wird benutzt von AddAssocMember(), AddMember(), ChangeLeader(), DoAddMember(), DoNotifyHpChange(), DoRemoveMember(), FleeToRow(), InitAttack_Callback(), NotifyHpChange(), RemoveAssocMember(), RemoveMember(), RemoveSingles(), TeamAttackExecuted_Callback(), TeamCmd() und TeamInitAttack().

00143                         {
00144   return (objectp(ob) && is_member[ob]);
00145 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

object Leader (  ) 

Definiert in Zeile 92 der Datei team.c.

Benutzt leader.

00092                 {
00093   return leader;
00094 }

static private void MakeFormation (  )  [static]

Definiert in Zeile 236 der Datei team.c.

Benutzt CheckFormation(), formax, formin, i, last_reorder, MAX_TEAMROWS, rows und UpdateActRow().

Wird benutzt von DoChangeRow().

00236                                     {
00237   // Verlegungsstrategie:
00238   //    Richtung Test Verschieben
00239   // 1. -----> a) MAX          <- X
00240   //           b) MAX             X ->
00241   //           c) MIN             X <- <- <- <-
00242   // 2. <----- a) MIN -> -> -> -> X
00243   //           b) MAX          <- X
00244   int i,j,d;
00245 
00246   last_reorder=time();
00247   UpdateActRow();
00248   CheckFormation();
00249   for (i=0;i<MAX_TEAMROWS;i++) {
00250     d=sizeof(rows[i]);
00251     if (d<formin[i] || d>formax[i])
00252       break;
00253   }
00254   if (i>=MAX_TEAMROWS)
00255     return; // Formation ist noch in Ordnung
00256 
00257   for (i=0;i<MAX_TEAMROWS;i++) {
00258     if (sizeof(rows[i])>formax[i]) {     // Reihe ist zu voll
00259       if (i>0) {
00260         d=formax[i-1]-sizeof(rows[i-1]);
00261         if (d>0) {                       // Reihe vorher hat d freie Plaetze
00262           rows[i-1]+=rows[i][0..(d-1)];  // Also d Mitglieder abgeben
00263           rows[i]=rows[i][d..];
00264         }
00265       }
00266       if (i<MAX_TEAMROWS-1 && sizeof(rows[i])>formax[i]) {// Immer noch zu voll
00267         rows[i+1]=rows[i][formax[i]..]+rows[i+1];         // Rest nach hinten.
00268         rows[i]=rows[i][0..(formax[i]-1)];
00269       }
00270       continue; // War zu voll, kann nicht zu leer sein
00271     }
00272     for (j=i+1;j<MAX_TEAMROWS;j++) {
00273       d=formin[i]-sizeof(rows[i]);
00274       if (d<=0)                   // Ausreichende Anzahl
00275         break;                    // kein weiteres j noetig
00276       rows[i]+=rows[j][0..(d-1)]; // Sonst Nachschub von hinten holen
00277       rows[j]=rows[j][d..];
00278     }
00279   }
00280   for (i=MAX_TEAMROWS-1;i>0;i--) {
00281     for (j=i-1;j>=0;j--) {
00282       d=formin[i]-sizeof(rows[i]);
00283       if (d<=0)                   // Ausreichende Anzahl
00284         break;                    // kein weiteres j noetig
00285       rows[i]+=rows[j][0..(d-1)]; // Sonst Nachschub von vorne holen
00286       rows[j]=rows[j][d..];
00287     }
00288     d=sizeof(rows[i])-formax[i];
00289     if (d>0) {
00290       rows[i-1]+=rows[i][0..(d-1)]; // Ueberschuss nach vorne schieben
00291       rows[i]=rows[i][d..];
00292     }
00293   }
00294   UpdateActRow();
00295 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

object* Members (  ) 

Definiert in Zeile 88 der Datei team.c.

Benutzt is_member.

Wird benutzt von Allowed(), CheckFormation(), CheckSecond(), DoChangeRow(), DoRemoveMember(), gtell(), remove(), RemoveMember(), RemoveSingles(), ShowTeamInfo(), ShowTeamRooms(), StartAttack(), StartFollow(), TryRemove() und UpdateActRow().

00088                   {
00089   return (m_indices(is_member)-({0}));
00090 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs string Name ( int  casus,
int  demon 
)

Definiert in Zeile 102 der Datei team.c.

Benutzt name.

00102                                           {
00103   return name(casus,demon);
00104 }

varargs string name ( int  casus,
int  demon 
)

Definiert in Zeile 96 der Datei team.c.

Benutzt tname.

00096                                           {
00097   if (!stringp(tname))
00098     return "Team ?";
00099   return "Team "+capitalize(tname);
00100 }

void NotifyHpChange (  ) 

Definiert in Zeile 1322 der Datei team.c.

Benutzt autoinf_flags, autoinf_hp, AUTOINF_HP_MINUS, AUTOINF_HP_PLUS, AUTOINF_INSTANT, autoinf_sp, AUTOINF_SP_MINUS, AUTOINF_SP_PLUS, autoinf_time, change(), DoNotifyHpChange(), GetHpInfo(), hp_info, IsMember() und PO.

01322                       {
01323   mixed act,old;
01324   int change;
01325 
01326   if (!IsMember(PO) || !pointerp(act=hp_info[PO]))
01327     return;
01328   old=act[0..];
01329   act=GetHpInfo(PO);change=0;
01330   if (!autoinf_flags) return;
01331   if (((autoinf_flags&AUTOINF_HP_MINUS) && act[0]<old[0]) ||
01332       ((autoinf_flags&AUTOINF_HP_PLUS)  && act[0]>old[0]))
01333     autoinf_hp[PO]=act[0],change=1;
01334   if (((autoinf_flags&AUTOINF_SP_MINUS) && act[2]<old[2]) ||
01335       ((autoinf_flags&AUTOINF_SP_PLUS)  && act[2]>old[2]))
01336     autoinf_sp[PO]=act[2],change=1;
01337 
01338   if (autoinf_time<time() || (change && (autoinf_flags&AUTOINF_INSTANT)))
01339     DoNotifyHpChange();
01340 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

mapping PresentPositions ( mixed  pres_rows  ) 

Definiert in Zeile 584 der Datei team.c.

Benutzt MAX_TEAMROWS und PresentRows().

Wird benutzt von FleeToRow() und ShowTeamHP().

00584                                           {
00585   mapping res;
00586   int i,j;
00587   object *obs,ob;
00588 
00589   res=([]);
00590   if (objectp(pres_rows))
00591     pres_rows=PresentRows(pres_rows);
00592   if (!pointerp(pres_rows))
00593     return res;
00594   for (i=0;i<MAX_TEAMROWS;i++) {
00595     obs=pres_rows[i];
00596     for (j=sizeof(obs)-1;j>=0;j--)
00597       if (objectp(ob=obs[j]) && !res[ob])
00598         res[ob]=i+1;
00599   }
00600   return res;
00601 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

mixed* PresentRows ( object  env  ) 

Definiert in Zeile 542 der Datei team.c.

Benutzt EMPTY_TEAMARRAY, formin, h, is_member, last_reorder, MAX_TEAMROWS, rows, TP und UpdateFormation().

Wird benutzt von PresentPositions().

00542                                {
00543   int i,j,d,arbeit;
00544   mixed *res;
00545   object *old,*new,*nd,ob;
00546 
00547   if (!objectp(env))
00548     env=environment(TP);
00549   if (last_reorder!=time() || !mappingp(h))
00550     UpdateFormation();
00551   res=EMPTY_TEAMARRAY;arbeit=0;nd=({});
00552   for (i=0;i<MAX_TEAMROWS;i++) {
00553     old=rows[i];new=({});
00554     for (j=sizeof(old)-1;j>=0;j--) {
00555       if (objectp(ob=old[j]) && is_member[ob] && environment(ob)==env) {
00556         if (query_once_interactive(ob) && !interactive(ob)) {
00557           nd+=({ob});
00558           arbeit=1;
00559         } else {
00560           new+=({ob});
00561         }
00562       } else {
00563         arbeit=1;
00564       }
00565     }
00566     res[i]=new;
00567   }
00568   if (!arbeit)
00569     return res;
00570   for (i=j=0;i<MAX_TEAMROWS;i++) {
00571     if (j<=i) j=i+1;
00572     for (;j<MAX_TEAMROWS;j++) {
00573       d=formin[i]-sizeof(res[i]);
00574       if (d<=0)                   // Ausreichende Anzahl
00575         break;                    // kein weiteres j noetig
00576       res[i]+=res[j][0..(d-1)];   // Sonst Nachschub von hinten holen
00577       res[j]=res[j][d..];
00578     }
00579   }
00580   res[MAX_TEAMROWS-1]+=nd; // Netztote bieten keine Deckung, nach hinten.
00581   return res;
00582 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void RandomChangeRow (  )  [static]

Definiert in Zeile 361 der Datei team.c.

Benutzt h, i, rows, UpdateActRow() und wanted_row.

Wird benutzt von DoChangeRow().

00361                                       {
00362   int *nums,i;
00363   object p1,p2;
00364 
00365   if (!mappingp(h))
00366     UpdateActRow();
00367   for (nums=({0,1,2,3});sizeof(nums);nums-=({i})) {
00368     i=nums[random(sizeof(nums))];
00369     if (!sizeof(rows[i]) || !sizeof(rows[i+1])) continue;
00370     if (!objectp(p1=rows[i][<1]) || !objectp(p2=rows[i+1][0])) continue;
00371     if (wanted_row[p1]<wanted_row[p2]) continue;
00372     if (h[p2]-h[p1]>=-10) continue;
00373     rows[i][<1]=p2;
00374     rows[i+1][0]=p1;
00375     return;
00376   }
00377 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int remove ( int  silent  ) 

Definiert in Zeile 106 der Datei team.c.

Benutzt destruct(), is_member, ME, Members() und TEAM_MASTER.

00106                                {
00107   if (mappingp(is_member) && sizeof(Members())) // Nur leere Teams removen
00108     return 0;
00109   TEAM_MASTER->UnregisterTeam(); // Teamnamen freigeben.
00110   destruct(ME);
00111   return 1;
00112 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int RemoveAssocMember ( object  caster,
object  npc 
)

Definiert in Zeile 899 der Datei team.c.

Benutzt assoc_mem, DoRemoveMember(), IsMember() und PO.

Wird benutzt von RemoveMemberAndAssocs().

00899                                                  {
00900   object *obs;
00901 
00902   if (extern_call() && PO!=caster)
00903     return 0;
00904   if (!IsMember(caster) || assoc_mem[npc]!=caster)
00905     return 0;
00906   DoRemoveMember(npc);
00907 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void RemoveFromRow ( object  ob,
int  src 
) [static]

Definiert in Zeile 297 der Datei team.c.

Benutzt formin, MAX_TEAMROWS und rows.

Wird benutzt von DoChangeRow().

00297                                                       {
00298   if (src<0 || src>=MAX_TEAMROWS)
00299     return;
00300   rows[src]-=({ob});
00301   if (sizeof(rows[src])>=formin[src])
00302     return;
00303   // Falls hinten noch Ueberschuss da ist, her damit.
00304   if (src<MAX_TEAMROWS-1 && sizeof(rows[src+1])-1>=formin[src+1]) {
00305     rows[src]+=rows[src+1][0..0];
00306     rows[src+1]=rows[src+1][1..];
00307     return;
00308   }
00309   // Falls vorne noch Ueberschuss da ist, her damit.
00310   if (src>0 && sizeof(rows[src-1])-1>=formin[src-1]) {
00311     rows[src]=rows[src-1][<1..]+rows[src];
00312     rows[src-1]=rows[src-1][0..<2];
00313   }
00314 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int RemoveMember ( mixed  arg  ) 

Definiert in Zeile 936 der Datei team.c.

Benutzt assoc_mem, IsMember(), leader, ME, Members(), notify_fail(), P_TEAM, PO, RemoveMemberAndAssocs(), RemoveSingles(), TP, WEM und WER.

Wird benutzt von TeamCmd().

00936                             {
00937   object *mems,mem,ob;
00938   int i;
00939   
00940   if (objectp(arg)) {
00941     ob=arg;
00942   } else if (stringp(arg) && arg!="") {
00943     mems=Members()-({leader});
00944     for (i=sizeof(mems)-1;i>=0;i--) {
00945       if (objectp(mem=mems[i]) && mem->id(arg))  {
00946         ob=mem;
00947         if (query_once_interactive(ob))
00948           break;
00949       }
00950     }
00951     if (!objectp(ob))
00952       return notify_fail(capitalize(arg)+" nicht gefunden.\n"),0;
00953   } else {
00954     return 0;
00955   }
00956   if (TP!=leader && TP!=ob && ob!=PO)
00957     return notify_fail("Nur der Teamleiter kann Mitglieder entlassen.\n"),0;
00958   if (!IsMember(ob) && ob->QueryProp(P_TEAM)!=ME)
00959     return notify_fail(ob->Name(WER)+" ist kein Teammitglied.\n"),0;
00960   if (PO!=ob && objectp(assoc_mem[ob]))
00961     return notify_fail(ob->Name(WER)+" gehoert zu "+
00962                        assoc_mem[ob]->Name(WEM)+".\n"),0;
00963 
00964   RemoveMemberAndAssocs(ob);
00965   RemoveSingles();
00966   return 1;
00967 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static void RemoveMemberAndAssocs ( object  caster  )  [static]

Definiert in Zeile 909 der Datei team.c.

Benutzt DoRemoveMember(), P_TEAM_ASSOC_MEMBERS und RemoveAssocMember().

Wird benutzt von RemoveMember() und RemoveSingles().

00909                                                  {
00910   object *obs,ob;
00911   int i;
00912 
00913   if (pointerp(obs=caster->QueryProp(P_TEAM_ASSOC_MEMBERS))) {
00914     for (i=sizeof(obs)-1;i>=0;i--)
00915       if (objectp(ob=obs[i]))
00916         RemoveAssocMember(caster,ob);
00917   }
00918   DoRemoveMember(caster);
00919 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void RemoveSingles (  )  [static]

Definiert in Zeile 921 der Datei team.c.

Benutzt assoc_mem, gtell(), IsMember(), leader, Members(), RemoveMemberAndAssocs() und TryRemove().

Wird benutzt von RemoveMember() und reset().

00921                                     {
00922   object *obs;
00923   mixed aso;
00924 
00925   if (!IsMember(leader)) return;
00926   if (!query_once_interactive(leader)) return; // NPC Team
00927   obs=Members()-({leader});
00928   if (pointerp(aso=assoc_mem[leader]))
00929     obs-=aso;
00930   if (sizeof(obs)) return;
00931   gtell("Das Team loest sich auf.\n");
00932   RemoveMemberAndAssocs(leader);
00933   TryRemove();
00934 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void reset ( void   ) 

Definiert in Zeile 1409 der Datei team.c.

Benutzt RemoveSingles() und TryRemove().

01409              {
01410   RemoveSingles();
01411   TryRemove();
01412 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int Shout ( string  str  ) 

Definiert in Zeile 653 der Datei team.c.

Benutzt gtell(), notify_fail(), TP und WER.

Wird benutzt von TeamCmd().

00653                       {
00654   if (!str || str=="")
00655     return notify_fail("Was willst Du den anderen Teammitgliedern sagen?\n"),0;
00656   gtell(str,TP->Name(WER),1);
00657   return 1;
00658 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int ShowTeamHP ( string  arg  ) 

Definiert in Zeile 1099 der Datei team.c.

Benutzt act_row, ANSI_BOLD, ANSI_GREEN, ANSI_NORMAL, ANSI_RED, ANSI_UNDERL, ANSI_YELLOW, attack_cmd, autofollow, GetHpInfo(), leader, MAX_TEAMROWS, ME, notify_fail(), P_GUILD, P_GUILD_LEVEL, P_LEVEL, P_TEAM_COLORS, P_TTY, P_WIMPY, P_WIMPY_DIRECTION, PresentPositions(), qp, RAW, rows, TP, wanted_row und wimpy_row.

Wird benutzt von TeamCmd().

01099                                    {
01100   object *tmembers,ob;
01101   closure qp;
01102   int i,longinf;
01103   mixed *vals,*res,cols,fr,rr,termstr;
01104   mapping real_row;
01105   string nm,inf;
01106 
01107   if (arg && arg[0..3]=="lang") {
01108     if (TP!=leader)
01109       return notify_fail("Nur der Teamleiter kann die lange "+
01110                          "Uebersicht aufrufen.\n"),0;
01111     longinf=1;
01112     arg=arg[5..];
01113   } else
01114     longinf=0;
01115   real_row=PresentPositions(environment(TP));
01116   tmembers=({});
01117   for (i=0;i<MAX_TEAMROWS;i++)
01118     tmembers+=rows[i];
01119   res=({});
01120   switch(TP->QueryProp(P_TTY)) {
01121   case "ansi":
01122     termstr=({ANSI_RED+ANSI_BOLD,ANSI_YELLOW,ANSI_GREEN,ANSI_NORMAL,
01123               ANSI_UNDERL});
01124     break;
01125   case "vt100":
01126     termstr=({ANSI_BOLD,"","",ANSI_NORMAL,ANSI_UNDERL});
01127     break;
01128   default:
01129     termstr=({"","","","",""});
01130   }
01131   vals=({"",0,0,termstr[3],"",0,0,termstr[3]});
01132 
01133   printf("  Name        Gilde           LV GLV  LP (MLP)  KP (MKP) Vors. GR AR TR FR A V\n");
01134   if (longinf)
01135     printf("  (Zeile 2)   Angriffsbefehl                             Fluchtrichtung\n");
01136 
01137   for (i=sizeof(tmembers)-1;i>=0;i--) {
01138     if (!objectp(ob=tmembers[i])) continue;
01139     qp=symbol_function("QueryProp",ob);
01140     fr=GetHpInfo(ob,qp);
01141     vals[1]=fr[0];vals[2]=fr[1];vals[5]=fr[2];vals[6]=fr[3];
01142     /*
01143     vals[1]=funcall(qp,P_HP);vals[2]=funcall(qp,P_MAX_HP);
01144     vals[5]=funcall(qp,P_SP);vals[6]=funcall(qp,P_MAX_SP);
01145     */
01146     if (!pointerp(cols=funcall(qp,P_TEAM_COLORS)) || sizeof(cols)<4)
01147       cols=({vals[2]/4,vals[2]/2,vals[6]/4,vals[6]/2});
01148     if (vals[1]<cols[0])
01149       vals[0]=termstr[0];
01150     else if (vals[1]<cols[1])
01151       vals[0]=termstr[1];
01152     else
01153       vals[0]=termstr[2];
01154     if (vals[5]<cols[2])
01155       vals[4]=termstr[0];
01156     else if (vals[5]<cols[3])
01157       vals[4]=termstr[1];
01158     else
01159       vals[4]=termstr[2];
01160     if (intp(fr=wimpy_row[ob]) && fr>1) fr=sprintf("%2d",fr); else fr="--";
01161     if (intp(rr=real_row[ob]) && rr>0)  rr=sprintf("%2d",rr); else rr="--";
01162     nm=ob->Name(RAW);
01163     inf=sprintf("%s %-11s%s %-14s %3d %3d %s%3d (%3d)%s %s%3d (%3d)%s %5d %2d %2d %2s %2s %1s %1s\n",
01164                ((ob==leader)?(termstr[4]+"*"):" "),
01165                nm[0..10],termstr[3],
01166                capitalize(funcall(qp,P_GUILD)||"")[0..13],
01167                funcall(qp,P_LEVEL),
01168                funcall(qp,P_GUILD_LEVEL),
01169                vals[0],vals[1],vals[2],vals[3],
01170                vals[4],vals[5],vals[6],vals[7],
01171                funcall(qp,P_WIMPY),
01172                wanted_row[ob],act_row[ob],rr,fr,
01173                (attack_cmd[ob]?"X":"-"),
01174                (autofollow[ob]?"X":"-"));
01175     if (longinf) {
01176       if (!stringp(fr=funcall(qp,P_WIMPY_DIRECTION))) fr="";
01177       if (!stringp(rr=attack_cmd[ob])) rr="";
01178       if (fr!="" || rr!="")
01179         inf+=sprintf("              %-42s %-21s\n",rr[0..41],fr[0..20]);
01180     }
01181 
01182     switch (arg) {
01183     case "alphabetisch":
01184       res+=({({(query_once_interactive(ob)?"0":"1")+nm,inf})});
01185       break;
01186     case "sortiert":
01187       res+=({({sprintf("%2s %2d %2d %s",rr,act_row[ob],wanted_row[ob],nm),
01188                  inf})});
01189       break;
01190     default:
01191       res+=({({i,inf})});
01192     }
01193   }
01194   if (arg && arg!="")
01195     res=sort_array(res,"CmpFirstArrayElement",ME);
01196   for (i=sizeof(res)-1;i>=0;i--)
01197     write(res[i][1]);
01198   return 1;
01199 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void ShowTeamInfo (  ) 

Definiert in Zeile 1077 der Datei team.c.

Benutzt act_row, formax, formin, IS_LEARNER, leader, MAX_TEAMROWS, ME, Members(), name, TI, TP, UpdateActRow(), wanted_row und WER.

01077                     {
01078   int i;
01079   object *tmembers,ob;
01080   string form;
01081 
01082   if (!TI || TP!=TI || !IS_LEARNER(TI))
01083     return;
01084 
01085   UpdateActRow();
01086   form="";
01087   for (i=0;i<MAX_TEAMROWS;i++)
01088     form+=sprintf(" %d-%d",formin[i],formax[i]);
01089   printf("%s [%O] L: %s F:%s\n",name(),ME,
01090          (objectp(leader)?leader->Name(WER):"?"),form);
01091   tmembers=Members();
01092   for (i=sizeof(tmembers)-1;i>=0;i--) {
01093     ob=tmembers[i];
01094     printf("  %d(%d) %s [%O]\n",
01095            act_row[ob],wanted_row[ob],ob->Name(WER),ob);
01096   }
01097 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs int ShowTeamRooms ( string  arg  ) 

Definiert in Zeile 1201 der Datei team.c.

Benutzt ME, Members(), P_INT_SHORT und RAW.

Wird benutzt von TeamCmd().

01201                                       {
01202   object *tmembers,ob;
01203   string s1,s2;
01204   mixed *res;
01205   int i;
01206 
01207   tmembers=Members();res=({});
01208   for (i=sizeof(tmembers)-1;i>=0;i--) {
01209     if (!objectp(ob=tmembers[i])) continue;
01210     if (!query_once_interactive(ob) && arg!="alle") continue;
01211     s1=ob->Name(RAW);
01212     if (!objectp(ob=environment(ob))) continue;
01213     if (!stringp(s2=ob->QueryProp(P_INT_SHORT))) s2="";
01214     res+=({({s1,s2})});
01215   }
01216   res=sort_array(res,"CmpFirstArrayElement",ME);
01217   for (i=sizeof(res)-1;i>=0;i--)
01218     printf("%-11s %-66s\n",res[i][0][0..10],res[i][1][0..65]);
01219   return 1;
01220 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private int StartAttack (  )  [static]

Definiert in Zeile 1038 der Datei team.c.

Benutzt att_exec, attack_cmd, gtell(), leader, Members(), notify_fail(), TeamInitAttack(), TP und WER.

Wird benutzt von TeamCmd().

01038                                  {
01039   object *tmembers,ob,env;
01040   int i;
01041 
01042   if (TP!=leader || !objectp(env=environment(TP)))
01043     return notify_fail("Nur der Teamleiter kann den Angriff starten.\n"),0;
01044   tmembers=Members();
01045   TeamInitAttack(); // Falls noch Schlaege fehlen....
01046   for (i=sizeof(tmembers)-1;i>=0;i--)
01047     if (objectp(ob=tmembers[i]) && stringp(attack_cmd[ob]))
01048       if (ob->CallTeamAttack(env)) // Angriff wird ausgefuehrt?
01049         att_exec+=({ob});          // Liste der Angreifer
01050   gtell(TP->Name(WER)+" startet den Angriff.\n");
01051   return 1;
01052 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void StartFollow ( object  env  ) 

Definiert in Zeile 1054 der Datei team.c.

Benutzt autofollow, leader, Members(), P_GHOST, PO und TP.

01054                              {
01055   object *tmembers,ob;
01056   int i;
01057   string cmd,args;
01058 
01059   // printf("ld:%O PO:%O TP:%O qv:%O env:%O\n",leader,PO,TP,query_verb(),env);
01060   if (TP!=leader
01061       || !stringp(cmd=query_verb())
01062       || !objectp(env)
01063       || TP!=PO
01064       || TP->QueryProp(P_GHOST) // Der Befehl war wohl ungesund...
01065       || TP->IsTeamMove()) // Angriffsbefehl nicht durch verfolge 2 mal...
01066     return;
01067   cmd="\\"+cmd;
01068   if (stringp(args=TP->_unparsed_args()) && args!="")
01069     cmd+=(" "+args);
01070   tmembers=Members()-({leader});
01071   for (i=sizeof(tmembers)-1;i>=0;i--)
01072     if (objectp(ob=tmembers[i]) && autofollow[ob])    
01073                 if(!query_once_interactive(ob)  || env==environment(ob)) // autofolge nur bei anfuehrer im gleichen raum
01074                       ob->CallTeamFollow(env,cmd);
01075 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int SwapRows ( object  ob1,
object  ob2 
)

Definiert in Zeile 485 der Datei team.c.

Benutzt gtell(), MAX_TEAMROWS, rows und WER.

00485                                      {
00486   int i,r1,r2,p1,p2;
00487 
00488   if (!objectp(ob1) || !objectp(ob2) || ob1==ob2)
00489     return 0;
00490   r1=r2=-1;
00491   for (i=0;i<MAX_TEAMROWS;i++) {
00492     if (r1==-1 && (p1=member(rows[i],ob1))>=0)
00493       r1=i;
00494     if (r2==-1 && (p2=member(rows[i],ob2))>=0)
00495       r2=i;
00496   }
00497   if (r1==-1 || r2==-1)
00498     return 0;
00499   if (r1==r2)
00500     return 1;
00501   if (r1<r2) { // Nicht Monster vor Spieler stellen
00502     if (query_once_interactive(ob1) && !interactive(ob2))
00503       return 0;
00504   } else {
00505     if (query_once_interactive(ob2) && !interactive(ob1))
00506       return 0;
00507   }
00508   rows[r1][p1]=ob2;ob2->InformRowChange(r2,r1);
00509   rows[r2][p2]=ob1;ob1->InformRowChange(r1,r2);
00510   gtell(ob1->Name(WER)+" und "+ob2->name(WER)+" tauschen die Plaetze.\n");
00511   return 1;
00512 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

void TeamAttackExecuted_Callback ( int  success  ) 

Definiert in Zeile 1030 der Datei team.c.

Benutzt att_exec, IsMember(), PO und TeamInitAttack().

01030                                               {
01031   if (!IsMember(PO))
01032     return;
01033   att_exec-=({PO,0});
01034   if (!sizeof(att_exec))
01035     TeamInitAttack();
01036 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int TeamCmd ( string  cmd,
string  arg 
)

Definiert in Zeile 1342 der Datei team.c.

Benutzt attack_cmd, autofollow, ChangeAutoInfo(), ChangeColors(), ChangeFormation(), ChangeLeader(), ChangeName(), ChangeRow(), ChangeWimpyRow(), Hist(), IsMember(), leader, m_delete(), ME, notify_fail(), P_TEAM, RemoveMember(), Shout(), ShowTeamHP(), ShowTeamRooms(), StartAttack() und TP.

01342                                     {
01343   if (!IsMember(TP)) {
01344     notify_fail("Du bist kein Teammitglied.\n");
01345     if (TP->QueryProp(P_TEAM)==ME)
01346       TP->SetProp(P_TEAM,0);
01347     return 0;
01348   }
01349   switch(cmd) {
01350   case "angriff":
01351     return StartAttack();
01352   case "angriffsbefehl":
01353     if (stringp(arg))
01354       attack_cmd[TP]=arg;
01355     else
01356       efun::m_delete(attack_cmd,arg);
01357     return 1;
01358   case "autofolge":
01359   case "autof":
01360     if (arg=="ein" || arg=="an")
01361       autofollow[TP]=1;
01362     else
01363       efun::m_delete(autofollow,TP);
01364     return 1;
01365   case "autoi":
01366   case "autoinf":
01367   case "autoinfo":
01368   case "autoinform":
01369     return ChangeAutoInfo(arg);
01370   case "entlasse":
01371     return RemoveMember(arg);
01372   case "farben":
01373     return ChangeColors(arg);
01374   case "fluchtreihe":
01375   case "flucht":
01376     return ChangeWimpyRow(arg);
01377   case "formation":
01378     if (TP!=leader)
01379       return notify_fail("Nur der Teamleiter kann die Formation aendern.\n"),0;
01380     return ChangeFormation(arg);
01381   case "hist":
01382   case "history":
01383     return Hist(arg);
01384   case "":
01385   case "info":
01386     return ShowTeamHP(arg);
01387   case "leiter":
01388   case "leiterin":
01389   case "leitung":
01390     return ChangeLeader(arg);
01391   case "name":
01392     return ChangeName(arg);
01393   case "orte":
01394     return ShowTeamRooms(arg);
01395   case "kampfreihe":
01396   case "reihe":
01397     return ChangeRow(arg);
01398   case "ruf":
01399   case "rufe":
01400     return Shout(arg);
01401   case "verlasse":
01402     TP->SetProp(P_TEAM,0);
01403     return RemoveMember(TP);
01404   default:;
01405   }
01406   return 0;
01407 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

void TeamInitAttack (  ) 

Definiert in Zeile 983 der Datei team.c.

Benutzt att_exec, debug(), IsMember(), mis_attacked, mis_init_att und removed().

Wird benutzt von StartAttack() und TeamAttackExecuted_Callback().

00983                       {
00984   object *obs,*ens,*removed,ob,en;
00985   int i,j;
00986 
00987   debug(sprintf("mis_init_att: %O\n",mis_init_att));
00988   ens=m_indices(mis_init_att);removed=({});
00989   for (i=sizeof(ens)-1;i>=0;i--) {
00990     if (!objectp(en=ens[i]))
00991       continue;
00992     if (!pointerp(obs=mis_init_att[en]))
00993       continue;
00994     for (j=sizeof(obs)-1;j>=0;j--)
00995       if (!IsMember(ob=obs[j]) || environment(ob)!=environment(en))
00996         obs[j]=0;
00997     obs-=({0});
00998     ob=en->SelectNearEnemy(obs,1);
00999     debug(sprintf("Begruessungsschlag von %O fuer %O\n",en,ob));
01000     if (!objectp(ob))
01001       continue;
01002     en->Attack2(ob); // Begruessungsschlag
01003     removed+=({en}); // Kein Begruessungsschlag mehr von diesem Monster
01004   }
01005 
01006   for (i=sizeof(mis_attacked)-1;i>=0;i--)
01007     if (objectp(ob=mis_attacked[i]))
01008       ob->ExecuteMissingAttacks(removed);
01009   // Begruessungsschlaege die ausgefuehrt wurden entfernen
01010   // und nicht ausgefuehrte nachholen
01011 
01012   mis_attacked=({});
01013   mis_init_att=([]);
01014   att_exec=({});
01015 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void TryRemove (  )  [static]

Definiert in Zeile 114 der Datei team.c.

Benutzt call_out(), is_member, ME und Members().

Wird benutzt von DoRemoveMember(), RemoveSingles() und reset().

00114                                 {
00115   if (clonep(ME)
00116       && (!mappingp(is_member) || !sizeof(Members()))
00117       && !first_inventory(ME)
00118       && find_call_out("remove")<0)
00119     call_out("remove",0);
00120 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void UpdateActRow (  )  [static]

Definiert in Zeile 166 der Datei team.c.

Benutzt act_row, assoc_mem, h, i, is_member, MAX_TEAMROWS, ME, Members(), ob(), P_HP, rows und wanted_row.

Wird benutzt von DoChangeRow(), MakeFormation(), RandomChangeRow() und ShowTeamInfo().

00166                                    {
00167   int i,j,update_hp;
00168   object *old,*new,ob;
00169   mixed aso;
00170 
00171   act_row=([]);
00172   rows[0]+=Members();
00173   update_hp=0;
00174   if (!mappingp(h)) {
00175     h=([]);
00176     update_hp=1;
00177   }
00178   for (i=MAX_TEAMROWS-1;i>=0;i--) {
00179     old=rows[i];new=({});
00180     for (j=sizeof(old)-1;j>=0;j--) {
00181       if (objectp(ob=old[j]) && is_member[ob] && !act_row[ob]) {
00182         act_row[ob]=i+1;
00183         new+=({ob});
00184         if (update_hp) {
00185           if (!objectp(aso=assoc_mem[ob]) || environment(aso)!=environment(ob))
00186             aso=ob;
00187           h[ob]=
00188             1000*wanted_row[aso]
00189             +40*act_row[aso]
00190             -(query_once_interactive(aso)?8:2)*aso->QueryProp(P_HP)
00191             -query_once_interactive(ob);
00192           // NPCs bekommen fast gleichen Wert wie Caster,
00193           // im Zweifelsfalle steht der Caster weiter vorne...
00194         }
00195       }
00196     }
00197     rows[i]=sort_array(new,"CompareHp",ME);
00198   }
00199 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void UpdateFormation (  ) 

Definiert in Zeile 481 der Datei team.c.

Benutzt DoChangeRow().

Wird benutzt von ChangeFormation() und PresentRows().

00481                        {
00482   DoChangeRow(0,0);
00483 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

Variablen-Dokumentation

private mapping act_row [static]

Definiert in Zeile 29 der Datei team.c.

Wird benutzt von create(), DoChangeRow(), DoRemoveMember(), ShowTeamHP(), ShowTeamInfo() und UpdateActRow().

private mapping assoc_mem [static]

Definiert in Zeile 32 der Datei team.c.

Wird benutzt von AddAssocMember(), create(), DoAddMember(), DoChangeRow(), DoRemoveMember(), RemoveAssocMember(), RemoveMember(), RemoveSingles() und UpdateActRow().

private object* att_exec [static]

Definiert in Zeile 37 der Datei team.c.

Wird benutzt von create(), InitAttack_Callback(), StartAttack(), TeamAttackExecuted_Callback() und TeamInitAttack().

private mapping attack_cmd [static]

Definiert in Zeile 31 der Datei team.c.

Wird benutzt von create(), DoAddMember(), DoRemoveMember(), ShowTeamHP(), StartAttack() und TeamCmd().

private mapping autofollow [static]

Definiert in Zeile 30 der Datei team.c.

Wird benutzt von create(), DoAddMember(), DoRemoveMember(), ShowTeamHP(), StartFollow() und TeamCmd().

private int autoinf_flags [static]

Definiert in Zeile 41 der Datei team.c.

Wird benutzt von ChangeAutoInfo(), create() und NotifyHpChange().

private mapping autoinf_hp [static]

Definiert in Zeile 42 der Datei team.c.

Wird benutzt von create(), DoNotifyHpChange(), DoRemoveMember() und NotifyHpChange().

private mapping autoinf_sp [static]

Definiert in Zeile 43 der Datei team.c.

Wird benutzt von create(), DoNotifyHpChange(), DoRemoveMember() und NotifyHpChange().

private int autoinf_time [static]

Definiert in Zeile 44 der Datei team.c.

Wird benutzt von DoNotifyHpChange() und NotifyHpChange().

private object debugger [static]

Definiert in Zeile 47 der Datei team.c.

Wird benutzt von _set_debug() und debug().

private int * formax [static]

Definiert in Zeile 33 der Datei team.c.

Wird benutzt von AddToRow(), ChangeFormation(), CheckFormation(), create(), CycleRows(), MakeFormation() und ShowTeamInfo().

private int* formin [static]

Definiert in Zeile 33 der Datei team.c.

Wird benutzt von ChangeFormation(), CheckFormation(), create(), CycleRows(), MakeFormation(), PresentRows(), RemoveFromRow() und ShowTeamInfo().

private mapping h [static]

Definiert in Zeile 36 der Datei team.c.

Wird benutzt von checkConsistency(), CompareHp(), create(), DoChangeRow(), finger_single(), FleeToRow(), get_carbon_copy(), HelpVerb(), MailMessage(), Message2string(), PresentRows(), process_names(), pubtest(), RandomChangeRow(), RegisterArmour(), RegisterWeapon(), scanart(), spaltenzahl(), Uncatchup(), UpdateActRow(), UseHands() und write_mail().

private string* hist [static]

Definiert in Zeile 45 der Datei team.c.

Wird benutzt von ChannelParser(), create(), gtell() und Hist().

private mapping hp_info [static]

Definiert in Zeile 40 der Datei team.c.

Wird benutzt von create(), DoRemoveMember(), GetHpInfo() und NotifyHpChange().

private mapping is_member [static]

Definiert in Zeile 24 der Datei team.c.

Wird benutzt von create(), DoAddMember(), DoRemoveMember(), IsInteractiveMember(), IsMember(), Members(), PresentRows(), remove(), TryRemove() und UpdateActRow().

private int last_reorder [static]

Definiert in Zeile 35 der Datei team.c.

Wird benutzt von MakeFormation() und PresentRows().

private object leader [static]

Definiert in Zeile 25 der Datei team.c.

Wird benutzt von AddMember(), ChangeAutoInfo(), ChangeLeader(), ChangeName(), create(), DoAddMember(), DoChangeLeader(), DoNotifyHpChange(), DoRemoveMember(), Leader(), RemoveMember(), RemoveSingles(), ShowTeamHP(), ShowTeamInfo(), StartAttack(), StartFollow() und TeamCmd().

private object* mis_attacked [static]

Definiert in Zeile 38 der Datei team.c.

Wird benutzt von create(), InitAttack_Callback() und TeamInitAttack().

private mapping mis_init_att [static]

Definiert in Zeile 39 der Datei team.c.

Wird benutzt von create(), InitAttack_Callback() und TeamInitAttack().

private mixed* rows [static]

Definiert in Zeile 34 der Datei team.c.

Wird benutzt von AddToRow(), create(), CycleRows(), MakeFormation(), PresentEnemyRows(), PresentRows(), RandomChangeRow(), RemoveFromRow(), SelectFarEnemy(), SelectNearEnemy(), ShowTeamHP(), SwapRows() und UpdateActRow().

private string tname [static]

Definiert in Zeile 26 der Datei team.c.

Wird benutzt von ChangeName(), create() und name().

private mapping wanted_row [static]

Definiert in Zeile 27 der Datei team.c.

Wird benutzt von ChangeRow(), create(), DoAddMember(), DoChangeRow(), DoRemoveMember(), FleeToRow(), RandomChangeRow(), ShowTeamHP(), ShowTeamInfo() und UpdateActRow().

private mapping wimpy_row [static]

Definiert in Zeile 28 der Datei team.c.

Wird benutzt von ChangeWimpyRow(), create(), DoAddMember(), DoRemoveMember(), FleeToRow() und ShowTeamHP().

Erzeugt am Thu Jun 3 14:40:45 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3