skills.c-Dateireferenz

#include <combat.h>
#include <new_skills.h>
#include <properties.h>
#include <break_string.h>
#include <player/base.h>

Include-Abhängigkeitsdiagramm für skills.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	NEED_PROTOTYPES
Funktionen
protected void	create ()
public mapping	GetDeactivatedSkills ()
public int	is_deactivated_skill (string sname, string guild)
private void	set_weapon_skills ()
protected void	InitSkills ()
private void	FixSkillV0 (string skillname, mixed sinfo)
protected void	FixSkills ()
protected mapping	ShortRangeSkill (object me, string sname, mapping sinfo)
protected mapping	LongRangeSkill (object me, string sname, mapping sinfo, int dam)
protected mapping	StdSkill_Fight_axe (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Fight_club (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Fight_knife (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Fight_spear (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Fight_sword (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Fight_whip (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Fight_staff (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Shoot_arrow (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Shoot_bolt (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Shoot_dart (object me, string sname, mapping sinfo)
protected mapping	StdSkill_Shoot_stone (object me, string sname, mapping sinfo)
protected string *	_query_localcmds ()
public varargs int	SetSpellFatigue (int duration, string key)
	Speichert eine Spellfatigue von <duration> Sekunden fuer <key>.
public int	enable_spell_fatigue_compat (string cmd)
	Befehlsfunktion fuer Spieler um den Spellfatigue-Kompatibilitaetsmodus umzuschalten.
protected void	heart_beat ()
	Speichert die Zeit des letztes Heartbeats.
Variablen
inherit std living	skills
nosave mapping	deactivated_skills = ([])
int	spell_fatigue_compat_mode

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 23 der Datei skills.c.

Dokumentation der Funktionen

protected string* _query_localcmds ( )

Definiert in Zeile 375 der Datei skills.c.

00375                                      {
00376     return ({ ({"spruchermuedung","enable_spell_fatigue_compat",0,0}) });
00377 }

protected void create ( )

Definiert in Zeile 39 der Datei skills.c.

Benutzt create(), deactivated_skills, dtime(), F_MODE_AD, F_MODE_AS, guild, GUILDMASTER, log_file, P_GUILD_DEACTIVATE_SKILLS, P_NEXT_SPELL_TIME, P_SKILLSVERSION, P_VALID_GUILDS, SAVE, SECURED und Set().

00040 {
00041   mapping act;
00042 
00043   ::create();
00044 
00045   // Wir holen die Gilden aus dem Gildenmaster 
00046   foreach(string guild:
00047       (string *)call_other(GUILDMASTER,"QueryProp",P_VALID_GUILDS))
00048   {
00049     if(catch(act=call_other("/gilden/"+guild,"QueryProp",
00050         P_GUILD_DEACTIVATE_SKILLS); publish ))
00051         log_file("WEAPON_SKILLS", sprintf ("%s: Gilde nicht ladbar: "
00052               +"TP: %O, TI: %O, PO: %O, Gilde: %s\n", dtime(time()),
00053               this_player(), this_interactive(), previous_object(), guild));
00054     else if (act) // wenn act, ins Mapping aufnehmen.
00055         deactivated_skills+=([guild:act]);
00056   }
00057   // keine echte Prop mehr, Save-Modus unnoetig.
00058   Set(P_NEXT_SPELL_TIME,SAVE,F_MODE_AD);
00059 
00060   Set(P_SKILLSVERSION, SAVE|SECURED, F_MODE_AS);
00061 }

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

public int enable_spell_fatigue_compat ( string cmd )

Befehlsfunktion fuer Spieler um den Spellfatigue-Kompatibilitaetsmodus umzuschalten.

Definiert in Zeile 418 der Datei skills.c.

Benutzt break_string(), BS_LEAVE_MY_LFS, notify_fail(), P_LAST_COMBAT_TIME, QueryProp() und spell_fatigue_compat_mode.

00419 00420 00421 00422 00423 00424 00425 00426 00427   } 00428 00429 00430 00431 00432 00433 00434 00435 00436   } 00437 00438 00439 00440 00441 00442 00443   } 00444 00445 00446 00447 00448 00449 00450 00451 }

class="fragment">00418 { if (QueryProp(P_LAST_COMBAT_TIME) + 600 > time()) { write(break_string( "Im Kampf oder kurz nach einem Kampf kannst Du nicht zwischen " "alter und neuer Spruchermuedung umschalten.\n" "Momentan benutzt Du die " + (spell_fatigue_compat_mode ? "alte (ungenauere)" : "neue (normale)") + " Spruchermuedung.",78,0,BS_LEAVE_MY_LFS)); return 1; if (cmd=="alt") { spell_fatigue_compat_mode=time(); write(break_string( "Alte Spruchermuedung wurde eingeschaltet. Alle Ermuedungspausen " "zwischen Spruechen werden auf Vielfache von 2s aufgerundet und " "beginnen in der Regel am Anfang Deiner Kampfrunde.")); return 1; else if (cmd=="neu" || cmd=="normal") { spell_fatigue_compat_mode=0; write(break_string( "Normale Spruchermuedung wurde eingeschaltet. Alle Ermuedungspausen " "zwischen Spruechen werden sekundengenau berechnet.")); return 1; notify_fail(break_string( "Moechtest Du die alte oder die neue Spruchermuedung?\n" "Momentan benutzt Du die " + (spell_fatigue_compat_mode ? "alte (ungenauere)" : "neue (normale)") + " Spruchermuedung.",78,0,BS_LEAVE_MY_LFS)); return 0;

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

protected void FixSkills ( )

Definiert in Zeile 143 der Datei skills.c.

00143                            {
00144 /*
00145   // nur bei genug rechenzeit loslegen
00146   if (get_eval_cost() < 1300000) {
00147     call_out(#'FixSkills, 2);
00148     return;
00149   }
00150   // wenn gar keine Skills da (?): InitSkills() rufen.
00151   mapping allskills = Query(P_NEWSKILLS, F_VALUE);
00152   if (!mappingp(allskills) || !sizeof(allskills)) {
00153       InitSkills();
00154       return;
00155   }
00156   // bei Version 0
00157   if (QueryProp(P_SKILLSVERSION) == 0) {
00158     foreach(string gilde, mapping skills: allskills) {
00159       walk_mapping(skills, #'FixSkillV0);
00160     }
00161     // Waffenskills aktivieren
00162     set_weapon_skills();
00163     // Speicherflag fuer die Versionsprop muss noch gesetzt werden.
00164     Set(P_SKILLSVERSION, SAVE|SECURED, F_MODE_AS);
00165     // Versionszaehlen um eins auf 1 erhoehen.
00166     SetProp(P_SKILLSVERSION, 1);
00167   }
00168 
00169   // Falls noch nicht auf der aktuellen Version angekommen, neuer callout
00170   if (QueryProp(P_SKILLSVERSION) != CURRENT_SKILL_VERSION)
00171       call_out(#'FixSkills, 2);
00172       */
00173 }

private void FixSkillV0	(	string	skillname,
		mixed	sinfo
	)

Definiert in Zeile 118 der Datei skills.c.

Benutzt SI_SKILLABILITY, SI_SPELL, SI_SPELLBOOK und SP_NAME.

00118                                                        {
00119   // alte Skills auf mapping normieren
00120   if (intp(sinfo)) {
00121     sinfo = ([SI_SKILLABILITY: sinfo ]);
00122   }
00123   // wenn ein Spellbook vermerkt ist, ist es wohl ein Spell, sonst wird von
00124   // Skill ausgegangen. Bei Skills: hier Abbruch
00125   if (!sinfo[SI_SPELLBOOK])
00126       return;
00127 
00128   // Fuer Spells ggf. SI_SPELL erstellen
00129   if (!mappingp(sinfo[SI_SPELL]))
00130     sinfo[SI_SPELL] = ([]);
00131   // SP_NAME vermerken
00132   if (!sinfo[SP_NAME] && !sinfo[SI_SPELL][SP_NAME]) {
00133     sinfo[SP_NAME] = skillname;
00134     sinfo[SI_SPELL][SP_NAME] = skillname;
00135   }
00136   else if (sinfo[SP_NAME] && !sinfo[SI_SPELL][SP_NAME])
00137     sinfo[SI_SPELL][SP_NAME] = sinfo[SP_NAME];
00138   else if (!sinfo[SP_NAME] && sinfo[SI_SPELL][SP_NAME])
00139     sinfo[SP_NAME] = sinfo[SI_SPELL][SP_NAME];
00140 }

public mapping GetDeactivatedSkills ( )

Definiert in Zeile 65 der Datei skills.c.

Benutzt deactivated_skills.

00066 {
00067     return copy(deactivated_skills);
00068 }

protected void heart_beat ( )

Speichert die Zeit des letztes Heartbeats.

Definiert in Zeile 455 der Datei skills.c.

Benutzt spell_fatigue_compat_mode.

00455                             {
00456   if (spell_fatigue_compat_mode)
00457     spell_fatigue_compat_mode = time();
00458 }

protected void InitSkills ( )

Definiert in Zeile 103 der Datei skills.c.

Benutzt CURRENT_SKILL_VERSION, F_MODE_AS, F_VALUE, P_NEWSKILLS, P_SKILLSVERSION, Query(), SAVE, SECURED, Set(), set_weapon_skills() und SetProp().

00103                             {
00104   mapping ski;
00105   // schonmal initialisiert?
00106   if (mappingp(ski=Query(P_NEWSKILLS, F_VALUE)) && sizeof(ski))
00107     return;
00108 
00109   // allg. Waffenskills aktivieren
00110   set_weapon_skills();
00111 
00112   // Version setzen
00113   SetProp(P_SKILLSVERSION, CURRENT_SKILL_VERSION);
00114   Set(P_SKILLSVERSION, SAVE|SECURED, F_MODE_AS);
00115 }

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

public int is_deactivated_skill	(	string	sname,
		string	guild
	)

Definiert in Zeile 71 der Datei skills.c.

Benutzt deactivated_skills.

00072 {
00073         if (deactivated_skills[guild])        
00074                 return deactivated_skills[guild][sname];
00075         return 0;
00076 }

protected mapping LongRangeSkill	(	object	me,
		string	sname,
		mapping	sinfo,
		int	dam
	)

Definiert in Zeile 290 der Datei skills.c.

Benutzt LearnSkill(), MAX_ABILITY, OFFSET, P_SHOOTING_WC, P_WEAPON, QueryProp(), QuerySkillAttribute(), SA_DAMAGE, SI_SKILLABILITY und SI_SKILLDAMAGE.

Wird benutzt von StdSkill_Shoot_arrow(), StdSkill_Shoot_bolt(), StdSkill_Shoot_dart() und StdSkill_Shoot_stone().

00291 { int abil,val;
00292 
00293   if (!mappingp(sinfo) || !dam || !objectp(sinfo[P_WEAPON]) ||
00294       (sinfo[P_WEAPON]->QueryProp(P_SHOOTING_WC))<5)
00295     return 0;
00296 
00297   abil=sinfo[SI_SKILLABILITY]+OFFSET(sinfo[SI_SKILLABILITY]);
00298   val=dam*abil/MAX_ABILITY;
00299   val=val/2+random(val/2+1);
00300   val=(val*QuerySkillAttribute(SA_DAMAGE))/100;
00301   sinfo[SI_SKILLDAMAGE]+=val;
00302 
00303   if (random(MAX_ABILITY+1)>sinfo[SI_SKILLABILITY] && random(50)==42)
00304     LearnSkill(sname, 1, 150);
00305 
00306   return sinfo;
00307 }

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

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

private void set_weapon_skills ( )

Definiert in Zeile 83 der Datei skills.c.

Benutzt FIGHT, ModifySkill(), QuerySkillAbility(), SI_SKILLABILITY, WT_AXE, WT_CLUB, WT_KNIFE, WT_SPEAR, WT_STAFF, WT_SWORD und WT_WHIP.

Wird benutzt von InitSkills().

00083                                  {
00084 
00085   if (QuerySkillAbility(FIGHT(WT_SWORD))<=0)                
00086       ModifySkill(FIGHT(WT_SWORD),([SI_SKILLABILITY:0]),150,"ANY");    
00087   if (QuerySkillAbility(FIGHT(WT_AXE))<=0)                
00088       ModifySkill(FIGHT(WT_AXE),([SI_SKILLABILITY:0]),150,"ANY");          
00089   if (QuerySkillAbility(FIGHT(WT_SPEAR))<=0)        
00090       ModifySkill(FIGHT(WT_SPEAR),([SI_SKILLABILITY:0]),150,"ANY");          
00091   if (QuerySkillAbility(FIGHT(WT_WHIP))<=0)
00092       ModifySkill(FIGHT(WT_WHIP),([SI_SKILLABILITY:0]),150,"ANY");
00093   if (QuerySkillAbility(FIGHT(WT_KNIFE))<=0)                
00094       ModifySkill(FIGHT(WT_KNIFE),([SI_SKILLABILITY:0]),150,"ANY");          
00095   if (QuerySkillAbility(FIGHT(WT_CLUB))<=0)                
00096       ModifySkill(FIGHT(WT_CLUB),([SI_SKILLABILITY:0]),150,"ANY");          
00097   if (QuerySkillAbility(FIGHT(WT_STAFF))<=0)
00098       ModifySkill(FIGHT(WT_STAFF),([SI_SKILLABILITY:0]),150,"ANY");
00099 }

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

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

public varargs int SetSpellFatigue	(	int	duration,
		string	key
	)

Speichert eine Spellfatigue von <duration> Sekunden fuer <key>.

Ist hier nur fuer den Spellfatigue-Compat-mode. <key> darf 0 sein und bezeichnet das globale Spellfatigue. Rueckgabewert: Ablaufzeit der gesetzten Sperre -1, wenn noch eine nicht-abgelaufene Sperre auf dem <key> lag. 0, wenn duration 0 ist.

Definiert in Zeile 390 der Datei skills.c.

Benutzt SetSpellFatigue() und spell_fatigue_compat_mode.

00390                                                              {
00391 
00392   // 0 sollte nie eine Sperre bewirken, auch nicht im compat mode.
00393   if (!duration) return 0;
00394 
00395   if (spell_fatigue_compat_mode) {
00396     // Spell-Fatigues auf HBs synchronisieren (2s-Alarmzeit-Emulation).
00397     // Aufrunden auf ganzzahlige Vielfache von __HEART_BEAT_INTERVAL__
00398     if (duration % __HEART_BEAT_INTERVAL__)
00399         ++duration;
00400 
00401     // Startpunkt des Delay soll Beginn der aktuellen Kampfrunde (HB-Zyklus)
00402     // sein, ggf. um max. eine Sekunde zurueckdatieren.
00403     // (spell_fatigue_compat_mode hat die Zeit des letzten HB-Aufrufs)
00404     // Falls durch irgendein Problem (z.B. sehr hohe Last), der letzte HB
00405     // laenger als 1s zurueckliegt, funktioniert das natuerlich nicht, aber
00406     // bei fatigue+=spell_fatigue_compat_mode kann der Spieler zuviel Zeit
00407     // einsparen.
00408     if (time() > spell_fatigue_compat_mode)
00409         --duration;  //1s zurueckdatieren
00410   }
00411 
00412   return ::SetSpellFatigue(duration, key);
00413 }

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

protected mapping ShortRangeSkill	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 177 der Datei skills.c.

Benutzt A_DEX, A_STR, dtime(), find_player(), LearnSkill(), log_file, MAX_ABILITY, P_WC, P_WEAPON, P_WEAPON_TEACHER, P_WEAPON_TYPE, P_XP, QueryAttribute(), QueryProp(), SI_ENEMY, SI_SKILLABILITY, SI_SKILLDAMAGE, WT_AXE, WT_CLUB, WT_KNIFE, WT_SPEAR, WT_STAFF, WT_SWORD und WT_WHIP.

Wird benutzt von StdSkill_Fight_axe(), StdSkill_Fight_club(), StdSkill_Fight_knife(), StdSkill_Fight_spear(), StdSkill_Fight_staff(), StdSkill_Fight_sword() und StdSkill_Fight_whip().

00178 { 
00179   int val, w;
00180   object enemy;
00181   
00182   if (!mappingp(sinfo) || !objectp(sinfo[P_WEAPON]))
00183     return 0;
00184 
00185   w = ([WT_KNIFE : 8,
00186         WT_SWORD : 5,
00187         WT_AXE   : 4,
00188         WT_SPEAR : 6,
00189         WT_CLUB  : 1,
00190         WT_WHIP  : 9,
00191         WT_STAFF : 7])[sinfo[P_WEAPON]->QueryProp(P_WEAPON_TYPE)];
00192       
00193 
00194   val = sinfo[SI_SKILLABILITY]*(sinfo[P_WEAPON]->QueryProp(P_WC)*
00195                                 (w*QueryAttribute(A_DEX)+
00196                                  (10-w)*QueryAttribute(A_STR))/800)
00197         /MAX_ABILITY;
00198 
00199   if (val > 75) {
00200     log_file("WEAPON_SKILLS", sprintf("%s: Zu hoher Schaden von: "
00201     +"TO: %O, TI: %O, PO: %O, val: %d, A_DEX: %d, A_STR: %d, "
00202                                    +"P_WEAPON: %O, P_WC: %d\n", dtime(time()),
00203                                    this_object(), this_interactive(), 
00204                                    previous_object(), val, 
00205                                    QueryAttribute(A_DEX),
00206                                    QueryAttribute(A_STR), sinfo[P_WEAPON],
00207                                    sinfo[P_WEAPON]->QueryProp(P_WC)));
00208     val = 75;
00209   }
00210 
00211   /*
00212     Der zus�tzliche Schaden der allgemeinen Waffenskills berechnet
00213     sich wie folgt: 
00214 
00215     sinfo[SI_SKILLABILITY)* (P_WC * ( X ) / 800) / MAX_ABILITY
00216 
00217     Dabei beruecksichtigt X je nach Waffentyp in unterschiedlicher
00218     Gewichtung die Werte fuer Geschicklichkeit und Staerke. 
00219 
00220      X == 
00221 
00222        Messer   : 8*A_DEX + 2*A_STR
00223        Schwert  : 5*A_DEX + 5*A_STR
00224        Axt      : 4*A_DEX + 6*A_STR 
00225        Speer    : 6*A_DEX + 4*A_STR
00226        Keule    : 1*A_DEX + 9*A_STR
00227        Peitsche : 9*A_DEX + 1*A_STR
00228   */
00229 
00230   sinfo[SI_SKILLDAMAGE]+=val;
00231 
00232 
00233   /* Lernen: Wird immer schwieriger, nur bei jedem 20. Schlag im Schnitt,
00234    * und nur dann, wenn der Gegner auch XP gibt. */
00235   if (random(MAX_ABILITY+1)>sinfo[SI_SKILLABILITY] && !random(20))
00236   {
00237          enemy=sinfo[SI_ENEMY];
00238          if (objectp(enemy) && (enemy->QueryProp(P_XP)>0))
00239          {
00240            object ausbilder;
00241         //         log_file("humni/log_wurm","Haut: %s und zwar %s, mit xp %d\n",geteuid(this_object()),to_string(enemy),enemy->QueryProp(P_XP));
00242             LearnSkill(sname, random(5), 150);
00243         // Gibt es einen Ausbilder?
00244         if (QueryProp(P_WEAPON_TEACHER) && 
00245                         ausbilder=find_player(QueryProp(P_WEAPON_TEACHER)))
00246           {
00247             // Ist der Ausbilder anwesend?
00248             if (present(ausbilder,environment()))
00249               {
00250               // Ausbilder und Azubi muessen dieselbe Waffe haben.
00251               //string wt_aus,wt_azu;
00252               object waf_aus,waf_azu;
00253 
00254               waf_azu=QueryProp(P_WEAPON);
00255               waf_aus=call_other(ausbilder,"QueryProp",P_WEAPON);
00256 
00257               //wt_azu=call_other(waf_azu,"QueryProp",P_WEAPON_TYPE);
00258               //wt_aus=call_other(waf_aus,"QueryProp",P_WEAPON_TYPE);
00259               //if (wt_azu==wt_aus)
00260               if (objectp(waf_aus) && objectp(waf_azu) &&
00261                   (string)waf_aus->QueryProp(P_WEAPON_TYPE)
00262                      == (string)waf_azu->QueryProp(P_WEAPON_TYPE)) 
00263                 {
00264                 // Bonus von bis zu 5 Punkten
00265                 //log_file("humni/log_azubi",
00266                   // sprintf("Azubi %O und Ausbilder %O : Waffentypen %s und %s, gelernt\n",this_object(),
00267                     //   ausbilder, wt_azu, wt_aus));
00268                 LearnSkill(sname,random(6),150);
00269                 }
00270           }
00271         }
00272     }
00273   }
00274 
00275   /* 
00276      Die Schwierigkeit liegt bei 150, so dass 
00277      ein Lvl. 1 Spieler maximal 15% Skill 
00278      usw...
00279      lernen kann. (Genaue Tabelle in /std/living/skills bei LimitAbility)
00280   */         
00281 
00282   return sinfo;
00283 }

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

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

protected mapping StdSkill_Fight_axe	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 313 der Datei skills.c.

Benutzt ShortRangeSkill().

00314 {
00315   return ShortRangeSkill(me, sname, sinfo);
00316 }

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

protected mapping StdSkill_Fight_club	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 318 der Datei skills.c.

Benutzt ShortRangeSkill().

00319 {
00320   return ShortRangeSkill(me, sname, sinfo);
00321 }

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

protected mapping StdSkill_Fight_knife	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 323 der Datei skills.c.

Benutzt ShortRangeSkill().

00324 {
00325   return ShortRangeSkill(me, sname, sinfo);
00326 }

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

protected mapping StdSkill_Fight_spear	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 328 der Datei skills.c.

Benutzt ShortRangeSkill().

00329 {
00330   return ShortRangeSkill(me, sname, sinfo);
00331 }

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

protected mapping StdSkill_Fight_staff	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 343 der Datei skills.c.

Benutzt ShortRangeSkill().

00344 {
00345   return ShortRangeSkill(me, sname, sinfo);
00346 }

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

protected mapping StdSkill_Fight_sword	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 333 der Datei skills.c.

Benutzt ShortRangeSkill().

00334 {
00335   return ShortRangeSkill(me, sname, sinfo);
00336 }

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

protected mapping StdSkill_Fight_whip	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 338 der Datei skills.c.

Benutzt ShortRangeSkill().

00339 {
00340   return ShortRangeSkill(me, sname, sinfo);
00341 }

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

protected mapping StdSkill_Shoot_arrow	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 355 der Datei skills.c.

Benutzt LongRangeSkill().

00356 {
00357   return LongRangeSkill(me, sname, sinfo, 40);
00358 }

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

protected mapping StdSkill_Shoot_bolt	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 360 der Datei skills.c.

Benutzt LongRangeSkill().

00361 { 
00362   return LongRangeSkill(me, sname, sinfo, 40);
00363 }

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

protected mapping StdSkill_Shoot_dart	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 365 der Datei skills.c.

Benutzt LongRangeSkill().

00366 {
00367   return LongRangeSkill(me, sname, sinfo, 20);
00368 }

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

protected mapping StdSkill_Shoot_stone	(	object	me,
		string	sname,
		mapping	sinfo
	)

Definiert in Zeile 370 der Datei skills.c.

Benutzt LongRangeSkill().

00371 {
00372   return LongRangeSkill(me, sname, sinfo, 40);
00373 }

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

Variablen-Dokumentation

nosave mapping deactivated_skills = ([])

Definiert in Zeile 29 der Datei skills.c.

Wird benutzt von create(), GetDeactivatedSkills() und is_deactivated_skill().

inherit std living skills

Definiert in Zeile 16 der Datei skills.c.

int spell_fatigue_compat_mode

Definiert in Zeile 35 der Datei skills.c.

Wird benutzt von enable_spell_fatigue_compat(), heart_beat() und SetSpellFatigue().

skills.c-Dateireferenz

Makrodefinitionen

Funktionen

Variablen

Makro-Dokumentation

Dokumentation der Funktionen

Variablen-Dokumentation