games-request@tekred.TEK.COM (01/21/88)
Submitted by: "Laurence R. Brothers" <brothers@paul.rutgers.edu>
Comp.sources.games: Volume 3, Issue 61
Archive-name: omega/Part14
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 14 (of 15)."
# Contents: oeffect2.c ogen.c oscroll2.txt
# Wrapped by billr@tekred on Mon Jan 18 10:20:48 1988
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f oeffect2.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"oeffect2.c\"
else
echo shar: Extracting \"oeffect2.c\" \(27353 characters\)
sed "s/^X//" >oeffect2.c <<'END_OF_oeffect2.c'
X/* omega copyright (C) by Laurence Raphael Brothers, 1987 */
X/* oeffect2.c */
X
X#include <strings.h>
X#include "oglob.h"
X
X
X/* from oaux */
Xextern void setspot(),levelchange(),gain_experience();
Xextern void calc_melee(),p_death(),darkenroom(),lightroom();
Xextern void p_damage(),hour_status_check();
Xextern int p_immune();
Xextern char *spellid();
X
X/* from oinv */
Xextern void drop_at(),pickup_at(),add_item_to_pack();
Xextern int getitem();
Xextern char *itemid();
X
X/* from oitem */
Xextern int i_nothing();
Xextern void make_potion(), make_scroll(), make_ring(), make_stick();
Xextern void make_armor(), make_shield(), make_weapon(), make_boots();
Xextern void make_cloak(),make_food(),make_artifact(),make_thing();
Xextern void item_use();
X
X/* from omovef */
Xextern void p_movefunction();
X
X
X/* from omon */
Xextern void m_damage(),m_status_set(),m_status_reset(),m_death();
Xextern struct monster *make_creature(),*m_create();
Xextern int m_immunityp();
X
X/* from outil */
Xextern int random_range(),inbounds(),hitp(),cursed();
Xextern void do_los(),findspace();
X
X
X/* from ogen */
Xextern void clear_level(),create_level();
X
X/* from oscr */
Xextern void mprint(),printm(),morewait(),drawvision();
Xextern void draw_explosion(),erase_level(),plotmon(),menuprintitem();
Xextern void levelrefresh(),menuclear(),menumorewait(),showflags();
Xextern void show_screen(),putspot(),menuprint();
Xextern void clearmsg(),xredraw();
Xextern char mgetc();
X
X/* from oeffect1 */
Xextern void heal(),level_drain(),sleep_player();
X
X/* oeffect2 functions */
Xvoid knowledge(),flux(),displace(),breathe(),invisible(),warp(),alert();
Xvoid haste(),regenerate(),recover_stat(),augment(),truesight();
Xvoid i_chaos(),i_law(),sanctify(),hero(),level_return(),cure(),dispel();
Xvoid polymorph(),hellfire(),illuminate();
X
X
X
Xvoid knowledge(blessing)
Xint blessing;
X{
X if (blessing < 0)
X mprint("You feel ignorant.");
X else {
X mprint("You feel knowledgeable!");
X menuclear();
X menuprint("Alignment:\n");
X if (Player.alignment == 0)
X menuprint("Neutral: embodying the Cosmic Balance");
X else if (abs(Player.alignment) < 5)
X menuprint("Neutral, tending toward ");
X else if (abs(Player.alignment) < 20)
X menuprint("Neutral-");
X else if (abs(Player.alignment) > 100)
X menuprint("The essence of ");
X else if (abs(Player.alignment) > 200)
X menuprint("The Ultimate Avatar of ");
X if (Player.alignment < 0) menuprint("Chaos\n");
X else if (Player.alignment > 0) menuprint("Law\n");
X menumorewait();
X menuclear();
X menuprint("Current stati:\n");
X if (Player.status[BLINDED])
X menuprint("Blinded\n");
X if (Player.status[SLOWED])
X menuprint("Slowed\n");
X if (Player.status[HASTED])
X menuprint("Hasted\n");
X if (Player.status[DISPLACED])
X menuprint("Displaced\n");
X if (Player.status[SLEPT])
X menuprint("Slept\n");
X if (Player.status[DISEASED])
X menuprint("Diseased\n");
X if (Player.status[POISONED])
X menuprint("Poisoned\n");
X if (Player.status[BREATHING])
X menuprint("Breathing\n");
X if (Player.status[INVISIBLE])
X menuprint("Invisible\n");
X if (Player.status[REGENERATING])
X menuprint("Regenerating\n");
X if (Player.status[VULNERABLE])
X menuprint("Vulnerable\n");
X if (Player.status[BERSERK])
X menuprint("Berserk\n");
X if (Player.status[IMMOBILE])
X menuprint("Immobile\n");
X if (Player.status[ALERT])
X menuprint("Alert\n");
X if (Player.status[AFRAID])
X menuprint("Afraid\n");
X if (Player.status[ACCURATE])
X menuprint("Accurate\n");
X if (Player.status[HERO])
X menuprint("Heroic\n");
X if (Player.status[LEVITATING])
X menuprint("Levitating\n");
X menumorewait();
X menuclear();
X menuprint("Immunities:\n");
X if (p_immune(NORMAL_DAMAGE))
X menuprint("Normal Damage\n");
X if (p_immune(FLAME))
X menuprint("Flame\n");
X if (p_immune(ELECTRICITY))
X menuprint("Electricity\n");
X if (p_immune(COLD))
X menuprint("Cold\n");
X if (p_immune(POISON))
X menuprint("Poison\n");
X if (p_immune(ACID))
X menuprint("Acid\n");
X if (p_immune(FEAR))
X menuprint("Fear\n");
X if (p_immune(SLEEP))
X menuprint("Sleep\n");
X if (p_immune(NEGENERGY))
X menuprint("Negative Energies\n");
X if (p_immune(THEFT))
X menuprint("Theft\n");
X if (p_immune(GAZE))
X menuprint("Gaze\n");
X if (p_immune(INFECTION))
X menuprint("Infection\n");
X menumorewait();
X menuclear();
X menuprint("Ranks:\n");
X switch(Player.rank[LEGION]) {
X case COMMANDANT:
X menuprint("Commandant of the Legion.\n");
X break;
X case COLONEL:
X menuprint("Colonel of the Legion.\n");
X break;
X case FORCE_LEADER:
X menuprint("Force Leader of the Legion.\n");
X break;
X case CENTURION:
X menuprint("Centurion of the Legion.\n");
X break;
X case LEGIONAIRE:
X menuprint("Legionaire.\n");
X break;
X }
X switch(Player.rank[ARENA]) {
X case -1:
X menuprint("Ex-gladiator\n");
X case CHAMPION:
X menuprint("Gladiator Champion.\n");
X break;
X case GLADIATOR:
X menuprint("Gladiator of the Arena.\n");
X break;
X case RETIARIUS:
X menuprint("Retiarius of the Arena.\n");
X break;
X case BESTIARIUS:
X menuprint("Bestiarius of the Arena.\n");
X break;
X case TRAINEE:
X menuprint("Gladiator Trainee of the Arena.\n");
X break;
X }
X switch(Player.rank[COLLEGE]) {
X case ARCHMAGE:
X menuprint("Archmage of the Collegium Magii\n");
X break;
X case MAGE:
X menuprint("Collegium Magii: Mage\n");
X break;
X case PRECEPTOR:
X menuprint("Collegium Magii: Preceptor\n");
X break;
X case STUDENT:
X menuprint("Collegium Magii: Student\n");
X break;
X case NOVICE:
X menuprint("Collegium Magii: Novice\n");
X break;
X }
X switch(Player.rank[NOBILITY]) {
X case DUKE:
X menuprint("Duke of Rampart\n");
X break;
X case LORD:
X menuprint("Peer of the Realm\n");
X break;
X case KNIGHT:
X menuprint("Order of the Knights of Rampart\n");
X break;
X case ESQUIRE:
X menuprint("Squire of Rampart\n");
X break;
X case COMMONER:
X menuprint("Commoner\n");
X break;
X default:
X menuprint("Lowly Commoner\n");
X break;
X }
X switch(Player.rank[CIRCLE]) {
X case PRIME:
X menuprint("Prime Sorceror of the Inner Circle\n");
X break;
X case HIGHSORCEROR:
X menuprint("High Sorceror of the Inner Circle\n");
X break;
X case SORCEROR:
X menuprint("Member of the Circle of Sorcerors\n");
X break;
X case ENCHANTER:
X menuprint("Member of the Circle of Enchanters\n");
X break;
X case INITIATE:
X menuprint("Member of the Circle of Initiates\n");
X break;
X }
X switch(Player.rank[THIEVES]) {
X case SHADOWLORD:
X menuprint("Guild of Thieves: Shadowlord\n");
X break;
X case TMASTER:
X menuprint("Guild of Thieves: Master Thief\n");
X break;
X case THIEF:
X menuprint("Guild of Thieves: Thief\n");
X break;
X case ATHIEF:
X menuprint("Guild of Thieves: Apprentice Thief\n");
X break;
X case TMEMBER:
X menuprint("Guild of Thieves: Candidate Member\n");
X break;
X }
X switch(Player.rank[PRIESTHOOD]) {
X case LAY:
X menuprint("A lay devotee of ");
X break;
X case ACOLYTE:
X menuprint("An Acolyte of ");
X break;
X case PRIEST:
X menuprint("A Priest of ");
X break;
X case SPRIEST:
X menuprint("A Senior Priest of ");
X break;
X case HIGHPRIEST:
X menuprint("The High Priest of ");
X break;
X }
X switch(Player.patron) {
X case ODIN:
X menuprint("Odin.\n");
X break;
X case SET:
X menuprint("Set.\n");
X break;
X case ATHENA:
X menuprint("Athena.\n");
X break;
X case HECATE:
X menuprint("Hecate.\n");
X break;
X case DRUID:
X menuprint("Druidism.\n");
X break;
X case DESTINY:
X menuprint("the Lords of Destiny.\n");
X break;
X }
X if (Player.rank[ADEPT] > 0)
X menuprint("**************\n*Omegan Adept*\n**************\n");
X menumorewait();
X xredraw();
X }
X}
X
X
X/* Recreates the current level */
Xvoid flux(blessing)
Xint blessing;
X{
X mprint("The universe warps around you!");
X if (Dlevel == 0) {
X mprint("Sensing dangerous high order magic, the Collegium Magii");
X mprint("and the Circle of Sorcerors join forces to negate the spell.");
X mprint("You are zapped by an antimagic ray!!!");
X dispel(-1);
X mprint("The universe unwarps itself....");
X }
X else {
X mprint("You stagger as the very nature of reality warps!");
X erase_level();
X clear_level(Dlevel);
X mprint("The fabric of spacetime reknits....");
X create_level(Dlevel-1,Dlevel,'<');
X }
X}
X
X/*Turns on displacement status for the player */
Xvoid displace(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X mprint("You feel a sense of dislocation.");
X Player.status[DISPLACED] = blessing + random_range(6);
X }
X else {
X mprint("You feel vulnerable");
X Player.status[VULNERABLE] += random_range(6) - blessing;
X }
X}
X
X
X
Xvoid invisible(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X mprint("You feel transparent!");
X Player.status[INVISIBLE]+= 2+5*blessing;
X }
X else {
X mprint("You feel dangerous!");
X Player.status[VULNERABLE] +=
X random_range(10)+1;
X }
X}
X
X
Xvoid warp(blessing)
Xint blessing;
X{
X int newlevel,ok=FALSE;
X if (blessing > -1) {
X mprint("Warp to which level? ");
X newlevel = parsenum();
X if ((newlevel > NUMLEVELS-10) &&
X (newlevel < NUMLEVELS) &&
X (Player.patron != DESTINY))
X mprint("Some mysterious force alters your destination.");
X else ok = TRUE;
X }
X if (! ok) {
X do newlevel=random_range(NUMLEVELS+20)-10;
X while ((newlevel>NUMLEVELS-10) && (newlevel < NUMLEVELS));
X }
X mprint("You dematerialize...");
X levelchange(newlevel,Dungeon[Dlevel][Player.x][Player.y].locchar);
X if (newlevel > 0)
X mprint("You feel homesick.");
X}
X
Xvoid alert(blessing)
X int blessing;
X{
X if (blessing > -1) {
X mprint("You feel a sense of insomnia.");
X Player.status[ALERT]+= 4+(5*blessing);
X }
X else sleep_player(abs(blessing)+3);
X}
X
Xvoid regenerate(blessing)
Xint blessing;
X{
X if (blessing < 0)
X heal(blessing * 10);
X else {
X mprint("You feel abnormally healthy.");
X Player.status[REGENERATING] += (blessing+1)*50;
X }
X}
X
Xvoid haste(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X if (! Player.status[HASTED])
X mprint("The world slows down!");
X else mprint("Nothing much happens.");
X if (Player.status[SLOWED])
X Player.status[SLOWED] = 0;
X Player.status[HASTED] += (blessing*100)+random_range(250);
X }
X else {
X mprint("You feel slower.");
X if (Player.status[HASTED] > 0) mprint("...but the feeling quickly fades.");
X else
X Player.status[SLOWED] += random_range(250)+250;
X }
X}
X
X
Xvoid recover_stat(blessing)
Xint blessing;
X{
X if (blessing < 0) {
X mprint("You feel a cold surge!");
X switch(random_range(6)) {
X case 0: Player.str = min(Player.str-1,Player.maxstr-1); break;
X case 1: Player.con = min(Player.con-1,Player.maxcon-1); break;
X case 2: Player.dex = min(Player.dex-1,Player.maxdex-1); break;
X case 3: Player.agi = min(Player.agi-1,Player.maxagi-1); break;
X case 4: Player.iq = min(Player.iq-1,Player.maxiq-1); break;
X case 5: Player.pow = min(Player.pow-1,Player.maxpow-1); break;
X }
X }
X else {
X mprint("You feel a warm tingle!");
X Player.str = max(Player.str,Player.maxstr);
X Player.con = max(Player.con,Player.maxcon);
X Player.dex = max(Player.dex,Player.maxdex);
X Player.agi = max(Player.agi,Player.maxagi);
X Player.iq = max(Player.iq,Player.maxiq);
X Player.pow = max(Player.pow,Player.maxpow);
X }
X calc_melee();
X}
X
Xvoid augment(blessing)
Xint blessing;
X{
X if (blessing < 0) {
X mprint("You feel a cold surge!");
X switch(random_range(6)) {
X case 0: Player.str = min(Player.str-1,Player.maxstr-1); break;
X case 1: Player.con = min(Player.con-1,Player.maxcon-1); break;
X case 2: Player.dex = min(Player.dex-1,Player.maxdex-1); break;
X case 3: Player.agi = min(Player.agi-1,Player.maxagi-1); break;
X case 4: Player.iq = min(Player.iq-1,Player.maxiq-1); break;
X case 5: Player.pow = min(Player.pow-1,Player.maxpow-1); break;
X }
X }
X else if (blessing == 0) {
X mprint("You feel a warm tingle!");
X switch(random_range(6)) {
X case 0: Player.str = max(Player.str+1,Player.maxstr+1); break;
X case 1: Player.con = max(Player.con+1,Player.maxcon+1); break;
X case 2: Player.dex = max(Player.dex+1,Player.maxdex+1); break;
X case 3: Player.agi = max(Player.agi+1,Player.maxagi+1); break;
X case 4: Player.iq = max(Player.iq+1,Player.maxiq+1); break;
X case 5: Player.pow = max(Player.pow+1,Player.maxpow+1); break;
X }
X }
X else {
X mprint("You feel a hot flash!");
X Player.str = max(Player.str+1,Player.maxstr+1);
X Player.con = max(Player.con+1,Player.maxcon+1);
X Player.dex = max(Player.dex+1,Player.maxdex+1);
X Player.agi = max(Player.agi+1,Player.maxagi+1);
X Player.iq = max(Player.iq+1,Player.maxiq+1);
X Player.pow = max(Player.pow+1,Player.maxpow+1);
X }
X calc_melee();
X}
X
Xvoid breathe(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X mprint("Your breath is energized!");
X Player.status[BREATHING] += 6+blessing;
X }
X else {
X mprint("You choke as your lungs fill with water!");
X p_damage(50,UNSTOPPABLE,"drowning");
X }
X}
X
X
Xvoid i_chaos(o)
Xpob o;
X{
X if (Player.alignment < 0) {
X Player.alignment -= random_range(20);
X mprint("You feel deliciously chaotic!");
X gain_experience(abs(Player.alignment)*10);
X }
X else {
X mprint("You feel a sense of inner turmoil!");
X Player.alignment -= random_range(20);
X }
X}
X
Xvoid i_law(o)
Xpob o;
X{
X if (Player.alignment > 0) {
X Player.alignment += random_range(20);
X mprint("You feel wonderfully lawful!");
X gain_experience(Player.alignment*10);
X }
X else {
X mprint("You feel a sense of inner constraint!");
X Player.alignment += random_range(20);
X }
X}
X
Xvoid sanctify(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X if (Dungeon[Dlevel][Player.x][Player.y].locchar == ALTAR)
X mprint("This site can't get any holier!");
X else if (Player.patron == 0) {
X mprint("The gods are angered!");
X Dungeon[Dlevel][Player.x][Player.y].locchar = LAVA;
X Dungeon[Dlevel][Player.x][Player.y].p_locf = L_LAVA;
X p_movefunction(L_LAVA);
X }
X else {
X Dungeon[Dlevel][Player.x][Player.y].locchar = ALTAR;
X Dungeon[Dlevel][Player.x][Player.y].aux = Player.patron;
X Dungeon[Dlevel][Player.x][Player.y].p_locf = L_ALTAR;
X mprint("You are standing on sacred ground!");
X }
X }
X else {
X if (Dungeon[Dlevel][Player.x][Player.y].locchar == ALTAR) {
X mprint("The altar crumbles before your unholy blast....");
X Dungeon[Dlevel][Player.x][Player.y].locchar = FLOOR;
X Dungeon[Dlevel][Player.x][Player.y].p_locf = L_NO_OP;
X if (Dungeon[Dlevel][Player.x][Player.y].aux == Player.patron) {
X mprint("Your deity is not amused....");
X p_damage(Player.hp-1,UNSTOPPABLE,"Divine Wrath");
X }
X else if ((Player.patron == ATHENA) || (Player.patron == ODIN)) {
X if ((Dungeon[Dlevel][Player.x][Player.y].aux == SET) ||
X (Dungeon[Dlevel][Player.x][Player.y].aux == HECATE)) {
X mprint("Your deity applauds the eradication of Chaos' taint");
X gain_experience(1000);
X }
X else {
X mprint("Your deity approves of your action.");
X gain_experience(100);
X }
X }
X if ((Player.patron == SET) || (Player.patron == HECATE)) {
X if ((Dungeon[Dlevel][Player.x][Player.y].aux == ODIN) ||
X (Dungeon[Dlevel][Player.x][Player.y].aux == ATHENA)) {
X mprint("Your deity applauds the obliteration of Law");
X gain_experience(1000);
X }
X else {
X mprint("Your deity approves of your action.");
X gain_experience(100);
X }
X }
X else if (Player.patron == DRUID) {
X mprint("Your attempt to maintain the Balance is applauded....");
X gain_experience(250);
X }
X else mprint("Nothing much happens");
X }
X else mprint("You feel an aura of unholiness arising from this spot....");
X }
X}
X
Xvoid accuracy(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X mprint("Everything seems covered in bullseyes!");
X Player.status[ACCURACY] += random_range(5)+1+blessing*5;
X calc_melee();
X }
X else {
X Player.status[ACCURACY]=0;
X calc_melee();
X mprint("Your vision blurs...");
X }
X}
X
Xvoid hero(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X mprint("You feel super!");
X Player.status[HERO] += random_range(5)+1+blessing;
X calc_melee();
X }
X else {
X Player.status[HERO]=0;
X calc_melee();
X mprint("You feel cowardly.");
X level_drain(abs(blessing),"a potion of cowardice");
X }
X}
X
X
Xvoid levitate(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X mprint("You start to float a few inches above the floor.");
X mprint("You discover you can easily control your altitude...");
X Player.status[LEVITATING] += random_range(5)+1+blessing;
X }
X else mprint("Nothing much happens.");
X}
X
X
X/* has effect of switching between city and lowest level attained */
Xvoid level_return()
X{
X if (Dlevel > 0)
X levelchange(0,Dungeon[Dlevel][Player.x][Player.y].locchar);
X else levelchange(Deepest,Dungeon[Dlevel][Player.x][Player.y].locchar);
X}
X
X
Xvoid cure(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X if (Player.status[DISEASED]) {
X Player.status[DISEASED]=0;
X mprint("You feel hygienic!");
X }
X else mprint("Nothing much happens.");
X }
X else if (! Player.immunity[INFECTION]) {
X mprint("You feel tainted.");
X Player.status[DISEASED]+=random_range(10)+1;
X }
X else mprint("Nothing much happens.");
X showflags();
X}
X
X
Xvoid truesight(blessing)
Xint blessing;
X{
X if (blessing > -1) {
X Player.status[TRUESIGHT]+=random_range(10)+1;
X mprint("You feel sharp.");
X }
X else {
X Player.status[BLINDED]+=random_range(10)+1;
X mprint("You've been blinded!");
X }
X}
X
X
X
Xvoid dispel(blessing)
Xint blessing;
X{
X int i,x=Player.x,y=Player.y;
X if (blessing > -1) {
X setspot(&x,&y);
X if ((x==Player.x)&&(y==Player.y)) {
X for(i=0;i<MAXITEMS;i++) {
X if (Player.possessions[i]!=NULL)
X if ((Player.possessions[i]->used) &&
X (Player.possessions[i]->blessing < 0)) {
X if (blessing+1 + Player.possessions[i]->blessing >=0) {
X mprint("You hear a sighing sound from");
X mprint(itemid(Player.possessions[i]));
X Player.possessions[i]->blessing = 0;
X }
X else {
X mprint("You hear dark laughter from");
X mprint(itemid(Player.possessions[i]));
X }
X }
X }
X }
X else if (Dungeon[Dlevel][x][y].creature != NULL) {
X if (Dungeon[Dlevel][x][y].creature->level < blessing * 3) {
X Dungeon[Dlevel][x][y].creature->specialf = M_NO_OP;
X if (Dungeon[Dlevel][x][y].creature->meleef != M_NO_OP)
X Dungeon[Dlevel][x][y].creature->meleef = M_MELEE_NORMAL;
X Dungeon[Dlevel][x][y].creature->strikef = M_NO_OP;
X Dungeon[Dlevel][x][y].creature->immunity=0;
X m_status_reset(Dungeon[Dlevel][x][y].creature,M_INVISIBLE);
X m_status_reset(Dungeon[Dlevel][x][y].creature,INTANGIBLE);
X }
X else mprint("The monster ignores the effect!");
X }
X else if ((Dungeon[Dlevel][x][y].p_locf == L_TRAP_FIRE) ||
X (Dungeon[Dlevel][x][y].p_locf == L_STATUE_WAKE) ||
X (Dungeon[Dlevel][x][y].p_locf == L_TRAP_TELEPORT) ||
X (Dungeon[Dlevel][x][y].p_locf == L_TRAP_DISINTEGRATE)) {
X Dungeon[Dlevel][x][y].p_locf == L_NO_OP;
X if (Dungeon[Dlevel][x][y].locchar == TRAP)
X Dungeon[Dlevel][x][y].locchar = FLOOR;
X }
X else if (Dungeon[Dlevel][x][y].p_locf == L_MAGIC_POOL)
X Dungeon[Dlevel][x][y].p_locf = L_WATER;
X else mprint("Nothing much seems to happen.");
X }
X else {
X mprint("A smell of ozone and positive ions fills the air..");
X if (Player.status[ACCURACY] && (Player.status[ACCURACY] < 1000))
X Player.status[ACCURACY]=1;
X if (Player.status[DISPLACED]&&(Player.status[DISPLACED] < 1000))
X Player.status[DISPLACED]=1;
X if (Player.status[HASTED]&&(Player.status[HASTED] < 1000))
X Player.status[HASTED]=1;
X if (Player.status[BREATHING]&&(Player.status[BREATHING] < 1000))
X Player.status[BREATHING]=1;
X if (Player.status[INVISIBLE]&&(Player.status[INVISIBLE] < 1000))
X Player.status[INVISIBLE]=1;
X if (Player.status[REGENERATING]&&(Player.status[REGENERATING] < 1000))
X Player.status[REGENERATING]=1;
X if (Player.status[ALERT]&&(Player.status[ALERT] < 1000))
X Player.status[ALERT]=1;
X if (Player.status[HERO]&&(Player.status[HERO] < 1000))
X Player.status[HERO]=1;
X if (Player.status[LEVITATING]&&(Player.status[LEVITATING] < 1000))
X Player.status[LEVITATING]=1;
X if (Player.status[ACCURATE]&&(Player.status[ACCURATE] < 1000))
X Player.status[ACCURATE]=1;
X if (Player.status[TRUESIGHT]&&(Player.status[TRUESIGHT] < 1000))
X Player.status[TRUESIGHT]=1;
X hour_status_check();
X }
X}
X
X
Xvoid polymorph(blessing)
Xint blessing;
X{
X int i,x=Player.x,y=Player.y,newmonster;
X struct monster *m;
X setspot(&x,&y);
X if ((x==Player.x)&&(y==Player.y)) {
X mprint("You enjoy your new life as a");
X mprint(Monsters[random_range(NUMMONSTERS)].monstring);
X mprint("But your game is over....");
X p_death("polymorphing oneself");
X }
X else if ((m=Dungeon[Dlevel][x][y].creature) == NULL)
X mprint("Nothing happens.");
X else {
X if (m_immunityp(m,OTHER_MAGIC) || (m->level > random_range(12))) {
X strcpy(Str1,"The ");
X strcat(Str1,m->monstring);
X strcat(Str1," resists the change!");
X m_status_set(m,HOSTILE);
X }
X else {
X if (blessing < 0) {
X do newmonster = random_range(NUMMONSTERS);
X while ((newmonster == ML0+4) ||
X (newmonster == ML7+3) ||
X (Monsters[newmonster].level < m->level) ||
X (Monsters[newmonster].uniqueness != COMMON));
X }
X else {
X do newmonster = random_range(NUMMONSTERS);
X while ((newmonster == ML0+4) ||
X (newmonster == ML7+3) ||
X (Monsters[newmonster].uniqueness != COMMON));
X }
X *m = Monsters[newmonster];
X m_status_set(m,HOSTILE);
X }
X }
X}
X
X
X
X
Xvoid hellfire(x,y,blessing)
Xint x,y,blessing;
X{
X int i;
X struct monster *m;
X if ((x==Player.x)&&(y==Player.y)) {
X mprint("You have been completely annihilated. Congratulations.");
X p_death("hellfire");
X }
X else if ((m=Dungeon[Dlevel][x][y].creature) == NULL) {
X mprint("The gods are angry over your waste of power...");
X level_drain(5,"indiscriminate use of hellfire");
X }
X else {
X mprint("The monster writhes in the flames...");
X if (blessing < 0) {
X mprint("...and appears stronger.");
X morewait();
X mprint("Much stronger.");
X m->hp += 1000;
X m->hit +=20;
X m->dmg += 100;
X m->actions += 4;
X m_status_set(m,HOSTILE);
X }
X else {
X mprint("and is utterly annihilated. Only a greasy spot remains...");
X strcpy(m->corpsestr,"a greasy spot");
X m->corpsevalue = 0;
X m->possessions = NULL; /* it happens that that transformid is -1 */
X m_death(m);
X }
X }
X}
X
X
Xvoid drain(blessing)
Xint blessing;
X{
X int i,x=Player.x,y=Player.y;
X struct monster *m;
X setspot(&x,&y);
X mprint("You begin to drain energy...");
X if ((x==Player.x)&&(y==Player.y)) {
X mprint("You drain your own energy....");
X mprint("Uh, oh, positive feedback....");
X level_drain(Player.level,"self-vampirism");
X }
X else if ((m=Dungeon[Dlevel][x][y].creature) != NULL) {
X if ((blessing > -1) && (! m_immunityp(m,NEGENERGY))) {
X mprint("The monster seems weaker...");
X m_damage(m,NEGENERGY,m->level*m->level);
X m->hit -= m->level;
X m->dmg -= m->level*m->level;
X m->ac -= m->level;
X m->level--;
X mprint("You feel stronger...");
X gain_experience(m->level*5);
X Player.hp+=(m->level*m->level / 2);
X }
X else {
X mprint("The effect reverses itself!");
X mprint("The monster seems stronger...");
X m->hp+=Player.level*Player.level;
X m->hit += Player.level;
X m->dmg += Player.level*Player.level;
X m->ac += Player.level;
X m->level++;
X mprint("You feel weaker...");
X Player.mana = min(0,Player.level*Player.level);
X level_drain(m->level,"negative energy conflict.");
X }
X }
X else if (blessing < 1) {
X mprint("You seem to lose energy, instead of gaining it!");
X level_drain(3,"reversed energy drain");
X }
X else if (Dungeon[Dlevel][x][y].locchar == WHIRLWIND) {
X Dungeon[Dlevel][x][y].locchar = FLOOR;
X Dungeon[Dlevel][x][y].p_locf = L_NO_OP;
X if (p_immune(ELECTRICITY)) {
X mprint("You transform some electrical energy.");
X gain_experience(20);
X Player.hp += 20;
X Player.str++;
X Player.con++;
X }
X else {
X mprint("The storm's lightning zaps you as you try to drain it!");
X p_damage(40,UNSTOPPABLE,"an attempt to drain energy from a whirlwind");
X }
X }
X else if (Dungeon[Dlevel][x][y].locchar == ALTAR) {
X mprint("The altar collapses in on itself....");
X Dungeon[Dlevel][x][y].locchar = ABYSS;
X Dungeon[Dlevel][x][y].p_locf = L_ABYSS;
X if (! Player.patron) {
X mprint("You drain some theurgic energy from the altar....");
X gain_experience(40);
X Player.hp += 20;
X Player.pow+=2;
X }
X if (Dungeon[Dlevel][x][y].aux == Player.patron) {
X mprint("Your deity is enraged.");
X mprint("You are struck by godsfire.");
X p_damage(Player.hp-1,UNSTOPPABLE,"godsfire");
X mprint("You feel atheistic.");
X Player.patron = -1;
X Player.rank[PRIESTHOOD] = 0;
X }
X else {
X mprint("You feel the wrath of a god....");
X p_damage(random_range(Player.level*10),UNSTOPPABLE,"divine wrath");
X mprint("Your deity doesn't seem to mind your action, though.");
X gain_experience(100);
X }
X }
X else {
X mprint("You drain some energy from the ambient megaflow.");
X Player.hp++;
X }
X}
X
Xvoid sanctuary()
X{
X mprint("You're standing on sacred ground!");
X Player.sx = Player.x;
X Player.sy = Player.y;
X Player.slevel = Dlevel;
X}
X
Xvoid invulnerable()
X{
X int i;
X mprint("You feel invincible.");
X for(i=0;i<NUMIMMUNITIES;i++)
X Player.immunity[i]+=20;
X}
X
Xvoid shadowform()
X{
X int i;
X if (Dlevel == NUMLEVELS-1)
X mprint("Some force seems to block the operation of the effect!");
X mprint("You feel like a shadow.");
X Player.immunity[NORMAL_DAMAGE]++;
X Player.immunity[ACID]++;
X Player.immunity[THEFT]++;
X Player.immunity[INFECTION]++;
X Player.status[SHADOWFORM]+=Player.level;
X}
X
Xvoid illuminate(blessing)
Xint blessing;
X{
X int r;
X if (blessing > -1) {
X if (r =Dungeon[Dlevel][Player.x][Player.y].roomnumber > 0) {
X if (Leveldata[Dlevel].rooms[r].lighted)
X mprint("Nothing much happens.");
X else {
X mprint("The room lights up!");
X Leveldata[Dlevel].rooms[r].lighted = TRUE;
X lightroom(r);
X }
X }
X else mprint("You see a faint glimmer of light which quickly fades.");
X }
X else {
X if (r = Dungeon[Dlevel][Player.x][Player.y].roomnumber > 0) {
X if (! Leveldata[Dlevel].rooms[r].lighted)
X mprint("Nothing much happens.");
X else {
X mprint("The room darkens!");
X Leveldata[Dlevel].rooms[r].lighted = FALSE;
X darkenroom(r);
X }
X }
X else mprint("The gloom thickens for a moment.");
X }
X}
END_OF_oeffect2.c
if test 27353 -ne `wc -c <oeffect2.c`; then
echo shar: \"oeffect2.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f ogen.c -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"ogen.c\"
else
echo shar: Extracting \"ogen.c\" \(25352 characters\)
sed "s/^X//" >ogen.c <<'END_OF_ogen.c'
X/* omega copyright (c) 1987 by Laurence Raphael Brothers */
X/* ogen.c */
X/* level generator functions */
X
X#include <stdio.h>
X#include "oglob.h"
X
X
X/* from outil */
Xextern int random_range(),inbounds(),sign();
X
X/* from olev */
Xextern void populate_level(),stock_level(),load_city();
Xextern pmt make_creature(),m_create(),make_hiscore_npc();
X
X/* from odepths */
Xextern void load_depths();
X
X/* from oitem */
Xextern pob make_weapon(),create_object();
X
X/* from omon */
Xextern void m_pickup();
X
X/* from oscr */
Xextern void erase_level(),locprint(),drawvision();
X
Xvoid clear_level(),create_level(),graph_wheel(),build_wheel(),wheel_level();
Xvoid connect_room(),corridor_crawl(),build_room(),roomcenter();
Xvoid clear_dungeon(),init_dungeon(),install_traps(),straggle_corridor();
Xvoid room_connect_corridor(),make_central_room(),make_spoke_room();
Xvoid change_level(),cavern_level(),makedoor(),grid_level();
Xvoid install_specials(),make_stairs(),pond_level(),room_level();
X
Xint connected();
Xchar *roomname();
X
Xvoid init_dungeon()
X{
X clear_level(0);
X Dlevel = 0;
X erase_level();
X load_city();
X locprint("The City of Rampart.");
X}
X
Xvoid clear_dungeon()
X{
X int i;
X for(i=0;i<NUMLEVELS;i++) {
X Leveldata[i].generated = FALSE;
X Leveldata[i].tunnelled = 0;
X clear_level(i);
X }
X}
X
X/* erase the level */
Xvoid clear_level(level)
Xint level;
X{
X int i,j;
X Mlist[level] = NULL;
X for(i=0;i<WIDTH;i++)
X for(j=0;j<LENGTH;j++) {
X Dungeon[level][i][j].locchar = WALL;
X Dungeon[level][i][j].showchar = ' ';
X Dungeon[level][i][j].creature = NULL;
X Dungeon[level][i][j].things = NULL;
X Dungeon[level][i][j].stopsrun = FALSE;
X Dungeon[level][i][j].aux = level*2; /* toughness of the rock */
X Dungeon[level][i][j].p_locf = L_NO_OP;
X Dungeon[level][i][j].seen = FALSE;
X Dungeon[level][i][j].secret = FALSE;
X Dungeon[level][i][j].roomnumber = RS_WALLSPACE;
X }
X}
X
Xvoid create_level(fromlevel,tolevel,sitechar)
Xint fromlevel,tolevel;
Xchar sitechar;
X{
X clear_level(tolevel);
X if (tolevel == 5) cavern_level(tolevel,1);
X else if (tolevel == 18) pond_level(tolevel,1);
X else if (tolevel == 27) pond_level(tolevel,2);
X else if (tolevel == 33) cavern_level(tolevel,2);
X else if (tolevel == 34) room_level(tolevel,1);
X else if (tolevel == 35) room_level(tolevel,2);
X else if (tolevel == 36) room_level(tolevel,3);
X else if (tolevel == 37) room_level(tolevel,4);
X else if (tolevel == 38) room_level(tolevel,5);
X else if (tolevel == NUMLEVELS-1) load_depths();
X else switch(random_range(20)) {
X case 0:
X case 1:
X case 2:
X case 3:
X case 4: cavern_level(tolevel,FALSE); break;
X case 5:
X case 6:
X case 7: grid_level(tolevel); break;
X case 8:
X case 9:
X case 10:
X case 11:
X case 12: room_level(tolevel,FALSE); break;
X case 13:
X case 14: pond_level(tolevel,FALSE); break;
X default: wheel_level(tolevel); break;
X }
X install_traps(tolevel);
X install_specials(tolevel);
X if (tolevel != NUMLEVELS-1) make_stairs(fromlevel,tolevel,sitechar);
X}
X
X
Xvoid wheel_level(level)
Xint level;
X{
X int i,j;
X
X Leveldata[level].numrooms = 21;
X
X for (i=0;i<Leveldata[level].numrooms;i++) {
X Leveldata[level].rooms[i].rsi = random_range(NUMROOMNAMES)+ROOMBASE;
X Leveldata[level].rooms[i].numconnections = 0;
X for (j=0;j<MAXCONNECTIONS;j++)
X Leveldata[level].rooms[i].connections[j] = -1;
X }
X
X graph_wheel(level);
X build_wheel(level);
X
X populate_level(level,-1);
X stock_level(level);
X}
X
X
X
X
X/* designate room 0 focus; all rooms must be connected eventually to
X room 0. */
Xvoid graph_wheel(level)
Xint level;
X{
X int i;
X
X connect_room(0,Leveldata[level].numrooms-1,level);
X
X for (i=1;i<Leveldata[level].numrooms-1;i++)
X if (random_range(2) == 1)
X connect_room(i,0,level);
X
X for (i=1;i<Leveldata[level].numrooms-1;i++)
X if (! connected(i,0,level))
X connect_room(i,i+1,level);
X}
X
X
Xvoid build_wheel(level)
Xint level;
X{
X int i,j,fx,fy,tx,ty;
X
X make_central_room(level);
X build_room(0,level);
X
X for (i=1;i<Leveldata[level].numrooms;i++) {
X make_spoke_room(i,level);
X build_room(i,level);
X }
X
X for (i=0;i<Leveldata[level].numrooms;i++)
X for (j=0;j<Leveldata[level].rooms[i].numconnections;j++)
X room_connect_corridor(i,Leveldata[level].rooms[i].connections[j],level);
X}
X
X
X
X
Xvoid make_central_room(level)
Xint level;
X{
X Leveldata[level].rooms[0].left = ((int) (WIDTH/2)) - 6;
X Leveldata[level].rooms[0].right = Leveldata[level].rooms[0].left+12;
X Leveldata[level].rooms[0].top = ((int) (LENGTH/2)) - 4;
X Leveldata[level].rooms[0].bottom = Leveldata[level].rooms[0].top+4;
X}
X
X
X
X
Xvoid make_spoke_room(room,level)
Xint room,level;
X{
X int t,b,l,r;
X
X switch (room-1) {
X
X case 0: l = 2; t = 1; break;
X case 1: l = 18; t = 1; break;
X case 2: l = 33; t = 1; break;
X case 3: l = 48; t = 1; break;
X
X case 4: l = 48; t = 9; break;
X case 5: l = 48; t = 17; break;
X
X case 6: l = 48; t = 57; break;
X case 7: l = 18; t = 57; break;
X case 8: l = 33; t = 57; break;
X case 9: l = 2; t = 57; break;
X
X case 10: l = 2; t = 25; break;
X case 11: l = 2; t = 33; break;
X case 12: l = 2; t = 41; break;
X case 13: l = 2; t = 49; break;
X
X case 14: l = 48; t = 25; break;
X case 15: l = 48; t = 33; break;
X case 16: l = 48; t = 41; break;
X case 17: l = 48; t = 49; break;
X
X case 18: l = 2; t = 9; break;
X case 19: l = 2; t = 17; break;
X
X }
X
X r = l + random_range(11)+4;
X b = t + random_range(4)+3;
X
X Leveldata[level].rooms[room].top = t;
X Leveldata[level].rooms[room].bottom = b;
X Leveldata[level].rooms[room].left = l;
X Leveldata[level].rooms[room].right = r;
X}
X
X
X/* actually change Dungeon */
X/* at moment, build rectangular rooms only */
Xvoid build_room(room,level)
Xint room,level;
X{
X int i,j;
X pml head,tml;
X
X Leveldata[level].rooms[room].lighted = (random_range(100) > level*2);
X
X for(i=Leveldata[level].rooms[room].left+1;
X i<=Leveldata[level].rooms[room].right-1;
X i++)
X for (j=Leveldata[level].rooms[room].top+1;
X j<=Leveldata[level].rooms[room].bottom-1;
X j++)
X Dungeon[level][i][j].locchar = FLOOR;
X for(i=Leveldata[level].rooms[room].left;
X i<=Leveldata[level].rooms[room].right;
X i++)
X for (j=Leveldata[level].rooms[room].top;
X j<=Leveldata[level].rooms[room].bottom;
X j++)
X Dungeon[level][i][j].roomnumber = room+ROOMBASE;
X
X /* party room */
X if ((random_range(1000) < 2*level) &&
X ((Leveldata[level].rooms[room].right -
X Leveldata[level].rooms[room].left) < 11) &&
X ((Leveldata[level].rooms[room].bottom -
X Leveldata[level].rooms[room].top) < 11)) {
X head = tml = ((pml) (malloc(sizeof(mltype))));
X for(i=Leveldata[level].rooms[room].left+1;
X i<=Leveldata[level].rooms[room].right-1;
X i++)
X for (j=Leveldata[level].rooms[room].top+1;
X j<=Leveldata[level].rooms[room].bottom-1;
X j++)
X if ((Dungeon[level][i][j].locchar == FLOOR) &&
X (Dungeon[level][i][j].creature == NULL)) {
X Dungeon[level][i][j].things = ((pol) malloc(sizeof(oltype)));
X Dungeon[level][i][j].things->thing = ((pob) create_object());
X Dungeon[level][i][j].things->next = NULL;
X
X Dungeon[level][i][j].creature = (pmt) m_create(i,j,WANDERING,Dlevel);
X Dungeon[level][i][j].creature->x = i;
X Dungeon[level][i][j].creature->y = j;
X
X tml->next = ((pml) malloc(sizeof(mltype)));
X tml->next->m = Dungeon[level][i][j].creature;
X tml=tml->next;
X }
X
X if (Mlist[level] == NULL) {
X Mlist[level] = head->next;
X tml->next = NULL;
X }
X else {
X tml->next = Mlist[level];
X Mlist[level] = head->next;
X }
X }
X}
X
X
X/* keep going in one orthogonal direction or another until we hit our */
X/* destination */
X
Xvoid straggle_corridor(fx,fy,tx,ty,level,loc)
Xint fx,fy,tx,ty,level;
Xchar loc;
X{
X int dx,dy;
X while ((fx != tx) || (fy != ty)) {
X dx = tx - fx;
X dy = ty - fy;
X if (random_range(abs(dx)+abs(dy)) < abs(dx))
X corridor_crawl(&fx,&fy,sign(dx),0,random_range(abs(dx))+1,level,loc);
X else corridor_crawl(&fx,&fy,0,sign(dy),random_range(abs(dy))+1,level,loc);
X }
X}
X
X/* now assumes rectangular rooms */
Xvoid room_connect_corridor(fromroom,toroom,level)
Xint fromroom,toroom,level;
X{
X int fx,fy,tx,ty,sx,sy,fromdoor=FALSE,todoor=FALSE;
X roomcenter(fromroom,&fx,&fy,level);
X roomcenter(toroom,&tx,&ty,level);
X while ((! todoor) && ((tx != fx) || (ty != fy))) {
X sx = sign(tx - fx);
X sy = sign(ty - fy);
X fx += sx;
X fy += sy;
X if ((! fromdoor) && (Dungeon[level][fx][fy].locchar == WALL)) {
X makedoor(fx,fy,level);
X fromdoor = TRUE;
X }
X else if ((! todoor) &&
X (Dungeon[level][fx][fy].roomnumber-ROOMBASE == toroom)) {
X makedoor(fx,fy,level);
X todoor = TRUE;
X }
X else {
X Dungeon[level][fx][fy].locchar = FLOOR;
X if(Dungeon[level][fx][fy].roomnumber < ROOMBASE)
X Dungeon[level][fx][fy].roomnumber = RS_CORRIDOR;
X }
X }
X}
X
X
Xvoid makedoor(x,y,level)
Xint x,y,level;
X{
X if (random_range(20) <= level/10) {
X Dungeon[level][x][y].locchar = FLOOR;
X Dungeon[level][x][y].secret = TRUE;
X }
X else if (random_range(20)<=level/2) {
X Dungeon[level][x][y].locchar = CLOSED_DOOR;
X if (random_range(20) <= level/10)
X Dungeon[level][x][y].secret = TRUE;
X if (random_range(40) <= level)
X Dungeon[level][x][y].aux = LOCKED;
X else Dungeon[level][x][y].aux = UNLOCKED;
X }
X else {
X Dungeon[level][x][y].locchar = OPEN_DOOR;
X Dungeon[level][x][y].aux = UNLOCKED;
X }
X if (! Dungeon[level][x][y].secret) {
X Dungeon[level][x][y+1].stopsrun = TRUE;
X Dungeon[level][x+1][y].stopsrun = TRUE;
X Dungeon[level][x-1][y].stopsrun = TRUE;
X Dungeon[level][x][y-1].stopsrun = TRUE;
X }
X}
X
X
Xvoid corridor_crawl(fx,fy,sx,sy,n,level,loc)
Xint *fx,*fy,sx,sy,n,level;
Xchar loc;
X{
X int i;
X for (i=0;i<n;i++) {
X *fx += sx;
X *fy += sy;
X Dungeon[level][*fx][*fy].locchar = loc;
X if (loc==WATER) {
X Dungeon[level][*fx][*fy].p_locf = L_WATER;
X if (Dungeon[level][*fx][*fy].roomnumber < ROOMBASE)
X Dungeon[level][*fx][*fy].roomnumber = RS_PONDS;
X }
X else if (loc==FLOOR) {
X Dungeon[level][*fx][*fy].p_locf = L_NO_OP;
X if (Dungeon[level][*fx][*fy].roomnumber < ROOMBASE)
X Dungeon[level][*fx][*fy].roomnumber = RS_CORRIDOR;
X }
X }
X}
X
X
X
X
X
Xchar *roomname(index)
Xint index;
X{
X switch(index) {
X case RS_DESTINY: return("The Halls of Fate");
X case RS_DRUID: return("The Great Henge");
X case RS_HECATE: return("The Church of the Far Side");
X case RS_SET: return("The Temple of the Black Hand");
X case RS_ATHENA: return("The Parthenon");
X case RS_ODIN: return("The Shrine of the Noose");
X case RS_ADEPT: return("Labyrinth of The Adept's Challenge."); break;
X case RS_WYRM: return("The Sunken Cavern of the Great Wyrm."); break;
X case RS_OCEAN: return("The Underground Ocean."); break;
X case RS_PONDS: return("A series of subterranean pools and streams.");
X case RS_DRAGONLORD: return("The Lair of the DragonLord."); break;
X case RS_GOBLINKING: return("The Caves of the Goblins."); break;
X case RS_CAVERN: return("A vast natural cavern."); break;
X case RS_CORRIDOR: return("A dimly lit corridor."); break;
X case RS_WALLSPACE: return("A niche hollowed out of the wall.");
X case ROOMBASE+0: return("An abandoned garderobe."); break;
X case ROOMBASE+1: return("A dungeon cell."); break;
X case ROOMBASE+2: return("A tiled chamber."); break;
X case ROOMBASE+3: return("A crystal cavern."); break;
X case ROOMBASE+4: return("Someone's bedroom."); break;
X case ROOMBASE+5: return("An old storeroom."); break;
X case ROOMBASE+6: return("A room with charred walls."); break;
X case ROOMBASE+7: return("A marble hall."); break;
X case ROOMBASE+8: return("An eerie cave."); break;
X case ROOMBASE+9: return("A ransacked treasure-chamber."); break;
X case ROOMBASE+10: return("A smoke-filled room."); break;
X case ROOMBASE+11: return("A well-appointed apartment."); break;
X case ROOMBASE+12: return("An antechamber."); break;
X case ROOMBASE+13: return("An unoccupied harem."); break;
X case ROOMBASE+14: return("A multi-purpose room."); break;
X case ROOMBASE+15: return("A room filled with stalactites."); break;
X case ROOMBASE+16: return("An underground greenhouse."); break;
X case ROOMBASE+17: return("A water closet."); break;
X case ROOMBASE+18: return("A study."); break;
X case ROOMBASE+19: return("A living room."); break;
X case ROOMBASE+20: return("A comfortable den."); break;
X case ROOMBASE+21: return("An abatoir."); break;
X case ROOMBASE+22: return("A boudoir.");break;
X case ROOMBASE+23: return("A star chamber.");break;
X case ROOMBASE+24: return("A manmade cavern."); break;
X case ROOMBASE+25: return("A sewer control room");break;
X default: return("A room of mystery and allure."); break;
X }
X}
X
X/* is a room connected to a lower number room? */
Xint connected(fromroom,toroom,level)
X{
X int i,connected=FALSE;
X
X for (i=0;
X ((i<Leveldata[level].rooms[fromroom].numconnections) &&
X (! connected));
X i++)
X connected != (Leveldata[level].rooms[fromroom].connections[i] == toroom);
X return(connected);
X}
X
X/* establishes a connection from room to a lower numbered room */
Xvoid connect_room(fromroom,toroom,level)
Xint fromroom,toroom,level;
X{
X /* What a mess! */
X Leveldata[level].rooms[fromroom].connections[(Leveldata[level].rooms[fromroom].numconnections)++] = toroom;
X}
X
X
X
Xvoid roomcenter(room,x,y,level)
Xint room,*x,*y,level;
X{
X *x = (Leveldata[level].rooms[room].left +
X Leveldata[level].rooms[room].right) / 2;
X *y = (Leveldata[level].rooms[room].top +
X Leveldata[level].rooms[room].bottom) / 2;
X}
X
X
X
Xvoid change_level(level,sitechar)
Xint level;
Xchar sitechar;
X{
X int i,j,found=FALSE;
X for(i=0;i<WIDTH;i++)
X for(j=0;j<LENGTH;j++)
X if ((Dungeon[level][i][j].locchar == sitechar) && (! found)){
X found = TRUE;
X Player.x = i;
X Player.y = j;
X break;
X }
X}
X
X
Xvoid install_traps(level)
Xint level;
X{
X int i,j;
X for(i=0;i<WIDTH;i++)
X for(j=0;j<LENGTH;j++)
X if ((Dungeon[level][i][j].locchar == FLOOR) &&
X (Dungeon[level][i][j].p_locf == L_NO_OP) &&
X random_range(500) <= ((int)(level/6)))
X Dungeon[level][i][j].p_locf = TRAP_BASE+random_range(NUMTRAPS);
X}
X
X
Xvoid cavern_level(level,special_level)
Xint level;
Xint special_level;
X{
X int i,j,fx,fy,tx,ty;
X pob tob;
X
X Leveldata[level].numrooms = 1;
X
X if (special_level==1)
X Leveldata[level].rooms[0].rsi = RS_GOBLINKING;
X else if (special_level==2)
X Leveldata[level].rooms[0].rsi = RS_DRAGONLORD;
X else Leveldata[level].rooms[0].rsi = RS_CAVERN;
X Leveldata[level].rooms[0].top = random_range((int)(LENGTH/2));
X Leveldata[level].rooms[0].left = random_range((int)(WIDTH/2));
X Leveldata[level].rooms[0].right = Leveldata[level].rooms[0].left +
X random_range((int)(WIDTH/4)) +
X ((int)(WIDTH/4));
X Leveldata[level].rooms[0].bottom = Leveldata[level].rooms[0].top +
X random_range((int)(LENGTH/4)) +
X ((int)(LENGTH/4));
X
X build_room(0,level);
X
X
X for (i=0;i<24;i++) {
X do {
X tx = random_range(WIDTH);
X ty = random_range(LENGTH);
X } while (Dungeon[level][tx][ty].locchar != FLOOR);
X fx = random_range(WIDTH-2)+1;
X fy = random_range(LENGTH-2)+1;
X straggle_corridor(fx,fy,tx,ty,level,FLOOR);
X }
X while (random_range(3)==1) {
X do {
X tx = random_range(WIDTH);
X ty = random_range(LENGTH);
X } while (Dungeon[level][tx][ty].locchar != FLOOR);
X fx = random_range(WIDTH-2)+1;
X fy = random_range(LENGTH-2)+1;
X straggle_corridor(fx,fy,tx,ty,level,WATER);
X }
X if (special_level==1) {
X populate_level(level,ML1+6); /* ML1+6 == goblin */
X do {
X tx = random_range(WIDTH);
X ty = random_range(LENGTH);
X } while (Dungeon[level][tx][ty].locchar != FLOOR);
X
X Mlist[level]->m =
X Dungeon[level][tx][ty].creature =
X ((pmt) make_creature(ML3+5));
X Mlist[level]->m->x = tx;
X Mlist[level]->m->y = ty;
X }
X else if (special_level==2) { /* dragonslair */
X populate_level(level,ML8+3); /* dragon */
X do {
X tx = random_range(WIDTH);
X ty = random_range(LENGTH);
X } while (Dungeon[level][tx][ty].locchar != FLOOR);
X Mlist[level]->m =
X Dungeon[level][tx][ty].creature =
X ((pmt) make_creature(ML10+3)); /*dragonlord*/
X Mlist[level]->m->x = tx;
X Mlist[level]->m->y =ty;
X }
X else populate_level(level,-1);
X stock_level(level);
X}
X
X
X
X
X
X
X
X
X
Xvoid install_specials(level)
Xint level;
X{
X int i,j,x,y;
X
X for(x=0;x<WIDTH;x++)
X for(y=0;y<LENGTH;y++)
X if ((Dungeon[level][x][y].locchar == FLOOR) &&
X (Dungeon[level][x][y].p_locf == L_NO_OP) &&
X random_range(500) <= ((int)(level/4))) {
X i = random_range(100);
X if (i < 10) {
X Dungeon[level][x][y].locchar = ALTAR;
X Dungeon[level][x][y].p_locf = L_ALTAR;
X Dungeon[level][x][y].aux = random_range(10);
X }
X else if (i < 25) {
X Dungeon[level][x][y].locchar = WATER;
X Dungeon[level][x][y].p_locf = L_MAGIC_POOL;
X }
X else if (i < 35) {
X Dungeon[level][x][y].locchar = LAVA;
X Dungeon[level][x][y].p_locf = L_LAVA;
X }
X else if (i < 45) {
X Dungeon[level][x][y].locchar = FIRE;
X Dungeon[level][x][y].p_locf = L_FIRE;
X }
X else if (i < 50) {
X Dungeon[level][x][y].locchar = LIFT;
X Dungeon[level][x][y].p_locf = L_LIFT;
X }
X else if (i < 55) {
X Dungeon[level][x][y].locchar = HEDGE;
X Dungeon[level][x][y].p_locf = L_HEDGE;
X }
X else if (i < 57) {
X Dungeon[level][x][y].locchar = HEDGE;
X Dungeon[level][x][y].p_locf = L_TRIFID;
X }
X else if (i< 65) {
X Dungeon[level][x][y].locchar = STATUE;
X if (random_range(100) < Dlevel)
X for (j=0;j<8;j++) {
X if (Dungeon[level][x+Dirs[0][j]][y+Dirs[1][j]].p_locf != L_NO_OP)
X Dungeon[level][x+Dirs[0][j]][y+Dirs[1][j]].locchar = FLOOR;
X Dungeon[level][x+Dirs[0][j]][y+Dirs[1][j]].p_locf =
X L_STATUE_WAKE;
X }
X }
X else if (i<70) {
X Dungeon[level][x][y].locchar = WHIRLWIND;
X Dungeon[level][x][y].p_locf = L_WHIRLWIND;
X }
X else {
X Dungeon[level][x][y].locchar = WATER;
X Dungeon[level][x][y].p_locf = L_WATER;
X }
X }
X}
X
X
Xvoid grid_level(level)
Xint level;
X{
X int i,j,k,l,fx,fy,tx,ty,x,y;
X
X Leveldata[level].numrooms = 0;
X
X
X for (i=1;i<LENGTH-1;i+=random_range(4)+4) {
X for (l=1;l<WIDTH-1;l++) {
X Dungeon[level][l][i].locchar = FLOOR;
X Dungeon[level][l][i].roomnumber = RS_CORRIDOR;
X }
X }
X for (i=1;i<WIDTH-1;i+=random_range(6)+3) {
X for (l=1;l<LENGTH-1;l++) {
X Dungeon[level][i][l].locchar = FLOOR;
X Dungeon[level][i][l].roomnumber = RS_CORRIDOR;
X }
X }
X
X Leveldata[level].numrooms = random_range(4)+4;
X
X for (i=0;i<Leveldata[level].numrooms;i++) {
X Leveldata[level].rooms[i].rsi = random_range(NUMROOMNAMES)+ROOMBASE;
X Leveldata[level].rooms[i].top = random_range(LENGTH-8)+1;
X Leveldata[level].rooms[i].left = random_range(WIDTH-16)+1;
X Leveldata[level].rooms[i].right =
X Leveldata[level].rooms[i].left +
X random_range(8)+8;
X Leveldata[level].rooms[i].bottom =
X Leveldata[level].rooms[i].top +
X random_range(4)+4;
X build_room(i,level);
X }
X
X while (random_range(3)==1) {
X fx = random_range(WIDTH-2)+1;
X fy = random_range(LENGTH-2)+1;
X tx = random_range(WIDTH-2)+1;
X ty = random_range(LENGTH-2)+1;
X straggle_corridor(fx,fy,tx,ty,level,WATER);
X }
X
X populate_level(level,-1);
X stock_level(level);
X}
X
X
X/* For each level,
X Make one stairway back to wherever player came from.
X There are always four stairways. One goes up one level, one down one
X level, one goes up multiple levels, and one goes down multiple levels
X*/
Xvoid make_stairs(fromlevel,level,sitechar)
Xint fromlevel;
Xint level;
Xchar sitechar;
X{
X int i,j,k;
X do {
X i = random_range(WIDTH);
X j = random_range(LENGTH);
X } while (Dungeon[level][i][j].locchar != FLOOR);
X Player.x = i;
X Player.y = j;
X Dungeon[level][Player.x][Player.y].locchar = sitechar;
X Dungeon[level][Player.x][Player.y].aux = fromlevel;
X Dungeon[level][Player.x][Player.y].stopsrun = TRUE;
X if (fromlevel != level - 1) {
X do {
X i = random_range(WIDTH);
X j = random_range(LENGTH);
X } while (Dungeon[level][i][j].locchar != FLOOR);
X Player.x = i;
X Player.y = j;
X Dungeon[level][Player.x][Player.y].locchar = UP;
X Dungeon[level][Player.x][Player.y].aux = level - 1;
X Dungeon[level][Player.x][Player.y].stopsrun = TRUE;
X }
X
X /* only one final portal... */
X if ((fromlevel != level + 1) && (level != NUMLEVELS-2)) {
X do {
X i = random_range(WIDTH);
X j = random_range(LENGTH);
X } while (Dungeon[level][i][j].locchar != FLOOR);
X Dungeon[level][i][j].locchar = DOWN;
X Dungeon[level][i][j].stopsrun = TRUE;
X Dungeon[level][i][j].aux = level + 1;
X }
X
X
X if (fromlevel >= level - 1) {
X do {
X i = random_range(WIDTH);
X j = random_range(LENGTH);
X } while (Dungeon[level][i][j].locchar != FLOOR);
X Dungeon[level][i][j].locchar = UP;
X Dungeon[level][i][j].stopsrun = TRUE;
X Dungeon[level][i][j].aux = max(0,level - (random_range(3)+2));
X }
X
X if (fromlevel <= level + 1) {
X do {
X i = random_range(WIDTH);
X j = random_range(LENGTH);
X } while (Dungeon[level][i][j].locchar != FLOOR);
X Dungeon[level][i][j].locchar = DOWN;
X Dungeon[level][i][j].stopsrun = TRUE;
X Dungeon[level][i][j].aux = level + (random_range(3)+2);
X if (Dungeon[level][i][j].aux > NUMLEVELS -10)
X Dungeon[level][i][j].aux = level+1;
X if (level == NUMLEVELS-2)
X Dungeon[level][i][j].p_locf = L_WARNING;
X }
X}
X
X
X
Xvoid pond_level(level,special_level)
Xint level;
Xint special_level;
X{
X int i,l,r,t,b,k,j,fx,fy,tx,ty,rsi;
X pob tob;
X
X if (special_level==1)
X rsi = RS_OCEAN;
X else if (special_level==2)
X rsi = RS_WYRM;
X else rsi = RS_PONDS;
X
X
X for(i=1;i<WIDTH-1;i++)
X for(j=1;j<LENGTH-1;j++) {
X Dungeon[level][i][j].roomnumber = rsi;
X Dungeon[level][i][j].p_locf = L_WATER;
X Dungeon[level][i][j].locchar = WATER;
X }
X
X tx = random_range(WIDTH-2)+1;
X ty = random_range(LENGTH-2)+1;
X for (i=0;i<24;i++) {
X fx = tx;
X fy = ty;
X tx = random_range(WIDTH-2)+1;
X ty = random_range(LENGTH-2)+1;
X straggle_corridor(fx,fy,tx,ty,level,FLOOR);
X }
X
X if (special_level==1) {
X populate_level(level,ML4+8); /* giant croc */
X do {
X i = random_range(WIDTH);
X j = random_range(LENGTH);
X }while (Dungeon[level][i][j].locchar != WATER);
X Mlist[level]->m =
X Dungeon[level][i][j].creature =
X ((pmt) make_creature(ML6+6)); /* triton */
X Mlist[level]->m->x = i;
X Mlist[level]->m->y = j;
X }
X else if (special_level==2) {
X populate_level(level,ML8+6); /* tigershark */
X do {
X i = random_range(WIDTH);
X j = random_range(LENGTH);
X }while (Dungeon[level][i][j].locchar != WATER);
X Mlist[level]->m =
X Dungeon[level][i][j].creature =
X ((pmt) make_creature(ML9+6)); /*great wyrm*/
X Mlist[level]->m->x = i;
X Mlist[level]->m->y = j;
X }
X else populate_level(level,-1);
X stock_level(level);
X
X}
X
X
X/* draw a bunch of random non-intersecting rooms and draw corridors between
X them */
Xvoid room_level(level,special_level)
Xint level,special_level;
X{
X int roomsmade[30][30]; /* 30 is an arbitrary large enough number.... */
X int i,j,k,l,x,y,templetype,left,right,top,bottom;
X pml ml;
X
X if (special_level) Leveldata[level].numrooms = 23;
X else Leveldata[level].numrooms = 10+random_range(20);
X for(i=0;i<30;i++)
X for(j=0;j<30;j++)
X roomsmade[i][j] = FALSE;
X for (i=0;i<Leveldata[level].numrooms;i++) {
X do {
X k = random_range(6); /* 64 / 10, 10 is max room width */
X l = random_range(6); /* 64 / 10, 10 is max room length */
X } while(roomsmade[k][l]);
X roomsmade[k][l]=TRUE;
X Leveldata[level].rooms[i].top = (l * 10) + 1;
X Leveldata[level].rooms[i].bottom = (l * 10) + 5 + random_range(5);
X Leveldata[level].rooms[i].left = (k * 10) + 1;
X Leveldata[level].rooms[i].right = (k * 10) + 5 + random_range(5);
X Leveldata[level].rooms[i].rsi = random_range(NUMROOMNAMES)+ROOMBASE;
X build_room(i,level);
X }
X for (i=0;i<Leveldata[level].numrooms-1;i++)
X room_connect_corridor(i,i+1,level);
X
X if (special_level) {
X do {
X x = random_range(WIDTH);
X y = random_range(LENGTH);
X } while ((Dungeon[level][x][y].locchar != FLOOR) &&
X (Dungeon[level][x][y].roomnumber < ROOMBASE));
X Dungeon[level][x][y].locchar = ALTAR;
X Dungeon[level][x][y].p_locf = L_ALTAR;
X Dungeon[level][x][y].aux = special_level;
X ml = (pml) malloc(sizeof(mltype));
X ml->next = NULL;
X ml->m =
X Dungeon[level][x][y].creature =
X ((pmt) make_hiscore_npc(special_level));
X ml->m->x = x;
X ml->m->y = y;
X Mlist[level] = ml;
X populate_level(level,ML8+9);
X left =
X Leveldata[level].rooms[Dungeon[level][x][y].roomnumber-ROOMBASE].left;
X right =
X Leveldata[level].rooms[Dungeon[level][x][y].roomnumber-ROOMBASE].right;
X top =
X Leveldata[level].rooms[Dungeon[level][x][y].roomnumber-ROOMBASE].top;
X bottom =
X Leveldata[level].rooms[Dungeon[level][x][y].roomnumber-ROOMBASE].bottom;
X switch(special_level) {
X case ODIN: templetype = RS_ODIN; break;
X case ATHENA: templetype = RS_ATHENA; break;
X case SET: templetype = RS_SET; break;
X case HECATE: templetype = RS_HECATE; break;
X case DRUID: templetype = RS_DRUID; break;
X case DESTINY: templetype = RS_DESTINY; break;
X }
X for(k=left;k<=right;k++)
X for(l=top;l<bottom;l++)
X Dungeon[level][k][l].roomnumber = templetype;
X }
X populate_level(level,-1);
X stock_level(level);
X}
X
END_OF_ogen.c
if test 25352 -ne `wc -c <ogen.c`; then
echo shar: \"ogen.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f oscroll2.txt -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"oscroll2.txt\"
else
echo shar: Extracting \"oscroll2.txt\" \(1662 characters\)
sed "s/^X//" >oscroll2.txt <<'END_OF_oscroll2.txt'
XWelcome to Rampart! A guidebook of the Rampart Tourist Association.
X
XRampart is the sole city in this area of LOCUS, a bastion which the
Xwild forces of both Law and Chaos cannot breach. Within the town there
Xis a truce between the followers of Law and Chaos which is hardly ever
Xbroken.
X
XThe visitor to Rampart will enjoy a wide range of divertissements,
Xfrom shopping at Rampart's diverse assortment of shops, to attending
Xgames at the Rampart Coliseum, to a relaxing picnic at the Botanical
XGardens. Distinguished visitors may apply for an audience with the
XDuke, who is said to be the greatest courtier on LOCUS. Others spend
Xtheir nights (and days) gambling at the Rampart Casino.
X
XThe traveller who intends a longer stay in Rampart should check out the
Xvarious guilds, societies, and clubs which protect and employ almost
Xall the citizenry. The Commandant of the Mercenary Guild is always
Xhiring, just for example. Many travellers are attracted to the
XCollegium Magii -- scholarships are available to the qualified.
X
XA few cautions should be offered to the unwary. Rampart's sewer system
Xis dangerous, and while there is ABSOLUTELY NO TRUTH to the rumors of
Xtreasure-filled dungeons and caverns beneath the city, many
Xdisappearances each year are attributed to unauthorized excursions
Xbeneath the city. For the larcenous-minded, be warned that Rampart's
XCity Guard is uncorruptible. It is just a matter of time, promises
XMorgon the Justiciar, until the secret hideout of the Thieve's Guild
Xis uncovered....
X
XBut these warnings are surely unnecessary for the vast majority of our
Xvisitors who will be perfectly safe if they act with reasonable caution....
END_OF_oscroll2.txt
if test 1662 -ne `wc -c <oscroll2.txt`; then
echo shar: \"oscroll2.txt\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 14 \(of 15\).
cp /dev/null ark14isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 15 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0