WPUBLIC void * bless_WFile (const char * fname,
warc_u64_t max_size,
wfile_mode_t mode, warc_bool_t compressed,
const char * dname)
{
return (bless (WFile, fname, (warc_u64_t) max_size, mode, compressed,dname));
}
SV *ast_to_sv(pTHX_ AST *ast)
{
SV *root = node_to_sv(aTHX_ ast->root);
HV *hash = (HV*)new_Hash();
hv_stores(hash, "root", set(root));
SV *ret = set(bless(aTHX_ hash, "Compiler::Parser::AST"));
return ret;
}
void blessorcurse(struct obj *otmp, int chance)
{
if (otmp->blessed || otmp->cursed) return;
if (!rn2(chance)) {
if (!rn2(2)) {
curse(otmp);
} else {
bless(otmp);
}
}
return;
}
void test1 (void)
{
void * a = bless (AFile, "./app/wdata/arc2warc/file.arc", ARC_FILE_UNCOMPRESSED, ".");
void * w = bless (WFile, "file.warc",
WARC_MAX_SIZE, WARC_FILE_WRITER, WARC_FILE_UNCOMPRESSED, ".");
CU_ASSERT_PTR_NOT_EQUAL(a,NIL);
CU_ASSERT_PTR_NOT_EQUAL(w,NIL);
assert(a);
assert(w);
while (AFile_hasMoreRecords (a) )
{
void * ar = AFile_nextRecord (a);
void * wr = NIL;
unless (ar)
{
CU_FAIL ("unable to retrieve the ArcRecord object");
destroy (w);
destroy (a);
return ;
}
else CU_PASS (" retrieve the ArcRecord object");
wr = bless (WRecord);
unless (wr)
{
CU_FAIL( "unable to create the WRecord object");
destroy (w);
destroy (a);
destroy (ar);
return ;
}
else CU_PASS (" retrieve the ArcRecord object");
void test2 (void)
{
void * c = bless (WClient, makeS("127.0.0.1"), 8080, makeS ("warcserver"));
fprintf(stdout,"\n////////// test 2//////////\n");
CU_ASSERT_PTR_NOT_EQUAL(c,NIL);
if (WClient_getWFile (c, 0, makeS("cwarc.warc.gz"),
uS("./out2.warc.gz")))
{
CU_FAIL ( "request not satisfied");
}
else
CU_PASS ("request satisfied");
destroy (c);
}
void test4 (void)
{
void * c = bless (WClient, makeS("127.0.0.1"), 8080, makeS ("warcserver"));
fprintf(stdout,"\n////////// test 4//////////\n");
CU_ASSERT_PTR_NOT_EQUAL(c,NIL);
if (WClient_getFiltredWFile (c, 0, makeS ("recordtype"), makeS ("warcinfo"), makeS("ero1.warc"),
uS("./out4.warc")))
{
fprintf (stdout, "--------------\n");
CU_FAIL ( "request not satisfied");
}
else CU_PASS ("request satisfied");
destroy (c);
}
void test5 (void)
{
void * c = bless (WClient, makeS("127.0.0.1"), 8080, makeS ("warcserver"));
fprintf(stdout,"\n////////// test 5//////////\n");
CU_ASSERT_PTR_NOT_EQUAL(c,NIL);
if (WClient_getList (c, 0, makeS("cwarc.warc.gz"), makeS ("html"),
uS("./out51.html")))
{
CU_FAIL ( "request not satisfied");
}
else
CU_PASS ("request satisfied");
if (WClient_getList (c, 0, makeS("cwarc.warc.gz"), makeS ("xml"),
uS("./out52.xml")))
{
CU_FAIL ( "request not satisfied");
}
else
CU_PASS ("request satisfied");
if (WClient_getList (c, 0, makeS("cwarc.warc.gz"), makeS ("text"),
uS("./out53.txt")))
{
CU_FAIL ( "request not satisfied");
}
else
CU_PASS ("request satisfied");
if (WClient_getList (c, 0, makeS("cwarc.warc.gz"), makeS ("json"),
uS("./out5.json")))
{
CU_FAIL ( "request not satisfied");
}
else
CU_PASS ("request satisfied");
destroy (c);
}
WPRIVATE void * WGetOpt_constructor (void * _self, va_list * app)
{
struct WGetOpt * const self = _self;
const char * text = va_arg (* app, const char *);
const warc_u32_t len = va_arg (* app, const warc_u32_t);
/* preconditions */
assert (text);
FLAGS = bless (WString, text, len);
unless (FLAGS)
{
destroy (self);
return (NIL);
}
OPTIND = 1;
OPTARG = 0;
SP = 1;
return (self);
}
void s_bless(void)
{
bless(0);
}
/* Prayer occurs at altars, hence the name of the function */
void l_altar()
{
int i;
int deity;
char response;
if(Current_Environment == E_COUNTRYSIDE) {
deity = DRUID;
}
else {
deity = Level->site[Player.x][Player.y].aux;
}
switch(deity) {
case ODIN:
print1("This granite altar is graven with a gallows.");
break;
case SET:
print1("This sandstone altar has a black hand drawn on it.");
break;
case HECATE:
print1("This silver altar is inlaid with a black cresent moon.");
break;
case ATHENA:
print1("This golden altar is inscribed with an owl.");
break;
case DESTINY:
print1("This crystal altar is in the form of an omega.");
break;
case DRUID:
print1("This oaken altar is ornately engraved with leaves.");
break;
default:
print1("This rude altar has no markings.");
break;
}
print2("Worship at this altar? [yn] ");
if(ynq2() == 'y') {
if(Player.rank[PRIESTHOOD] == 0) {
increase_priest_rank(deity);
}
else if(!check_sacrilege(deity)) {
if(Blessing) {
print1("You have a sense of immanence.");
}
print2("Request a Blessing, Sacrifice an item, or just Pray [b,s,p] ");
response = mcigetc();
while((response != 'b')
&& (response != 's')
&& (response != 'p')
&& (response != ESCAPE)) {
response = mcigetc();
}
if(response == 'b') {
print1("You beg a heavenly benefice.");
print2("You hear a gong resonating throughout eternity...");
morewait();
if(Blessing) {
print1("A shaft of lecent radiance lances dwon from the heavens!");
print2("You feel uplifted...");
morewait();
gain_experience(Player.rank[PRIESTHOOD] * Player.rank[PRIESTHOOD] * 50);
cleanse(1);
heal(10);
bless(1);
Blessing = FALSE;
increase_priest_rank(deity);
}
else {
print1("Your ardent plea is ignored.");
print2("You feel ashamed.");
Player.xp -= (Player.xp / 4);
}
calc_melee();
}
else if(response == 's') {
print1("Which item to Sacrifice?");
i = getitem('\0');
if(i == ABORT) {
i = 0;
}
if(Player.possessions[i] == NULL) {
print1("You have insulted your deity!");
print2("Not a good idea, as it turns out...");
dispel(-1);
p_damage(Player.hp - 1, UNSTOPPABLE, "a god's pique");
}
else if(true_item_value(Player.possessions[i]) > (Player.rank[PRIESTHOOD] * Player.rank[PRIESTHOOD] * Player.rank[PRIESTHOOD] * 50)) {
print1("With a burst of blue flame, your offering vanishes!");
dispose_lost_objects(1, Player.possessions[i]);
print2("A violet nimbus settles around your head and slowly fades.");
morewait();
Blessing = TRUE;
}
else {
print1("A darkling glow envelopes your offering!");
print2("The glow slowly fades...");
morewait();
setgamestatus(SUPPRESS_PRINTING);
if(Player.possessions[i]->used) {
Player.possessions[i]->used = FALSE;
item_use(Player.possessions[i]);
Player.possessions[i]->blessing = -1 - abs(Player.possessions[i]->blessing);
Player.possessions[i]->used = TRUE;
item_use(Player.possessions[i]);
}
else {
Player.possessions[i]->blessing = -1 - abs(Player.possessions[i]->blessing);
}
resetgamestatus(SUPPRESS_PRINTING);
}
}
else if(response == 'p') {
if(deity != Player.patron) {
print1("Nothing seems to happen.");
}
else {
increase_priest_rank(deity);
}
}
}
}
}
static SV *node_to_sv(pTHX_ Node *node)
{
SV *ret = NULL;
if (!node) return ret;
if (TYPE_match(node, BranchNode)) {
BranchNode *branch = dynamic_cast<BranchNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, branch->tk);
add_key(hash, "left", branch->left);
add_key(hash, "right", branch->right);
add_key(hash, "next", branch->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Branch");
} else if (TYPE_match(node, FunctionCallNode)) {
FunctionCallNode *call = dynamic_cast<FunctionCallNode *>(node);
Nodes *args = call->args;
size_t argsize = args->size();
AV *array = new_Array();
for (size_t i = 0; i < argsize; i++) {
SV *arg = node_to_sv(aTHX_ args->at(i));
if (!arg) continue;
av_push(array, set(arg));
}
HV *hash = (HV*)new_Hash();
add_key(hash, "next", call->next);
add_token(hash, call->tk);
(void)hv_stores(hash, "args", set(new_Ref(array)));
ret = bless(aTHX_ hash, "Compiler::Parser::Node::FunctionCall");
} else if (TYPE_match(node, ArrayNode)) {
ArrayNode *array = dynamic_cast<ArrayNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, array->tk);
add_key(hash, "next", array->next);
add_key(hash, "idx", array->idx);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Array");
} else if (TYPE_match(node, HashNode)) {
HashNode *h = dynamic_cast<HashNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, h->tk);
add_key(hash, "next", h->next);
add_key(hash, "key", h->key);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Hash");
} else if (TYPE_match(node, DereferenceNode)) {
DereferenceNode *dref = dynamic_cast<DereferenceNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, dref->tk);
add_key(hash, "next", dref->next);
add_key(hash, "expr", dref->expr);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Dereference");
} else if (TYPE_match(node, FunctionNode)) {
FunctionNode *f = dynamic_cast<FunctionNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, f->tk);
add_key(hash, "next", f->next);
add_key(hash, "body", f->body);
add_key(hash, "prototype", f->prototype);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Function");
} else if (TYPE_match(node, BlockNode)) {
BlockNode *b = dynamic_cast<BlockNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, b->tk);
add_key(hash, "next", b->next);
add_key(hash, "body", b->body);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Block");
} else if (TYPE_match(node, ReturnNode)) {
ReturnNode *r = dynamic_cast<ReturnNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, r->tk);
add_key(hash, "next", r->next);
add_key(hash, "body", r->body);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Return");
} else if (TYPE_match(node, SingleTermOperatorNode)) {
SingleTermOperatorNode *s = dynamic_cast<SingleTermOperatorNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, s->tk);
add_key(hash, "next", s->next);
add_key(hash, "expr", s->expr);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::SingleTermOperator");
} else if (TYPE_match(node, DoubleTermOperatorNode)) {
} else if (TYPE_match(node, LeafNode)) {
LeafNode *leaf = dynamic_cast<LeafNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, leaf->tk);
add_key(hash, "next", leaf->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Leaf");
} else if (TYPE_match(node, ListNode)) {
ListNode *list = dynamic_cast<ListNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, list->tk);
add_key(hash, "data", list->data);
add_key(hash, "next", list->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::List");
} else if (TYPE_match(node, ArrayRefNode)) {
ArrayRefNode *ref = dynamic_cast<ArrayRefNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, ref->tk);
add_key(hash, "data", ref->data);
add_key(hash, "next", ref->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::ArrayRef");
} else if (TYPE_match(node, HashRefNode)) {
HashRefNode *ref = dynamic_cast<HashRefNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, ref->tk);
add_key(hash, "data", ref->data);
add_key(hash, "next", ref->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::HashRef");
} else if (TYPE_match(node, IfStmtNode)) {
IfStmtNode *stmt = dynamic_cast<IfStmtNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, stmt->tk);
add_key(hash, "next", stmt->next);
add_key(hash, "expr", stmt->expr);
add_key(hash, "true_stmt", stmt->true_stmt);
add_key(hash, "false_stmt", stmt->false_stmt);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::IfStmt");
} else if (TYPE_match(node, ElseStmtNode)) {
ElseStmtNode *stmt = dynamic_cast<ElseStmtNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, stmt->tk);
add_key(hash, "next", stmt->next);
add_key(hash, "stmt", stmt->stmt);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::ElseStmt");
} else if (TYPE_match(node, DoStmtNode)) {
DoStmtNode *stmt = dynamic_cast<DoStmtNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, stmt->tk);
add_key(hash, "next", stmt->next);
add_key(hash, "stmt", stmt->stmt);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::DoStmt");
} else if (TYPE_match(node, ForStmtNode)) {
ForStmtNode *stmt = dynamic_cast<ForStmtNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, stmt->tk);
add_key(hash, "next", stmt->next);
add_key(hash, "init", stmt->init);
add_key(hash, "cond", stmt->cond);
add_key(hash, "progress", stmt->progress);
add_key(hash, "true_stmt", stmt->true_stmt);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::ForStmt");
} else if (TYPE_match(node, ForeachStmtNode)) {
ForeachStmtNode *stmt = dynamic_cast<ForeachStmtNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, stmt->tk);
add_key(hash, "next", stmt->next);
add_key(hash, "itr", stmt->itr);
add_key(hash, "cond", stmt->cond);
add_key(hash, "true_stmt", stmt->true_stmt);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::ForeachStmt");
} else if (TYPE_match(node, WhileStmtNode)) {
WhileStmtNode *stmt = dynamic_cast<WhileStmtNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, stmt->tk);
add_key(hash, "next", stmt->next);
add_key(hash, "true_stmt", stmt->true_stmt);
add_key(hash, "expr", stmt->expr);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::WhileStmt");
} else if (TYPE_match(node, ModuleNode)) {
ModuleNode *mod = dynamic_cast<ModuleNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, mod->tk);
add_key(hash, "next", mod->next);
add_key(hash, "args", mod->args);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Module");
} else if (TYPE_match(node, PackageNode)) {
PackageNode *pkg = dynamic_cast<PackageNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, pkg->tk);
add_key(hash, "next", pkg->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Package");
} else if (TYPE_match(node, RegPrefixNode)) {
RegPrefixNode *reg = dynamic_cast<RegPrefixNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, reg->tk);
add_key(hash, "next", reg->next);
add_key(hash, "option", reg->option);
add_key(hash, "expr", reg->exp);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::RegPrefix");
} else if (TYPE_match(node, RegReplaceNode)) {
RegReplaceNode *reg = dynamic_cast<RegReplaceNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, reg->tk);
add_key(hash, "next", reg->next);
add_key(hash, "from", reg->from);
add_key(hash, "to", reg->to);
add_key(hash, "option", reg->option);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::RegReplace");
} else if (TYPE_match(node, RegexpNode)) {
RegexpNode *reg = dynamic_cast<RegexpNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, reg->tk);
add_key(hash, "next", reg->next);
add_key(hash, "option", reg->option);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Regexp");
} else if (TYPE_match(node, LabelNode)) {
LabelNode *label = dynamic_cast<LabelNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, label->tk);
add_key(hash, "next", label->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Label");
} else if (TYPE_match(node, HandleNode)) {
HandleNode *fh = dynamic_cast<HandleNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, fh->tk);
add_key(hash, "expr", fh->expr);
add_key(hash, "next", fh->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::Handle");
} else if (TYPE_match(node, HandleReadNode)) {
HandleReadNode *fh = dynamic_cast<HandleReadNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, fh->tk);
add_key(hash, "next", fh->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::HandleRead");
} else if (TYPE_match(node, ThreeTermOperatorNode)) {
ThreeTermOperatorNode *term = dynamic_cast<ThreeTermOperatorNode *>(node);
HV *hash = (HV*)new_Hash();
add_token(hash, term->tk);
add_key(hash, "cond", term->cond);
add_key(hash, "true_expr", term->true_expr);
add_key(hash, "false_expr", term->false_expr);
add_key(hash, "next", term->next);
ret = bless(aTHX_ hash, "Compiler::Parser::Node::ThreeTermOperator");
} else {
assert(0 && "node type is not found");
}
return ret;
}
void * bless_Wfile (char * path, warc_u64_t dim,
int mode, int compressed, char * dname)
{
return bless (WFile, path, dim, mode, compressed, dname);
}
WPUBLIC void * bless_WBloc (void * wfile, void * wrecord,
warc_bool_t httpheaders, warc_u32_t alloc)
{
return (bless (WBloc, wfile, wrecord, httpheaders, alloc));
}
WPUBLIC void * bless_WRecord (void)
{
return (bless (WRecord));
}
void * bless_Wrecord ()
{
return bless (WRecord);
}
/* scroll of blessing */
void i_bless(pob o)
{
Objects[o->id].known = 1;
bless(o->blessing);
}
int main (int argc, const char ** argv)
{
void * p = NIL; /* WGetOpt object */
void * a = NIL; /* an ARC file object */
void * w = NIL; /* a WARC file object */
void * u = NIL; /* a UUID object */
char * aname = NIL;
afile_comp_t amode = ARC_FILE_DETECT_COMPRESSION;
warc_bool_t b = WARC_FALSE;
warc_i32_t c = 0;
warc_u8_t * flags = uS ("ca:f:t:");
char * fname = NIL;
char * wdir = ".";
wfile_comp_t cmode = WARC_FILE_UNCOMPRESSED;
if (argc < 5 || argc > 9)
{
fprintf (stderr, "ARC to WARC convertor\n");
fprintf (stderr, "Usage: %s -a <file.arc> -f <file.warc> [-c] [-t <working_dir>]\n",
argv [0]);
fprintf (stderr, "\t-a : valid ARC file name\n");
fprintf (stderr, "\t-f : valid WARC file name\n");
fprintf (stderr, "\t[-c] : WARC file will be GZIP compressed (default no)\n");
fprintf (stderr, "\t[-t] : temporary working directory (default \".\")\n");
return (2);
}
p = bless (WGetOpt, makeS (flags) );
assert (p);
/* parse command line parameters */
while ( (c = WGetOpt_parse (p, argc, argv) ) != -1)
{
switch (c)
{
case 'f' :
if (w_index (flags, c) [1] == ':')
fname = WGetOpt_argument (p);
break;
case 'c' :
cmode = WARC_FILE_COMPRESSED_GZIP;
break;
case 'a' :
if (w_index (flags, c) [1] == ':')
aname = WGetOpt_argument (p);
break;
case 't' :
if (w_index (flags, c) [1] == ':')
wdir = WGetOpt_argument (p);
break;
case '?' : /* illegal option or missing argument */
destroy (p);
return (1);
}
}
unless (aname)
{
fprintf (stderr, "missing ARC file name. Use -a option\n");
destroy (p);
return (1);
}
unless (fname)
{
fprintf (stderr, "missing WARC file name. Use -f option\n");
destroy (p);
return (1);
}
/* open an existing ARC file */
a = bless (AFile, aname, amode, wdir);
unless (a)
{
fprintf (stderr, "unable to create the Arc object\n");
free_p;
return (2);
}
/* open or create a WARC file */
w = bless (WFile, fname, WARC_MAX_SIZE,
WARC_FILE_WRITER, cmode, wdir);
unless (w)
{
fprintf (stderr, "unable to create the Warc object\n");
free_p;
free_a;
return (3);
}
/* create a UUID object */
u = bless (WUUID);
unless (u)
{
fprintf (stderr, "unable to create a UUID object\n");
free_p;
free_w;
free_a;
return (4);
}
/* loop over all ARC records */
while (AFile_hasMoreRecords (a) )
{
void * ar = AFile_nextRecord (a);
void * wr = NIL;
/* check the next ARC record */
unless (ar)
{
fprintf (stderr, "corrupted ARC\n");
free_err_out ( 5);
}
/* create an empty WARC record */
wr = bless (WRecord);
unless (wr)
{
fprintf (stderr, "unable to create the WARC record object\n");
free_ar;
free_err_out (6);
}
/* set the subject URI */
b = WRecord_setTargetUri (wr, makeS (ARecord_getUrl (ar) ) );
if (b)
free_err (7);
/* set the record tyep */
b = WRecord_setRecordType (wr, WARC_RESPONSE_RECORD);
if (b)
free_err (8);
/* set the creation date */
b = WRecord_setDateFromArc (wr, makeS (ARecord_getCreationDate (ar) ) );
if (b)
free_err (9);
/* set the content type */
b = WRecord_setContentType (wr, makeS (ARecord_getMimeType (ar) ) );
if (b)
free_err (10);
/* Create a UUID (Universal Unique IDentifier) based on URL + Timestamp */
WUUID_hash (u, makeU (ARecord_getUrl (ar) ) );
WUUID_hash (u, makeU (ARecord_getCreationDate (ar) ) );
b = WRecord_setRecordId (wr, makeS (WUUID_text (u) ) );
if (b)
free_err (11);
WUUID_reinit (u); /* re-initialize the UUID object */
/* add the ARC IP as an Anvl */
b = WRecord_setIpAddress (wr, makeS (ARecord_getIpAddress (ar) ) );
if (b)
free_err (12);
/* move the ARC record payload to the WARC record */
b = ARecord_transferContent (ar, wr, a);
if (b)
free_err (13);
/* save the WARC record into the WARC file */
b = WFile_storeRecord (w, wr, NIL);
if (b)
free_err (14);
/* free the ARC and the WARC records */
free_in;
} /* end of while */
/* free the ARC and the WARC files */
free_out;
return (0);
}
void l_sorcerors(void)
{
char action;
int done=FALSE,fee;
long total;
print1("The Circle of Sorcerors.");
if (Player.rank[CIRCLE] == -1) {
print2("Fool! Didn't we tell you to go away?");
Player.mana = 0;
dataprint();
}
else while (! done) {
if ((Player.rank[CIRCLE]==HIGHSORCEROR) &&
(Player.level > Primelevel) &&
find_and_remove_item(CORPSEID,LAWBRINGER)) {
print2("You obtained the Crown of the Lawgiver!");
morewait();
print1("The Crown is ritually sacrificed to the Lords of Chaos.");
print2("You are now the Prime Sorceror of the Inner Circle!");
strcpy(Prime,Player.name);
Primelevel = Player.level;
morewait();
Primebehavior = fixnpc(4);
save_hiscore_npc(10);
clearmsg();
print1("You learn the Spell of Disintegration!");
morewait();
clearmsg();
Spells[S_DISINTEGRATE].known = TRUE;
Player.rank[CIRCLE] = PRIME;
Player.maxpow += 10;
Player.pow += 10;
}
menuclear();
menuprint("May we help you?\n\n");
menuprint("a: Become an Initiate of the Circle.\n");
menuprint("b: Raise your rank in the Circle.\n");
menuprint("c: Restore mana points\n");
menuprint("ESCAPE: Leave these Chambers of Power.\n");
showmenu();
action = mgetc();
if (action == ESCAPE) done = TRUE;
else if (action == 'a') {
if (Player.rank[CIRCLE] > 0)
print2("You are already an initiate!");
else if (Player.alignment > 0)
print2("You may not join -- you reek of Law!");
else if (Player.rank[COLLEGE] > 0)
print2("Foolish Mage! You don't have the right attitude to Power!");
#ifdef INCLUDE_MONKS
else if (Player.rank[MONKS] > 0)
print2("Stupid monk. Go Meditate on this!");
#endif
else {
fee = 3000;
fee += Player.alignment*100;
fee += fee*(12 - Player.pow)/9;
fee = max(100,fee);
clearmsg();
mprint("For you, there is an initiation fee of");
mnumprint(fee);
mprint(" Au.");
print2("Pay it? [yn] ");
if (ynq2() =='y') {
if (Player.cash < fee)
print3("Try again when you have the cash!");
else {
print1("Prime Sorceror ");
nprint1(Prime);
print2("conducts your initiation into the circle of novices.");
morewait();
clearmsg();
print1("You learn the Spell of Magic Missiles.");
Spells[S_MISSILE].known = TRUE;
Player.cash -= fee;
dataprint();
Player.rank[CIRCLE] = INITIATE;
Player.guildxp[CIRCLE] = 1;
Player.maxpow++;
Player.pow++;
}
}
}
}
else if (action == 'b') {
if (Player.rank[CIRCLE] == 0)
print2("You have not even been initiated, yet!");
else if (Player.alignment > -1) {
print1("Ahh! You have grown too lawful!!!");
print2("You are hereby blackballed from the Circle!");
Player.rank[CIRCLE] = -1;
morewait();
clearmsg();
print1("A pox upon thee!");
if (! Player.immunity[INFECTION])
Player.status[DISEASED]+=100;
print2("And a curse on your possessions!");
morewait();
clearmsg();
acquire(-1);
clearmsg();
enchant(-1);
bless(-1);
print3("Die, false sorceror!");
p_damage(25,UNSTOPPABLE,"a sorceror's curse");
done = TRUE;
}
else if (Player.rank[CIRCLE]==PRIME)
print2("You are at the pinnacle of mastery in the Circle.");
else if (Player.rank[CIRCLE]==HIGHSORCEROR) {
if (Player.level <= Primelevel)
print2("You are not experienced enough to advance.");
else
print2("You must return with the Crown of the LawBringer!");
}
else if (Player.rank[CIRCLE]==SORCEROR) {
if (Player.guildxp[CIRCLE] < 4000)
print2("You are not experienced enough to advance.");
else {
print1("You are now a High Sorceror of the Inner Circle!");
print2("You learn the Spell of Disruption!");
morewait();
clearmsg();
print1("To advance you must return with the LawBringer's Crown!");
print2("The LawBringer resides on Star Peak.");
Spells[S_DISRUPT].known = TRUE;
Player.rank[CIRCLE] = HIGHSORCEROR;
Player.maxpow += 5;
Player.pow += 5;
}
}
else if (Player.rank[CIRCLE]==ENCHANTER) {
if (Player.guildxp[CIRCLE] < 1500)
print2("You are not experienced enough to advance.");
else {
print1("You are now a member of the Circle of Sorcerors!");
print2("You learn the Spell of Ball Lightning!");
Spells[S_LBALL].known = TRUE;
Player.rank[CIRCLE] = SORCEROR;
Player.maxpow += 2;
Player.pow+=2;
}
}
else if (Player.rank[CIRCLE]==INITIATE) {
if (Player.guildxp[CIRCLE] < 400)
print2("You are not experienced enough to advance.");
else {
print1("You are now a member of the Circle of Enchanters!");
print2("You learn the Spell of Firebolts.");
Spells[S_FIREBOLT].known = TRUE;
Player.rank[CIRCLE] = ENCHANTER;
Player.maxpow+=2;
Player.pow+=2;
}
}
}
else if (action == 'c') {
done = TRUE;
fee = Player.level*100;
if (Player.rank[CIRCLE]) fee = fee / 2;
clearmsg();
print1("That will be: ");
mnumprint(fee);
nprint1("Au. Pay it? [yn] ");
if (ynq1()=='y') {
if (Player.cash < fee)
print2("Begone, deadbeat, or face the wrath of the Circle!");
else {
Player.cash -= fee;
total = calcmana();
while (Player.mana < total) {
Player.mana++;
dataprint();
}
print2("Have a sorcerous day, now!");
}
}
else print2("Be seeing you!");
}
}
xredraw();
}
// circuit input from demarshalled witness
void bless(const R1Cowitness<FR>& input) {
bless(valueFromWitness(input));
}
/* Scrolls for the reading -RAK- */
void read_scroll()
{
int32u i;
int j, k, item_val, y, x;
int tmp[6], flag, used_up;
bigvtype out_val, tmp_str;
register int ident, l;
register inven_type *i_ptr;
register struct misc *m_ptr;
free_turn_flag = TRUE;
if (py.flags.blind > 0)
msg_print("You can't see to read the scroll.");
else if (no_light())
msg_print("You have no light to read by.");
else if (py.flags.confused > 0)
msg_print("You are too confused to read a scroll.");
else if (inven_ctr == 0)
msg_print("You are not carrying anything!");
else if (!find_range(TV_SCROLL1, TV_SCROLL2, &j, &k))
msg_print ("You are not carrying any scrolls!");
else if (get_item(&item_val, "Read which scroll?", j, k, 0))
{
i_ptr = &inventory[item_val];
free_turn_flag = FALSE;
used_up = TRUE;
i = i_ptr->flags;
ident = FALSE;
while (i != 0)
{
j = bit_pos(&i) + 1;
if (i_ptr->tval == TV_SCROLL2)
j += 32;
/* Scrolls. */
switch(j)
{
case 1:
i_ptr = &inventory[INVEN_WIELD];
if (i_ptr->tval != TV_NOTHING)
{
objdes(tmp_str, i_ptr, FALSE);
(void) sprintf(out_val, "Your %s glows faintly!", tmp_str);
msg_print(out_val);
if (enchant(&i_ptr->tohit))
{
i_ptr->flags &= ~TR_CURSED;
calc_bonuses();
}
else
msg_print("The enchantment fails.");
ident = TRUE;
}
break;
case 2:
i_ptr = &inventory[INVEN_WIELD];
if (i_ptr->tval != TV_NOTHING)
{
objdes(tmp_str, i_ptr, FALSE);
(void) sprintf(out_val, "Your %s glows faintly!", tmp_str);
msg_print(out_val);
if (enchant(&i_ptr->todam))
{
i_ptr->flags &= ~TR_CURSED;
calc_bonuses ();
}
else
msg_print("The enchantment fails.");
ident = TRUE;
}
break;
case 3:
k = 0;
l = 0;
if (inventory[INVEN_BODY].tval != TV_NOTHING)
tmp[k++] = INVEN_BODY;
if (inventory[INVEN_ARM].tval != TV_NOTHING)
tmp[k++] = INVEN_ARM;
if (inventory[INVEN_OUTER].tval != TV_NOTHING)
tmp[k++] = INVEN_OUTER;
if (inventory[INVEN_HANDS].tval != TV_NOTHING)
tmp[k++] = INVEN_HANDS;
if (inventory[INVEN_HEAD].tval != TV_NOTHING)
tmp[k++] = INVEN_HEAD;
/* also enchant boots */
if (inventory[INVEN_FEET].tval != TV_NOTHING)
tmp[k++] = INVEN_FEET;
if (k > 0) l = tmp[randint(k)-1];
if (TR_CURSED & inventory[INVEN_BODY].flags)
l = INVEN_BODY;
else if (TR_CURSED & inventory[INVEN_ARM].flags)
l = INVEN_ARM;
else if (TR_CURSED & inventory[INVEN_OUTER].flags)
l = INVEN_OUTER;
else if (TR_CURSED & inventory[INVEN_HEAD].flags)
l = INVEN_HEAD;
else if (TR_CURSED & inventory[INVEN_HANDS].flags)
l = INVEN_HANDS;
else if (TR_CURSED & inventory[INVEN_FEET].flags)
l = INVEN_FEET;
if (l > 0)
{
i_ptr = &inventory[l];
objdes(tmp_str, i_ptr, FALSE);
(void) sprintf(out_val, "Your %s glows faintly!", tmp_str);
msg_print(out_val);
if (enchant(&i_ptr->toac))
{
i_ptr->flags &= ~TR_CURSED;
calc_bonuses ();
}
else
msg_print("The enchantment fails.");
ident = TRUE;
}
break;
case 4:
msg_print("This is an identify scroll.");
ident = TRUE;
used_up = ident_spell();
/* the identify may merge objects, causing the identify scroll
to move to a different place. Check for that here. */
if (i_ptr->tval != TV_SCROLL1 || i_ptr->flags != 0x00000008)
{
item_val--;
i_ptr = &inventory[item_val];
if (i_ptr->tval != TV_SCROLL1 || i_ptr->flags != 0x00000008)
{
msg_print("internal error with identify spell.");
msg_print("Please tell the wizard!");
return;
}
}
break;
case 5:
if (remove_curse())
{
msg_print("You feel as if someone is watching over you.");
ident = TRUE;
}
break;
case 6:
ident = light_area(char_row, char_col);
break;
case 7:
for (k = 0; k < randint(3); k++)
{
y = char_row;
x = char_col;
ident |= summon_monster(&y, &x, FALSE);
}
break;
case 8:
teleport(10);
ident = TRUE;
break;
case 9:
teleport(100);
ident = TRUE;
break;
case 10:
(void) tele_level();
ident = TRUE;
break;
case 11:
if (py.flags.confuse_monster == 0)
{
msg_print("Your hands begin to glow.");
py.flags.confuse_monster = TRUE;
ident = TRUE;
}
break;
case 12:
ident = TRUE;
map_area();
break;
case 13:
ident = sleep_monsters1(char_row, char_col);
break;
case 14:
ident = TRUE;
warding_glyph();
break;
case 15:
ident = detect_treasure();
break;
case 16:
ident = detect_object();
break;
case 17:
ident = detect_trap();
break;
case 18:
ident = detect_sdoor();
break;
case 19:
msg_print("This is a mass genocide scroll.");
ident = mass_genocide(TRUE);
break;
case 20:
ident = detect_invisible();
break;
case 21:
ident = aggravate_monster(20);
if (ident)
msg_print("There is a high pitched humming noise.");
break;
case 22:
ident = trap_creation();
break;
case 23:
ident = td_destroy();
break;
case 24: /* Not Used , used to be door creation */
break;
case 25:
msg_print("This is a Recharge-Item scroll.");
ident = TRUE;
used_up = recharge(60);
break;
case 26:
msg_print("This is a genocide scroll.");
ident = genocide(TRUE);
break;
case 27:
ident = unlight_area(char_row, char_col);
break;
case 28:
ident = protect_evil();
break;
case 29:
ident = TRUE;
create_food();
break;
case 30:
ident = dispel_creature(UNDEAD, 60);
break;
case 31:
remove_all_curse();
ident = TRUE;
break;
case 33:
i_ptr = &inventory[INVEN_WIELD];
if (i_ptr->tval != TV_NOTHING)
{
objdes(tmp_str, i_ptr, FALSE);
(void) sprintf(out_val, "Your %s glows brightly!", tmp_str);
msg_print(out_val);
flag = FALSE;
for (k = 0; k < randint(2); k++)
if (enchant(&i_ptr->tohit))
flag = TRUE;
for (k = 0; k < randint(2); k++)
if (enchant(&i_ptr->todam))
flag = TRUE;
if (flag)
{
i_ptr->flags &= ~TR_CURSED;
calc_bonuses ();
}
else
msg_print("The enchantment fails.");
ident = TRUE;
}
break;
case 34:
i_ptr = &inventory[INVEN_WIELD];
if (i_ptr->tval != TV_NOTHING)
{
objdes(tmp_str, i_ptr, FALSE);
(void)sprintf(out_val,"Your %s glows black, fades.",tmp_str);
msg_print(out_val);
unmagic_name(i_ptr);
i_ptr->tohit = -randint(5) - randint(5);
i_ptr->todam = -randint(5) - randint(5);
i_ptr->flags = TR_CURSED;
py_bonuses(i_ptr, -1);
calc_bonuses ();
ident = TRUE;
}
break;
case 35:
k = 0;
l = 0;
if (inventory[INVEN_BODY].tval != TV_NOTHING)
tmp[k++] = INVEN_BODY;
if (inventory[INVEN_ARM].tval != TV_NOTHING)
tmp[k++] = INVEN_ARM;
if (inventory[INVEN_OUTER].tval != TV_NOTHING)
tmp[k++] = INVEN_OUTER;
if (inventory[INVEN_HANDS].tval != TV_NOTHING)
tmp[k++] = INVEN_HANDS;
if (inventory[INVEN_HEAD].tval != TV_NOTHING)
tmp[k++] = INVEN_HEAD;
/* also enchant boots */
if (inventory[INVEN_FEET].tval != TV_NOTHING)
tmp[k++] = INVEN_FEET;
if (k > 0) l = tmp[randint(k)-1];
if (TR_CURSED & inventory[INVEN_BODY].flags)
l = INVEN_BODY;
else if (TR_CURSED & inventory[INVEN_ARM].flags)
l = INVEN_ARM;
else if (TR_CURSED & inventory[INVEN_OUTER].flags)
l = INVEN_OUTER;
else if (TR_CURSED & inventory[INVEN_HEAD].flags)
l = INVEN_HEAD;
else if (TR_CURSED & inventory[INVEN_HANDS].flags)
l = INVEN_HANDS;
else if (TR_CURSED & inventory[INVEN_FEET].flags)
l = INVEN_FEET;
if (l > 0)
{
i_ptr = &inventory[l];
objdes(tmp_str, i_ptr, FALSE);
(void) sprintf(out_val,"Your %s glows brightly!", tmp_str);
msg_print(out_val);
flag = FALSE;
for (k = 0; k < randint(2) + 1; k++)
if (enchant(&i_ptr->toac))
flag = TRUE;
if (flag)
{
i_ptr->flags &= ~TR_CURSED;
calc_bonuses ();
}
else
msg_print("The enchantment fails.");
ident = TRUE;
}
break;
case 36:
if ((inventory[INVEN_BODY].tval != TV_NOTHING)
&& (randint(4) == 1))
k = INVEN_BODY;
else if ((inventory[INVEN_ARM].tval != TV_NOTHING)
&& (randint(3) ==1))
k = INVEN_ARM;
else if ((inventory[INVEN_OUTER].tval != TV_NOTHING)
&& (randint(3) ==1))
k = INVEN_OUTER;
else if ((inventory[INVEN_HEAD].tval != TV_NOTHING)
&& (randint(3) ==1))
k = INVEN_HEAD;
else if ((inventory[INVEN_HANDS].tval != TV_NOTHING)
&& (randint(3) ==1))
k = INVEN_HANDS;
else if ((inventory[INVEN_FEET].tval != TV_NOTHING)
&& (randint(3) ==1))
k = INVEN_FEET;
else if (inventory[INVEN_BODY].tval != TV_NOTHING)
k = INVEN_BODY;
else if (inventory[INVEN_ARM].tval != TV_NOTHING)
k = INVEN_ARM;
else if (inventory[INVEN_OUTER].tval != TV_NOTHING)
k = INVEN_OUTER;
else if (inventory[INVEN_HEAD].tval != TV_NOTHING)
k = INVEN_HEAD;
else if (inventory[INVEN_HANDS].tval != TV_NOTHING)
k = INVEN_HANDS;
else if (inventory[INVEN_FEET].tval != TV_NOTHING)
k = INVEN_FEET;
else
k = 0;
if (k > 0)
{
i_ptr = &inventory[k];
objdes(tmp_str, i_ptr, FALSE);
(void)sprintf(out_val,"Your %s glows black, fades.",tmp_str);
msg_print(out_val);
unmagic_name(i_ptr);
i_ptr->flags = TR_CURSED;
i_ptr->toac = -randint(5) - randint(5);
calc_bonuses ();
ident = TRUE;
}
break;
case 37:
ident = FALSE;
for (k = 0; k < randint(3); k++)
{
y = char_row;
x = char_col;
ident |= summon_undead(&y, &x);
}
break;
case 38:
ident = TRUE;
bless(randint(12)+6);
break;
case 39:
ident = TRUE;
bless(randint(24)+12);
break;
case 40:
ident = TRUE;
bless(randint(48)+24);
break;
case 41:
ident = TRUE;
if (py.flags.word_recall == 0)
py.flags.word_recall = 25 + randint(30);
msg_print("The air about you becomes charged.");
break;
case 42:
destroy_area(char_row, char_col);
ident = TRUE;
break;
case 43:
place_special(char_row, char_col, SPECIAL);
prt_map();
break;
case 44:
special_random_object(char_row, char_col, 1);
prt_map();
break;
default:
msg_print("Internal error in scroll()");
break;
}
/* End of Scrolls. */
}
i_ptr = &inventory[item_val];
if (ident)
{
if (!known1_p(i_ptr))
{
m_ptr = &py.misc;
/* round half-way case up */
m_ptr->exp += (i_ptr->level +(m_ptr->lev >> 1)) / m_ptr->lev;
prt_experience();
identify(&item_val);
i_ptr = &inventory[item_val];
}
}
