/* * static char *rcsid_pets_c = * "$Id: pets.c,v 1.2 2006/03/22 03:03:35 root Exp $"; */ /* CrossFire, A Multiplayer game for X-windows Copyright (C) 2002 Mark Wedel & Crossfire Development Team Copyright (C) 1992 Frank Tore Johansen This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. The authors can be reached via e-mail at crossfire-devel@real-time.com */ #include #ifndef __CEXTRACT__ #include #endif /* given that 'pet' is a friendly object, this function returns a * monster the pet should attack, NULL if nothing appropriate is * found. it basically looks for nasty things around the owner * of the pet to attack. * this is now tilemap aware. */ object *get_pet_enemy(object * pet, rv_vector *rv){ object *owner, *tmp, *attacker, *tmp3; int i; sint16 x,y; mapstruct *nm; int search_arr[SIZEOFFREE]; int mflags; attacker = pet->attacked_by; /*pointer to attacking enemy*/ pet->attacked_by = NULL; /*clear this, since we are dealing with it*/ if ((owner = get_owner(pet)) != NULL) { /* If the owner has turned on the pet, make the pet * unfriendly. */ if ((check_enemy(owner,rv)) == pet) { CLEAR_FLAG(pet, FLAG_FRIENDLY); remove_friendly_object(pet); pet->attack_movement &=~PETMOVE; return owner; } } else { /* else the owner is no longer around, so the * pet no longer needs to be friendly. */ CLEAR_FLAG(pet, FLAG_FRIENDLY); remove_friendly_object(pet); pet->attack_movement &=~PETMOVE; return NULL; } /* If they are not on the same map, the pet won't be agressive */ if (!on_same_map(pet,owner)) return NULL; /* See if the pet has an existing enemy. If so, don't start a new one*/ if((tmp=check_enemy(pet, rv))!=NULL) { if(tmp == owner && !QUERY_FLAG(pet,FLAG_CONFUSED) && QUERY_FLAG(pet,FLAG_FRIENDLY)) /* without this check, you can actually get pets with * enemy set to owner! */ pet->enemy = NULL; else return tmp; } get_search_arr(search_arr); if (owner->type == PLAYER && owner->contr->petmode > pet_normal) { if (owner->contr->petmode == pet_sad) { tmp = find_nearest_living_creature(pet); if (tmp != NULL) { get_rangevector(pet, tmp, rv, 0); if(check_enemy(pet, rv) != NULL) return tmp; else pet->enemy = NULL; } /* if we got here we have no enemy */ /* we return NULL to avoid heading back to the owner */ pet->enemy = NULL; return NULL; } } /* Since the pet has no existing enemy, look for anything nasty * around the owner that it should go and attack. */ tmp3 = NULL; for (i = 0; i < SIZEOFFREE; i++) { x = owner->x + freearr_x[search_arr[i]]; y = owner->y + freearr_y[search_arr[i]]; nm = owner->map; /* Only look on the space if there is something alive there. */ mflags = get_map_flags(nm, &nm, x, y, &x, &y); if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) { for (tmp = get_map_ob(nm, x, y); tmp != NULL; tmp = tmp->above) { object *tmp2 = tmp->head == NULL?tmp:tmp->head; if (QUERY_FLAG(tmp2,FLAG_ALIVE) && (( !QUERY_FLAG(tmp2, FLAG_FRIENDLY) && (tmp2->type != PLAYER)) || should_arena_attack(pet, owner, tmp2)) && !QUERY_FLAG(tmp2,FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy(pet, tmp2, rv)) { if (!can_see_enemy(pet, tmp2)) { if (tmp3 != NULL) tmp3 = tmp2; } else { pet->enemy = tmp2; if(check_enemy(pet, rv)!=NULL) return tmp2; else pet->enemy = NULL; } }/* if this is a valid enemy */ }/* for objects on this space */ }/* if there is something living on this space */ } /* for loop of spaces around the owner */ /* fine, we went through the whole loop and didn't find one we could see, take what we have */ if (tmp3 != NULL) { pet->enemy = tmp3; if (check_enemy(pet, rv) != NULL) return tmp3; else pet->enemy = NULL; } /* No threat to owner, check to see if the pet has an attacker*/ if (attacker) { /* need to be sure this is the right one! */ if (attacker->count == pet->attacked_by_count) { /* also need to check to make sure it is not freindly */ /* or otherwise non-hostile, and is an appropriate target */ if (!QUERY_FLAG(attacker, FLAG_FRIENDLY) && on_same_map(pet, attacker)) { pet->enemy = attacker; if (check_enemy(pet, rv) != NULL) return attacker; else pet->enemy = NULL; } } } /* Don't have an attacker or legal enemy, so look for a new one!. * This looks for one around where the pet is. Thus, you could lead * a pet to danger, then take a few steps back. This code is basically * the same as the code that looks around the owner. */ if (owner->type == PLAYER && owner->contr->petmode != pet_defend) { tmp3 = NULL; for (i = 0; i < SIZEOFFREE; i++) { x = pet->x + freearr_x[search_arr[i]]; y = pet->y + freearr_y[search_arr[i]]; nm = pet->map; /* Only look on the space if there is something alive there. */ mflags = get_map_flags(nm, &nm, x,y, &x, &y); if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) { for (tmp = get_map_ob(nm, x, y); tmp != NULL; tmp = tmp->above) { object *tmp2 = tmp->head == NULL?tmp:tmp->head; if (QUERY_FLAG(tmp2,FLAG_ALIVE) && (( !QUERY_FLAG(tmp2, FLAG_FRIENDLY) && (tmp2->type != PLAYER)) || should_arena_attack(pet, owner, tmp2)) && !QUERY_FLAG(tmp2,FLAG_UNAGGRESSIVE) && tmp2 != pet && tmp2 != owner && can_detect_enemy(pet, tmp2, rv)) { if (!can_see_enemy(pet, tmp2)) { if (tmp3 != NULL) tmp3 = tmp2; } else { pet->enemy = tmp2; if(check_enemy(pet, rv)!=NULL) return tmp2; else pet->enemy = NULL; } } /* make sure we can get to the bugger */ }/* for objects on this space */ } /* if there is something living on this space */ } /* for loop of spaces around the pet */ } /* pet in defence mode */ /* fine, we went through the whole loop and didn't find one we could see, take what we have */ if (tmp3 != NULL) { pet->enemy = tmp3; if (check_enemy(pet, rv) != NULL) return tmp3; else pet->enemy = NULL; } /* Didn't find anything - return the owner's enemy or NULL */ return check_enemy(pet, rv); } void terminate_all_pets(object *owner) { objectlink *obl, *next; for(obl = first_friendly_object; obl != NULL; obl = next) { object *ob = obl->ob; next = obl->next; if(get_owner(ob) == owner) { if(!QUERY_FLAG(ob, FLAG_REMOVED)) remove_ob(ob); remove_friendly_object(ob); free_object(ob); } } } /* * Unfortunately, sometimes, the owner of a pet is in the * process of entering a new map when this is called. * Thus the map isn't loaded yet, and we have to remove * the pet... * Interesting enough, we don't use the passed map structure in * this function. */ void remove_all_pets(mapstruct *map) { objectlink *obl, *next; object *owner; for(obl = first_friendly_object; obl != NULL; obl = next) { next = obl->next; if(obl->ob->type != PLAYER && QUERY_FLAG(obl->ob,FLAG_FRIENDLY) && (owner = get_owner(obl->ob)) != NULL && !on_same_map(owner, obl->ob)) { /* follow owner checks map status for us */ follow_owner(obl->ob,owner); if(QUERY_FLAG(obl->ob, FLAG_REMOVED) && FABS(obl->ob->speed) > MIN_ACTIVE_SPEED) { object *ob = obl->ob; LOG(llevMonster,"(pet failed to follow)\n"); remove_friendly_object(ob); free_object(ob); } } } } void follow_owner(object *ob, object *owner) { object *tmp; int dir; if (!QUERY_FLAG(ob,FLAG_REMOVED)) remove_ob(ob); if(owner->map == NULL) { LOG(llevError,"Can't follow owner: no map.\n"); return; } if(owner->map->in_memory != MAP_IN_MEMORY) { LOG(llevError,"Owner of the pet not on a map in memory!?\n"); return; } dir = find_free_spot(ob, owner->map, owner->x, owner->y, 1, SIZEOFFREE); if (dir==-1) { LOG(llevMonster,"No space for pet to follow, freeing %s.\n",ob->name); return; /* Will be freed since it's removed */ } for(tmp=ob;tmp!=NULL;tmp=tmp->more) { tmp->x = owner->x + freearr_x[dir]+(tmp->arch==NULL?0:tmp->arch->clone.x); tmp->y = owner->y + freearr_y[dir]+(tmp->arch==NULL?0:tmp->arch->clone.y); tmp->map = owner->map; if (OUT_OF_REAL_MAP(tmp->map, tmp->x, tmp->y)) { tmp->map = get_map_from_coord(tmp->map, &tmp->x, &tmp->y); } } insert_ob_in_map(ob, ob->map, NULL,0); if (owner->type == PLAYER) /* Uh, I hope this is always true... */ new_draw_info(NDI_UNIQUE, 0,owner, "Your pet magically appears next to you"); return; } void pet_move(object * ob) { int dir, tag, i; sint16 dx, dy; object *ob2, *owner; mapstruct *m; /* Check to see if player pulled out */ if ((owner = get_owner(ob)) == NULL) { remove_ob(ob); /* Will be freed when returning */ remove_friendly_object(ob); free_object(ob); LOG(llevMonster, "Pet: no owner, leaving.\n"); return; } /* move monster into the owners map if not in the same map */ if (!on_same_map(ob, owner)) { follow_owner(ob, owner); return; } /* Calculate Direction */ if (owner->type == PLAYER && owner->contr->petmode == pet_sad) { /* in S&D mode, if we have no enemy, run randomly about. */ for (i=0; i < 15; i++) { dir = rndm(1, 8); dx = ob->x + freearr_x[dir]; dy = ob->y + freearr_y[dir]; m = ob->map; if (get_map_flags(ob->map, &m, dx, dy, &dx, &dy) & P_OUT_OF_MAP) continue; else if (OB_TYPE_MOVE_BLOCK(ob, GET_MAP_MOVE_BLOCK(m, dx, dy))) continue; else break; } } else { dir = find_dir_2(ob->x - ob->owner->x, ob->y - ob->owner->y); } ob->direction = dir; tag = ob->count; /* move_ob returns 0 if the object couldn't move. If that is the * case, lets do some other work. */ if (!(move_ob(ob, dir, ob))) { object *part; /* the failed move_ob above may destroy the pet, so check here */ if (was_destroyed(ob, tag)) return; for(part = ob; part != NULL; part = part->more) { dx = part->x + freearr_x[dir]; dy = part->y + freearr_y[dir]; m = get_map_from_coord(part->map, &dx, &dy); if (!m) continue; for (ob2 = get_map_ob(m, dx, dy); ob2 != NULL; ob2 = ob2->above) { object *new_ob; new_ob = ob2->head?ob2->head:ob2; if(new_ob == ob) break; if (new_ob == ob->owner) return; if (get_owner(new_ob) == ob->owner) break; /* Hmm. Did we try to move into an enemy monster? If so, * make it our enemy. */ if (QUERY_FLAG(new_ob,FLAG_ALIVE) && !QUERY_FLAG(ob,FLAG_UNAGGRESSIVE) && !QUERY_FLAG(new_ob,FLAG_UNAGGRESSIVE) && !QUERY_FLAG(new_ob,FLAG_FRIENDLY)) { ob->enemy = new_ob; if(new_ob->enemy == NULL) new_ob->enemy = ob; return; } else if (new_ob->type == PLAYER) { new_draw_info(NDI_UNIQUE, 0,new_ob, "You stand in the way of someones pet."); return; } } } /* Try a different course */ dir = absdir(dir + 4 - (RANDOM() %5) - (RANDOM()%5)); (void) move_ob(ob, dir, ob); } return; } /**************************************************************************** * * GOLEM SPELL CODE * ****************************************************************************/ /* fix_summon_pet() - this makes multisquare/single square monsters * proper for map insertion. * at is the archetype, op is the caster of the spell, dir is the * direction the monster should be placed in. * is_golem is to note that this is a golem spell. */ object *fix_summon_pet(archetype *at, object *op, int dir, int is_golem ) { archetype *atmp; object *tmp=NULL, *prev=NULL, *head=NULL; for(atmp = at; atmp!=NULL; atmp = atmp->more) { tmp = arch_to_object(atmp); if (atmp == at) { if(!is_golem) SET_FLAG(tmp, FLAG_MONSTER); set_owner(tmp, op); if (op->type == PLAYER) { tmp->stats.exp = 0; add_friendly_object(tmp); SET_FLAG(tmp, FLAG_FRIENDLY); if(is_golem) CLEAR_FLAG(tmp, FLAG_MONSTER); } else { if(QUERY_FLAG(op, FLAG_FRIENDLY)) { object *owner = get_owner(op); if(owner != NULL) {/* For now, we transfer ownership */ set_owner(tmp,owner); tmp->attack_movement = PETMOVE; add_friendly_object(tmp); SET_FLAG(tmp, FLAG_FRIENDLY); } } } if(op->type!=PLAYER || !is_golem) { tmp->attack_movement = PETMOVE; tmp->speed_left = -1; tmp->type = 0; tmp->enemy = op->enemy; } else tmp->type = GOLEM; } if(head == NULL) head = tmp; tmp->x = op->x + freearr_x[dir] + tmp->arch->clone.x; tmp->y = op->y + freearr_y[dir] + tmp->arch->clone.y; tmp->map = op->map; if(tmp->invisible) tmp->invisible=0; if(head != tmp) tmp->head = head, prev->more = tmp; prev = tmp; } head->direction = dir; /* need to change some monster attr to prevent problems/crashing */ head->last_heal=0; head->last_eat=0; head->last_grace=0; head->last_sp=0; head->other_arch=NULL; head->stats.exp = 0; CLEAR_FLAG(head,FLAG_CHANGING); CLEAR_FLAG(head,FLAG_STAND_STILL); CLEAR_FLAG(head,FLAG_GENERATOR); CLEAR_FLAG(head,FLAG_SPLITTING); if(head->attacktype&AT_GHOSTHIT) head->attacktype=(AT_PHYSICAL|AT_DRAIN); return head; } /* updated this to allow more than the golem 'head' to attack */ /* op is the golem to be moved. */ void move_golem(object *op) { int made_attack=0; object *tmp; tag_t tag; if(QUERY_FLAG(op, FLAG_MONSTER)) return; /* Has already been moved */ if(get_owner(op)==NULL) { LOG(llevDebug,"Golem without owner destructed.\n"); remove_ob(op); free_object(op); return; } /* It would be nice to have a cleaner way of what message to print * when the golem expires than these hard coded entries. * Note it is intentional that a golems duration is based on its * hp, and not duration */ if(--op->stats.hp<0) { if (op->msg) new_draw_info(NDI_UNIQUE, 0,op->owner,op->msg); op->owner->contr->ranges[range_golem]=NULL; op->owner->contr->golem_count = 0; remove_friendly_object(op); remove_ob(op); free_object(op); return; } /* Do golem attacks/movement for single & multisq golems. * Assuming here that op is the 'head' object. Pass only op to * move_ob (makes recursive calls to other parts) * move_ob returns 0 if the creature was not able to move. */ tag = op->count; if(move_ob(op,op->direction,op)) return; if (was_destroyed (op, tag)) return; for(tmp=op;tmp;tmp=tmp->more) { sint16 x=tmp->x+freearr_x[op->direction],y=tmp->y+freearr_y[op->direction]; object *victim; mapstruct *m; int mflags; m = op->map; mflags = get_map_flags(m, &m, x, y, &x, &y); if (mflags & P_OUT_OF_MAP) continue; for(victim=get_map_ob(op->map,x,y);victim;victim=victim->above) if(QUERY_FLAG(victim,FLAG_ALIVE)) break; /* We used to call will_hit_self to make sure we don't * hit ourselves, but that didn't work, and I don't really * know if that was more efficient anyways than this. * This at least works. Note that victim->head can be NULL, * but since we are not trying to dereferance that pointer, * that isn't a problem. */ if(victim && victim!=op && victim->head!=op) { /* for golems with race fields, we don't attack * aligned races */ if(victim->race && op->race && strstr(op->race,victim->race)) { if(op->owner) new_draw_info_format(NDI_UNIQUE, 0,op->owner, "%s avoids damaging %s.",op->name,victim->name); } else if (victim == op->owner) { if(op->owner) new_draw_info_format(NDI_UNIQUE, 0,op->owner, "%s avoids damaging you.",op->name); } else { attack_ob(victim,op); made_attack=1; } } /* If victim */ } if(made_attack) update_object(op,UP_OBJ_FACE); } /* this is a really stupid function when you get down and * look at it. Keep it here for the time being - makes life * easier if we ever decide to do more interesting thing with * controlled golems. */ void control_golem(object *op,int dir) { op->direction=dir; } /* summon golem: summons a monster for 'op'. caster is the object * casting the spell, dir is the direction to place the monster, * at is the archetype of the monster, and spob is the spell * object. At this stage, all spob is really used for is to * adjust some values in the monster. */ int summon_golem(object *op,object *caster,int dir,object *spob) { object *tmp, *god=NULL; archetype *at; char buf[MAX_BUF]; /* Because there can be different golem spells, player may want to * 'lose' their old golem. */ if(op->type==PLAYER && op->contr->ranges[range_golem]!=NULL && op->contr->golem_count == op->contr->ranges[range_golem]->count) { new_draw_info(NDI_UNIQUE, 0, op, "You dismiss your existing golem."); remove_ob(op->contr->ranges[range_golem]); free_object(op->contr->ranges[range_golem]); op->contr->ranges[range_golem]=NULL; op->contr->golem_count=-1; } if (spob->other_arch) at = spob->other_arch; else if (spob->race) { god = find_god(determine_god(caster)); if (!god) { new_draw_info_format(NDI_UNIQUE, 0,op,"You must worship a god to cast %s.", spob->name); return 0; } at = determine_holy_arch (god, spob->race); if (!at) { new_draw_info_format(NDI_UNIQUE, 0,op,"%s has no %s for you to call.", god->name,spob->race); return 0; } } else { LOG(llevError,"Spell %s lacks other_arch\n", spob->name); return 0; } if(!dir) dir=find_free_spot(NULL,op->map,op->x,op->y,1,SIZEOFFREE1+1); if ((dir==-1) || ob_blocked(&at->clone, op->map, op->x + freearr_x[dir], op->y + freearr_y[dir])) { new_draw_info(NDI_UNIQUE, 0,op,"There is something in the way."); return 0; } /* basically want to get proper map/coordinates for this object */ if(!(tmp=fix_summon_pet(at,op,dir,GOLEM))) { new_draw_info(NDI_UNIQUE, 0,op,"Your spell fails."); return 0; } if(op->type==PLAYER) { tmp->type=GOLEM; set_owner(tmp,op); set_spell_skill(op, caster, spob, tmp); op->contr->ranges[range_golem]=tmp; op->contr->golem_count = tmp->count; /* give the player control of the golem */ op->contr->shoottype=range_golem; } else { if(QUERY_FLAG(op, FLAG_FRIENDLY)) { object *owner = get_owner(op); if (owner != NULL) { /* For now, we transfer ownership */ set_owner (tmp, owner); tmp->attack_movement = PETMOVE; add_friendly_object (tmp); SET_FLAG (tmp, FLAG_FRIENDLY); } } SET_FLAG(tmp, FLAG_MONSTER); } /* make the speed positive.*/ tmp->speed = FABS(tmp->speed); /* This sets the level dependencies on dam and hp for monsters */ /* players can't cope with too strong summonings. */ /* but monsters can. reserve these for players. */ if(op->type==PLAYER) { tmp->stats.hp += spob->duration + SP_level_duration_adjust(caster,spob); if (!spob->stats.dam) tmp->stats.dam += SP_level_dam_adjust(caster,spob); else tmp->stats.dam= spob->stats.dam + SP_level_dam_adjust(caster,spob); tmp->speed += .02 * SP_level_range_adjust(caster,spob); tmp->speed = MIN(tmp->speed, 1.0); if (spob->attacktype) tmp->attacktype = spob->attacktype; } tmp->stats.wc -= SP_level_range_adjust(caster,spob); /* limit the speed to 0.3 for non-players, 1 for players. */ /* make experience increase in proportion to the strength. * this is a bit simplistic - we are basically just looking at how * often the sp doubles and use that as the ratio. */ tmp->stats.exp *= 1 + (MAX(spob->stats.maxgrace, spob->stats.sp) / caster_level(caster, spob)); tmp->speed_left= 0; tmp->direction=dir; /* Holy spell - some additional tailoring */ if (god) { object *tmp2; sprintf(buf,"%s of %s",spob->name,god->name); buf[0] = toupper(buf[0]); for (tmp2=tmp; tmp2; tmp2=tmp2->more) { if (tmp2->name) free_string(tmp2->name); tmp2->name = add_string(buf); } tmp->attacktype |= god->attacktype; memcpy(tmp->resist, god->resist, sizeof(tmp->resist)); if (tmp->race) FREE_AND_CLEAR_STR(tmp->race); if (god->race) tmp->race = add_string(god->race); if (tmp->slaying) FREE_AND_CLEAR_STR(tmp->slaying); if (god->slaying) tmp->slaying = add_string(god->slaying); /* safety, we must allow a god's servants some reasonable attack */ if(!(tmp->attacktype&AT_PHYSICAL)) tmp->attacktype|=AT_PHYSICAL; } insert_ob_in_map(tmp,tmp->map,op,0); return 1; } /*************************************************************************** * * Summon monster/pet/other object code * ***************************************************************************/ /* Returns a monster (chosen at random) that this particular player (and his * god) find acceptable. This checks level, races allowed by god, etc * to determine what is acceptable. * This returns NULL if no match was found. */ object *choose_cult_monster(object *pl, object *god, int summon_level) { char buf[MAX_BUF]; const char *race; int racenr, mon_nr,i; racelink *list; objectlink *tobl; object *otmp; /* Determine the number of races available */ racenr=0; strcpy(buf,god->race); race = strtok(buf,","); while(race) { racenr++; race = strtok(NULL,","); } /* next, randomly select a race from the aligned_races string */ if(racenr>1) { racenr = rndm(0, racenr-1); strcpy(buf,god->race); race = strtok(buf,","); for(i=0;irace; /* see if a we can match a race list of monsters. This should not * happen, so graceful recovery isn't really needed, but this sanity * checking is good for cases where the god archetypes mismatch the * race file */ if((list=find_racelink(race))==NULL) { new_draw_info_format(NDI_UNIQUE, 0,pl, "The spell fails! %s's creatures are beyond the range of your summons", god->name); LOG(llevDebug,"choose_cult_monster() requested non-existent aligned race!\n"); return 0; } /* search for an apprplritate monster on this race list */ mon_nr=0; for(tobl=list->member;tobl;tobl=tobl->next) { otmp=tobl->ob; if(!otmp||!QUERY_FLAG(otmp,FLAG_MONSTER)) continue; if(otmp->level<=summon_level) mon_nr++; } /* If this god has multiple race entries, we should really choose another. * But then we either need to track which ones we have tried, or just * make so many calls to this function, and if we get so many without * a valid entry, assuming nothing is available and quit. */ if (!mon_nr) return NULL; mon_nr = rndm(0, mon_nr-1); for(tobl=list->member;tobl;tobl=tobl->next) { otmp=tobl->ob; if(!otmp||!QUERY_FLAG(otmp,FLAG_MONSTER)) continue; if(otmp->level<=summon_level && !mon_nr--) return otmp; } /* This should not happen */ LOG(llevDebug,"choose_cult_monster() mon_nr was set, but did not find a monster\n"); return NULL; } int summon_object(object *op, object *caster, object *spell_ob, int dir, const char *stringarg) { sint16 x,y, nrof=1, i; archetype *summon_arch; int ndir; if (spell_ob->other_arch) { summon_arch = spell_ob->other_arch; } else if (spell_ob->randomitems) { int level = caster_level(caster, spell_ob); treasure *tr, *lasttr=NULL;; /* In old code, this was a very convuluted for statement, * with all the checks in the 'for' portion itself. Much * more readable to break some of the conditions out. */ for (tr=spell_ob->randomitems->items; tr; tr=tr->next) { if (level < tr->magic) break; lasttr = tr; if(stringarg && !strcmp(tr->item->name,stringarg)) break; if (tr->next == NULL || tr->next->item == NULL) break; } if (!lasttr) { LOG(llevError,"Treasurelist %s did not generate a valid entry in summon_object\n", spell_ob->randomitems->name); new_draw_info(NDI_UNIQUE, 0, op, "The spell fails to summon any monsters."); return 0; } summon_arch = lasttr->item; nrof = lasttr->nrof; } else if (spell_ob->race && !strcmp(spell_ob->race,"GODCULTMON")) { object *god=find_god(determine_god(op)), *mon, *owner; int summon_level, tries; if (!god && ((owner=get_owner(op))!=NULL)) { god = find_god(determine_god(owner)); } /* If we can't find a god, can't get what monster to summon */ if (!god) return 0; if (!god->race) { new_draw_info_format(NDI_UNIQUE, 0,op, "%s has no creatures that you may summon!",god->name); return 0; } /* the summon level */ summon_level=caster_level(caster, spell_ob); if (summon_level==0) summon_level=1; tries = 0; do { mon = choose_cult_monster(op, god,summon_level); if (!mon) { new_draw_info_format(NDI_UNIQUE, 0,op, "%s fails to send anything.",god->name); return 0; } ndir = dir; if (!ndir) ndir = find_free_spot(mon, op->map, op->x, op->y, 1, SIZEOFFREE); if (ndir == -1 || ob_blocked(mon,op->map, op->x + freearr_x[ndir], op->y+freearr_y[ndir])) { ndir=-1; if (++tries == 5) { new_draw_info(NDI_UNIQUE, 0,op, "There is something in the way."); return 0; } } } while (ndir == -1); if (mon->level > (summon_level/2)) nrof = random_roll(1, 2, op, PREFER_HIGH); else nrof = die_roll(2, 2, op, PREFER_HIGH); summon_arch = mon->arch; } else { summon_arch = NULL; } if (spell_ob->stats.dam) nrof += spell_ob->stats.dam + SP_level_dam_adjust(caster, spell_ob); if (!summon_arch) { new_draw_info(NDI_UNIQUE, 0, op, "There is no monsters available for summoning."); return 0; } for (i=1; i <= nrof; i++) { archetype *atmp; object *prev=NULL, *head=NULL, *tmp; if (dir) { ndir = dir; dir = absdir (dir+1); } else ndir = find_free_spot(&summon_arch->clone, op->map, op->x, op->y, 1, SIZEOFFREE); if (ndir > 0) { x = freearr_x[ndir]; y = freearr_y[ndir]; } if (ndir == -1 || ob_blocked(&summon_arch->clone, op->map, op->x + x, op->y + y)){ new_draw_info(NDI_UNIQUE, 0, op, "There is something in the way."); if (nrof > 1) new_draw_info(NDI_UNIQUE, 0,op, "No more pets for this casting."); return nrof > 1; } for (atmp = summon_arch; atmp!=NULL; atmp=atmp->more) { tmp = arch_to_object(atmp); if (atmp == summon_arch) { if (QUERY_FLAG(tmp, FLAG_MONSTER)) { set_owner(tmp, op); set_spell_skill(op, caster, spell_ob, tmp); tmp->enemy = op->enemy; tmp->type = 0; CLEAR_FLAG(tmp, FLAG_SLEEP); if (op->type == PLAYER || QUERY_FLAG(op, FLAG_FRIENDLY)) { /* If this is not set, we make it friendly */ if (!QUERY_FLAG(spell_ob, FLAG_MONSTER)) { SET_FLAG(tmp, FLAG_FRIENDLY); add_friendly_object(tmp); tmp->stats.exp = 0; if (spell_ob->attack_movement) tmp->attack_movement = spell_ob->attack_movement; if (get_owner(op)) set_owner(tmp, get_owner(op)); } } } if (tmp->speed > MIN_ACTIVE_SPEED) tmp->speed_left = -1; } if (head == NULL) head = tmp; else { tmp->head = head; prev->more = tmp; } prev = tmp; tmp->x = op->x + x + tmp->arch->clone.x; tmp->y = op->y + y + tmp->arch->clone.y; tmp->map = op->map; } head->direction = freedir[ndir]; head->stats.exp = 0; head = insert_ob_in_map(head, head->map, op, 0); if (head && head->randomitems) { object *tmp; create_treasure(head->randomitems, head, GT_APPLY | GT_STARTEQUIP, 6, 0); for (tmp=head->inv; tmp; tmp=tmp->below) if (!tmp->nrof) SET_FLAG(tmp, FLAG_NO_DROP); } } /* for i < nrof */ return 1; } /* recursively look through the owner property of objects until the real owner is found */ object *get_real_owner(object *ob) { object *realowner = ob; if (realowner == NULL) return NULL; while(get_owner(realowner) != NULL) { realowner = get_owner(realowner); } return realowner; } /* determines if checks so pets don't attack players or other pets should be overruled by the arena petmode */ int should_arena_attack(object *pet,object *owner,object *target) { object *rowner, *towner; /* exit if the target, pet, or owner is null. */ if ((target == NULL) || (pet == NULL) || (owner == NULL)) return 0; /* get the owners of itself and the target, this is to deal with pets of pets */ rowner = get_real_owner(owner); if (target->type != PLAYER) { towner = get_real_owner(target); } else { towner = 0; } /* if the pet has now owner, exit with error */ if (rowner == NULL) { LOG(llevError,"Pet has no owner.\n"); return 0; } /* if the target is not a player, and has no owner, we shouldn't be here */ if ((towner == NULL) && (target->type != PLAYER)) { LOG(llevError,"Target is not a player but has no owner. We should not be here.\n"); return 0; } /* make sure that the owner is a player */ if (rowner->type != PLAYER) return 0; /* abort if the petmode is not arena */ if (rowner->contr->petmode != pet_arena) return 0; /* abort if the pet, it's owner, or the target is not on battleground*/ if (!(op_on_battleground(pet, NULL, NULL) && op_on_battleground(owner, NULL, NULL) && op_on_battleground(target, NULL, NULL))) return 0; /* if the target is a monster, make sure it's owner is not the same */ if ((target->type != PLAYER) && (rowner == towner)) return 0; /* check if the target is a player which affects how it will handle parties */ if (target->type != PLAYER) { /* if the target is owned by a player make sure than make sure it's not in the same party */ if ((towner->type == PLAYER) && (rowner->contr->party != NULL)) { if (rowner->contr->party == towner->contr->party) return 0; } } else { /* if the target is a player make sure than make sure it's not in the same party */ if (rowner->contr->party != NULL){ if (rowner->contr->party == target->contr->party) return 0; } } return 1; }