MG Mud User | 88f1247 | 2016-06-24 23:31:02 +0200 | [diff] [blame^] | 1 | // MorgenGrauen MUDlib |
| 2 | // |
| 3 | // npc/combat.c -- NPC-spezifische Kampffunktionen |
| 4 | // |
| 5 | // $Id: combat.c 9488 2016-02-19 21:24:04Z Arathorn $ |
| 6 | #pragma strong_types |
| 7 | #pragma save_types |
| 8 | #pragma range_check |
| 9 | #pragma no_clone |
| 10 | #pragma pedantic |
| 11 | |
| 12 | inherit "std/living/combat"; |
| 13 | |
| 14 | #include <combat.h> |
| 15 | #include <language.h> |
| 16 | #include <properties.h> |
| 17 | #include <wizlevels.h> |
| 18 | #include <health.h> |
| 19 | #include <new_skills.h> |
| 20 | |
| 21 | #define NEED_PROTOTYPES 1 |
| 22 | #include <living/life.h> |
| 23 | #undef NEED_PROTOTYPES |
| 24 | |
| 25 | #define HB_CHECK 7 |
| 26 | #define ME this_object() |
| 27 | #define STATMASTER "/p/service/rochus/guildstat/master" |
| 28 | |
| 29 | nosave int heartbeat, beatcount; |
| 30 | |
| 31 | private void catch_up_hbs(); |
| 32 | |
| 33 | protected void create() { |
| 34 | ::create(); |
| 35 | beatcount=1; |
| 36 | heartbeat=1; |
| 37 | } |
| 38 | |
| 39 | protected void create_super() { |
| 40 | set_next_reset(-1); |
| 41 | } |
| 42 | |
| 43 | // aktuelles Lebewesen, fuer das dieser NPC gerade taetig ist. Default: |
| 44 | // Spieler, bei dem er als Helfer-NPC registriert ist. |
| 45 | public object QueryUser() |
| 46 | { |
| 47 | mixed helperdata = QueryProp(P_HELPER_NPC); |
| 48 | if (pointerp(helperdata) && objectp(helperdata[0])) |
| 49 | return helperdata[0]; |
| 50 | return 0; |
| 51 | } |
| 52 | |
| 53 | // ggf. Feinde expiren. Soll das Problem verringern, dass Spieler nach Tagen |
| 54 | // erst die Meldung kriegen, dass der NPC sie nicht mehr jagt, wenn der HB |
| 55 | // reaktivert wird. |
| 56 | void reset() { |
| 57 | // ggf. die abgeschalteten HBs nachholen. |
| 58 | if (!heartbeat) |
| 59 | catch_up_hbs(); |
| 60 | // ggf. P_ENEMY_DAMAGE zuruecksetzen |
| 61 | ResetEnemyDamage(); |
| 62 | } |
| 63 | |
| 64 | static void _set_max_hp(int i) { |
| 65 | Set(P_MAX_HP,i); |
| 66 | SetProp(P_HP,i); |
| 67 | } |
| 68 | |
| 69 | static void _set_max_sp(int i) { |
| 70 | Set(P_MAX_SP,i); |
| 71 | SetProp(P_SP,i); |
| 72 | } |
| 73 | |
| 74 | |
| 75 | // Check-Funktion fuer die P_NO_ATTACK-QueryMethod |
| 76 | static mixed _check_immortality() |
| 77 | { |
| 78 | int t; |
| 79 | |
| 80 | if ( !(t = Query("time_to_mortality")) || time() > t ){ |
| 81 | // Zeit ist abgelaufen - wieder angreifbar machen |
| 82 | Set( P_NO_ATTACK, 0, F_QUERY_METHOD ); |
| 83 | heartbeat = 1; |
| 84 | beatcount = 1; |
| 85 | set_heart_beat(1); |
| 86 | |
| 87 | return 0; |
| 88 | } |
| 89 | |
| 90 | // der NPC ist noch unangreifbar |
| 91 | return break_string( capitalize(name( WER, 1 )) + " versteckt sich hinter " |
| 92 | "einem Fehler im Raum-Zeit-Gefuege und entgeht so " |
| 93 | "voruebergehend allen Angriffen.", 78 ); |
| 94 | } |
| 95 | |
| 96 | |
| 97 | // wenn der HeartBeat buggt, wird diese Funktion vom Master aufgerufen |
| 98 | public void make_immortal() |
| 99 | { |
| 100 | // fuer 5 Minuten unangreifbar machen |
| 101 | Set( P_NO_ATTACK, #'_check_immortality, F_QUERY_METHOD ); |
| 102 | |
| 103 | Set( "time_to_mortality", time() + 300, F_VALUE ); |
| 104 | |
| 105 | // damit die Spieler keinen Vorteil durch den Bug haben, heilen |
| 106 | heal_self(10000); |
| 107 | |
| 108 | // da nun der Heartbeat abgeschaltet ist und normalerweise erst |
| 109 | // reaktiviert wird, sobald jemand nach 5min P_NO_ATTACK abfragt, muss man |
| 110 | // aber auf Viecher achten, die immer nen Heartbeat haben wollen. In dem |
| 111 | // fall per call_out selber die Prop abfragen. |
| 112 | if (QueryProp(P_HB)) |
| 113 | call_out(#'QueryProp, 301, P_NO_ATTACK); |
| 114 | } |
| 115 | |
| 116 | |
| 117 | // Damit NPCs gegeneinander weiterkaempfen, auch wenn kein Spieler |
| 118 | // in der Naehe ist: |
| 119 | static int _query_hb() |
| 120 | { |
| 121 | // TODO: return InFight() || Query(P_HB, F_VALUE), sobald InFight() |
| 122 | // geaendert. |
| 123 | return (InFight() || Query(P_HB,F_VALUE)) ? 1 : 0; |
| 124 | } |
| 125 | |
| 126 | |
| 127 | #define SPELL_TOTALRATE 0 |
| 128 | #define SPELL_DAMAGE 1 |
| 129 | #define SPELL_TEXT_FOR_ENEMY 2 |
| 130 | #define SPELL_TEXT_FOR_OTHERS 3 |
| 131 | #define SPELL_DAMTYPE 4 |
| 132 | #define SPELL_FUNC 5 |
| 133 | #define SPELL_ARG 6 |
| 134 | |
| 135 | varargs int AddSpell(int rate, int damage, string TextForEnemy, |
| 136 | string TextForOthers, string|string* dam_type, string func, |
| 137 | int|mapping spellarg) { |
| 138 | mixed *spells; |
| 139 | int total_rates; |
| 140 | |
| 141 | if (rate<0 || damage<=0 || !stringp(TextForEnemy) || |
| 142 | !stringp(TextForOthers)) |
| 143 | return 0; |
| 144 | |
| 145 | if (stringp(dam_type)) |
| 146 | dam_type = ({dam_type}); |
| 147 | else if (!pointerp(dam_type)) |
| 148 | dam_type = ({DT_MAGIC}); |
| 149 | |
| 150 | // Tatsaechlich ist es immer ein nicht-physischer Angriff, wenn spellarg ein |
| 151 | // int ist, weil wenn spellarg==0 ist der Default nicht-physischer Angriff |
| 152 | // und bei spellarg!=0 auch. Nur mit einem mapping kann man einen phys. |
| 153 | // Angriff erzeugen. |
| 154 | if (intp(spellarg)) |
| 155 | spellarg = ([SP_PHYSICAL_ATTACK: 0]); |
| 156 | |
| 157 | // Falls vorhanden, alte Syntax auf die von replace_personal() anpassen, |
| 158 | // die im heart_beat() beim Ausgeben der Meldung verwendet wird. |
| 159 | if ( strstr(TextForOthers, "@", 0) != -1 ) |
| 160 | { |
| 161 | // Zeichen nach @WER & Co in runde Klammern einschliessen, damit es als |
| 162 | // Sub-Pattern im Ausgabestring wiederholt werden kann. Ansonsten wuerde |
| 163 | // es mit ersetzt. |
| 164 | TextForOthers = regreplace(TextForOthers, "@WER([^1-9])", "@WER1\\1", 1); |
| 165 | TextForOthers = regreplace(TextForOthers, "@WESSEN([^1-9])", |
| 166 | "@WESSEN1\\1", 1); |
| 167 | TextForOthers = regreplace(TextForOthers, "@WEM([^1-9])", "@WEM1\\1", 1); |
| 168 | TextForOthers = regreplace(TextForOthers, "@WEN([^1-9])", "@WEN1\\1", 1); |
| 169 | } |
| 170 | total_rates=Query("npc:total_rates")+rate; |
| 171 | spells=Query(P_SPELLS); |
| 172 | if (!pointerp(spells)) |
| 173 | spells=({}); |
| 174 | spells+=({({total_rates, damage, TextForEnemy, TextForOthers, |
| 175 | dam_type, func, spellarg})}); |
| 176 | Set(P_SPELLS,spells); |
| 177 | Set("npc:total_rates",total_rates); |
| 178 | return 1; |
| 179 | } |
| 180 | |
| 181 | int AutoAttack(object ob) { |
| 182 | mixed m; |
| 183 | |
| 184 | if (!query_once_interactive(ob)) |
| 185 | return 0; |
| 186 | if (mappingp(m=QueryProp(P_AGGRESSIVE))) { |
| 187 | mixed *ind,x,z; |
| 188 | float f; |
| 189 | int i,n; |
| 190 | |
| 191 | ind=m_indices(m)-({0});n=0;f=0.0; |
| 192 | for (i=sizeof(ind)-1;i>=0;i--) { |
| 193 | x=ind[i]; |
| 194 | if ((z=m[x][ob->QueryProp(x)]) || (z=m[x][0])) { |
| 195 | f=f+(float)z; |
| 196 | n++; |
| 197 | } |
| 198 | } |
| 199 | if (n) |
| 200 | m=f/((float)n); |
| 201 | else |
| 202 | m=m[0]; |
| 203 | } |
| 204 | if (((int)(100*(m+ob->QueryProp(P_AGGRESSIVE))))<=random(100)) |
| 205 | return 0; |
| 206 | if (IS_LEARNER(ob) |
| 207 | && (ob->QueryProp(P_INVIS) |
| 208 | || ob->QueryProp(P_WANTS_TO_LEARN))) |
| 209 | return 0; |
| 210 | return 1; |
| 211 | } |
| 212 | |
| 213 | void SpellAttack(object enemy) { |
| 214 | } |
| 215 | |
| 216 | #if 0 |
| 217 | TJ(string s) { |
| 218 | object o; |
| 219 | if (o=find_player("jof")) |
| 220 | tell_object(o,sprintf("%O: %s\n",this_object(),s)); |
| 221 | } |
| 222 | #else |
| 223 | #define TJ(x) |
| 224 | #endif |
| 225 | |
| 226 | protected void heart_beat() { |
| 227 | int r,i; |
| 228 | mixed env,*spells, sinfo; |
| 229 | object enemy; |
| 230 | |
| 231 | if ( --beatcount < 0 ) |
| 232 | beatcount = 0; |
| 233 | |
| 234 | if (!beatcount && !Query(P_HB)) { |
| 235 | if (!environment()) { |
| 236 | set_heart_beat(0); |
| 237 | heartbeat = 0; |
| 238 | if( clonep(this_object()) ) remove(); |
| 239 | return; |
| 240 | } |
| 241 | if (!QueryProp(P_POISON)) { |
| 242 | // Spieler anwesend? |
| 243 | env = filter(all_inventory(environment()), #'query_once_interactive); |
| 244 | if (!sizeof(env)) { |
| 245 | // Nein, HBs abschalten. |
| 246 | set_heart_beat(0); |
| 247 | heartbeat=0; |
| 248 | TJ("OFF\n"); |
| 249 | beatcount=HB_CHECK; |
| 250 | Set("npc:beat_off_num",absolute_hb_count()); |
| 251 | return; |
| 252 | } |
| 253 | } |
| 254 | } |
| 255 | ::heart_beat(); |
| 256 | if (!ME) |
| 257 | return; |
| 258 | enemy=SelectEnemy(); |
| 259 | if (QueryProp(P_AGGRESSIVE) |
| 260 | && (!enemy || environment()!=environment(enemy)) |
| 261 | && !beatcount) { |
| 262 | beatcount=HB_CHECK; |
| 263 | env=filter(all_inventory(environment()),#'AutoAttack); |
| 264 | if (!sizeof(env)) |
| 265 | return; |
| 266 | i=random(sizeof(env)); |
| 267 | Kill(env[i]); |
| 268 | } |
| 269 | else if (!beatcount) |
| 270 | beatcount=HB_CHECK; |
| 271 | if (!objectp(enemy) ||QueryProp(P_DISABLE_ATTACK)>0) |
| 272 | return; |
| 273 | SpellAttack(enemy); |
| 274 | |
| 275 | if (!pointerp(spells=Query(P_SPELLS)) |
| 276 | || !sizeof(spells) |
| 277 | || !objectp(enemy=SelectEnemy()) |
| 278 | || environment(enemy)!=environment() |
| 279 | || (QueryProp(P_DISABLE_ATTACK)>0) |
| 280 | || random(100)>Query(P_SPELLRATE)) |
| 281 | return; |
| 282 | r=random(Query("npc:total_rates")); |
| 283 | for (i=sizeof(spells)-1;(i>0 && spells[i-1][SPELL_TOTALRATE]>r);i--) |
| 284 | ; |
| 285 | string akt_spell_mess = spells[i][SPELL_TEXT_FOR_ENEMY]; |
| 286 | if ( sizeof(akt_spell_mess) ) |
| 287 | tell_object(enemy, break_string(akt_spell_mess, 78)); |
| 288 | akt_spell_mess = spells[i][SPELL_TEXT_FOR_OTHERS]; |
| 289 | // Nur, wenn ueberhaupt eine Meldung gesetzt wurde, muss diese verarbeitet |
| 290 | // werden. |
| 291 | if (stringp(akt_spell_mess) && sizeof(akt_spell_mess)) |
| 292 | { |
| 293 | akt_spell_mess = replace_personal(akt_spell_mess, ({enemy}), 1); |
| 294 | say(break_string(akt_spell_mess, 78),({enemy, this_object()})); |
| 295 | } |
| 296 | sinfo = deep_copy(spells[i][SPELL_ARG]); |
| 297 | if(!mappingp(sinfo)) |
| 298 | sinfo=([ SI_MAGIC_TYPE :({ MT_ANGRIFF }) ]); |
| 299 | else if(!sinfo[SI_MAGIC_TYPE]) |
| 300 | sinfo[ SI_MAGIC_TYPE]=({ MT_ANGRIFF }); |
| 301 | if(!sinfo[SP_PHYSICAL_ATTACK] && |
| 302 | (enemy->SpellDefend(this_object(),sinfo) > |
| 303 | random(MAX_ABILITY+QueryProp(P_LEVEL)*50))){ |
| 304 | tell_object(enemy,"Du wehrst den Spruch ab.\n"); |
| 305 | say(enemy->Name(WER,1)+" wehrt den Spruch ab.\n", |
| 306 | ({ enemy, this_object()})); |
| 307 | return ; |
| 308 | } |
| 309 | int damage = random(spells[i][SPELL_DAMAGE])+1; |
| 310 | enemy->Defend(damage, spells[i][SPELL_DAMTYPE], |
| 311 | spells[i][SPELL_ARG], |
| 312 | this_object()); |
| 313 | |
| 314 | // Falls der Gegner (oder wir) im Defend stirbt, hier abbrechen |
| 315 | if ( !objectp(ME) || !objectp(enemy) |
| 316 | || enemy->QueryProp(P_GHOST) ) return; |
| 317 | |
| 318 | if (spells[i][SPELL_FUNC] && stringp(spells[i][SPELL_FUNC])) |
| 319 | catch(call_other(this_object(), |
| 320 | spells[i][SPELL_FUNC], |
| 321 | enemy, |
| 322 | damage, |
| 323 | spells[i][SPELL_DAMTYPE]);publish); |
| 324 | } |
| 325 | |
| 326 | // Heartbeats nachholen. |
| 327 | private void catch_up_hbs() { |
| 328 | // gibt es HBs zum nachholen? |
| 329 | int beat_off_num = Query("npc:beat_off_num"); |
| 330 | if (!beat_off_num) |
| 331 | return; // nein. |
| 332 | // wieviele HBs nachholen? |
| 333 | beat_off_num = absolute_hb_count() - beat_off_num; |
| 334 | |
| 335 | if (beat_off_num>0) { |
| 336 | // Nicht ausgefuehrtes HEILEN nachholen |
| 337 | int rlock=QueryProp(P_NO_REGENERATION); |
| 338 | int hp=QueryProp(P_HP); |
| 339 | int sp=QueryProp(P_SP); |
| 340 | int alc=QueryProp(P_ALCOHOL); |
| 341 | if (!(rlock & NO_REG_HP)) { |
| 342 | hp+=beat_off_num/HEAL_DELAY+alc/ALCOHOL_DELAY; |
| 343 | SetProp(P_HP,hp); |
| 344 | } |
| 345 | if (!(rlock & NO_REG_SP)) { |
| 346 | sp+=beat_off_num/HEAL_DELAY+alc/ALCOHOL_DELAY; |
| 347 | SetProp(P_SP,sp); |
| 348 | } |
| 349 | alc-=beat_off_num/ALCOHOL_DELAY; |
| 350 | if ( alc < 0 ) |
| 351 | alc = 0; |
| 352 | SetProp(P_ALCOHOL,alc); |
| 353 | int da = QueryProp(P_DISABLE_ATTACK); |
| 354 | // Paralysen abbauen |
| 355 | if ( da > 0 ) { |
| 356 | da -= beat_off_num; |
| 357 | if ( da < 0 ) |
| 358 | da = 0; |
| 359 | SetProp( P_DISABLE_ATTACK, da ); |
| 360 | } |
| 361 | // Hunttimes aktualisieren, Feinde expiren |
| 362 | update_hunt_times(beat_off_num); |
| 363 | if (!heartbeat) |
| 364 | // HBs immer noch abgeschaltet, naechstes Mal HBs seit jetzt nachholen. |
| 365 | Set("npc:beat_off_num",absolute_hb_count()); |
| 366 | else |
| 367 | // HB laeuft wieder, nix mehr nachholen, bis zur naechsten Abschaltung. |
| 368 | Set("npc:beat_off_num",0); |
| 369 | } |
| 370 | } |
| 371 | |
| 372 | void init() { |
| 373 | |
| 374 | // ggf. Heartbeats nachholen und wieder einschalten. |
| 375 | if (!heartbeat) { |
| 376 | set_heart_beat(1); |
| 377 | heartbeat=1; |
| 378 | catch_up_hbs(); |
| 379 | } |
| 380 | |
| 381 | if (AutoAttack(this_player())) |
| 382 | Kill(this_player()); |
| 383 | } |
| 384 | |
| 385 | private nosave closure mod_att_stat; |
| 386 | |
| 387 | int Defend(int dam, mixed dam_type, mixed spell, object enemy) { |
| 388 | if (objectp(enemy=(enemy||this_player())) |
| 389 | && query_once_interactive(enemy) |
| 390 | && !IS_LEARNER(enemy)) { |
| 391 | if (!objectp(get_type_info(mod_att_stat,2))) { |
| 392 | object ma; |
| 393 | if (!objectp(ma=find_object(STATMASTER))) |
| 394 | return ::Defend(dam,dam_type,spell,enemy); |
| 395 | // Keine Statistik wenn Master nicht geladen ist. |
| 396 | mod_att_stat=symbol_function("ModifyAttackStat",ma); |
| 397 | } |
| 398 | funcall(mod_att_stat, |
| 399 | enemy->QueryProp(P_GUILD), |
| 400 | enemy->QueryProp(P_GUILD_LEVEL), |
| 401 | dam, |
| 402 | dam_type, |
| 403 | spell); |
| 404 | } |
| 405 | |
| 406 | return ::Defend(dam,dam_type,spell,enemy); |
| 407 | } |