public static void wr_artifacts()
{
int i;
ushort tmp16u;
/* Hack -- Dump the artifacts */
tmp16u = Misc.z_info.a_max;
wr_u16b(tmp16u);
for (i = 0; i < tmp16u; i++) {
Artifact a_ptr = Misc.a_info[i];
if (a_ptr == null) {
a_ptr = new Artifact();
}
wr_byte(a_ptr.created);
wr_byte(a_ptr.seen);
wr_byte(a_ptr.everseen);
wr_byte(0);
}
}
/*
* Adding artifacts to the history list is trickier than other operations.
* This is a wrapper function that gets some of the logic out of places
* where it really doesn't belong. Call this to add an artifact to the history
* list or make the history entry visible--history_add_artifact will make that
* determination depending on what object_is_known returns for the artifact.
*/
public static bool add_artifact(Artifact artifact, bool known, bool found)
{
throw new NotImplementedException();
//object_type object_type_body;
//object_type *o_ptr = &object_type_body;
//char o_name[80];
//char buf[80];
//u16b type;
//assert(artifact);
///* Make fake artifact for description purposes */
//object_wipe(o_ptr);
//make_fake_artifact(o_ptr, artifact);
//object_desc(o_name, sizeof(o_name), o_ptr,
// ODESC_PREFIX | ODESC_BASE | ODESC_SPOIL);
//strnfmt(buf, sizeof(buf), (found)?"Found %s":"Missed %s", o_name);
///* Known objects gets different treatment */
//if (known) {
// /* Try revealing any existing artifact, otherwise log it */
// if (history_is_artifact_logged(artifact))
// history_know_artifact(artifact);
// else
// history_add(buf, HISTORY_ARTIFACT_KNOWN, artifact);
//} else {
// if (!history_is_artifact_logged(artifact)) {
// type = HISTORY_ARTIFACT_UNKNOWN |
// (found ? 0 : HISTORY_ARTIFACT_LOST);
// history_add(buf, type, artifact);
// } else {
// return false;
// }
//}
//return true;
}
/*
* Mark artifact number `id` as lost forever, either due to leaving it on a
* level, or due to a store purging its inventory after the player sold it.
*/
public static bool lose_artifact(Artifact artifact)
{
throw new NotImplementedException();
//size_t i = history_ctr;
//assert(artifact);
//while (i--) {
// if (history_list[i].a_idx == artifact.aidx) {
// history_list[i].type |= HISTORY_ARTIFACT_LOST;
// return true;
// }
//}
///* If we lost an artifact that didn't previously have a history, then we missed it */
//history_add_artifact(artifact, false, false);
//return false;
}
/*
* Add an entry with text `event` to the history list, with type `type`
* ("HISTORY_xxx" in defines.h), and artifact number `id` (0 for everything
* else).
*
* Returne true on success.
*/
public static bool add(string evt, ushort type, Artifact artifact)
{
Player.Player p_ptr = Player.Player.instance;
return add_full(type, artifact, p_ptr.depth, p_ptr.lev, Misc.turn, evt);
}
/*
* Returns true if the artifact denoted by a_idx is an active entry in
* the history log (i.e. is not marked HISTORY_ARTIFACT_LOST). This permits
* proper handling of the case where the player loses an artifact but (in
* preserve mode) finds it again later.
*/
public static bool history_is_artifact_logged(Artifact artifact)
{
throw new NotImplementedException();
//size_t i = history_ctr;
//assert(artifact);
//while (i--) {
// /* Don't count ARTIFACT_LOST entries; then we can handle
// * re-finding previously lost artifacts in preserve mode */
// if (history_list[i].type & HISTORY_ARTIFACT_LOST)
// continue;
// if (history_list[i].a_idx == artifact.aidx)
// return true;
//}
//return false;
}
/*
* Mark artifact number `id` as known.
*/
public static bool history_know_artifact(Artifact artifact)
{
throw new NotImplementedException();
//size_t i = history_ctr;
//assert(artifact);
//while (i--) {
// if (history_list[i].a_idx == artifact.aidx) {
// history_list[i].type = HISTORY_ARTIFACT_KNOWN;
// return true;
// }
//}
//return false;
}
/*
* Add an entry with text `event` to the history list, with type `type`
* ("HISTORY_xxx" in defines.h), and artifact number `id` (0 for everything
* else).
*
* Return true on success.
*/
public static bool add_full(ushort type, Artifact artifact, short dlev, short clev, int turn, string text)
{
/* Allocate the history list if needed */
if (history_list == null)
init(HISTORY_BIRTH_SIZE);
/* Expand the history list if appropriate */
else if ((history_ctr == history_size) && !set_num(history_size + 10))
return false;
/* History list exists and is not full. Add an entry at the current counter location. */
history_list[history_ctr] = new Info();
history_list[history_ctr].type = type;
history_list[history_ctr].dlev = dlev;
history_list[history_ctr].clev = clev;
history_list[history_ctr].a_idx = (byte)(artifact != null ? artifact.aidx : 0);
history_list[history_ctr].turn = turn;
history_list[history_ctr].evt = text;
history_ctr++;
return true;
}
/*
* Mega-Hack -- Attempt to create one of the "Special Objects".
*
* We are only called from "make_object()"
*
* Note -- see "make_artifact()" and "apply_magic()".
*
* We *prefer* to create the special artifacts in order, but this is
* normally outweighed by the "rarity" rolls for those artifacts.
*/
static bool make_artifact_special(ref Object o_ptr, int level)
{
int i;
Object_Kind kind;
/* No artifacts, do nothing */
if (Option.birth_no_artifacts.value)
{
return(false);
}
/* No artifacts in the town */
if (Misc.p_ptr.depth == 0)
{
return(false);
}
/* Check the special artifacts */
for (i = 0; i < Misc.ART_MIN_NORMAL; ++i)
{
Artifact a_ptr = Misc.a_info[i];
/* Skip "empty" artifacts */
if (a_ptr == null)
{
continue;
}
/* Cannot make an artifact twice */
if (a_ptr.created)
{
continue;
}
/* Enforce minimum "depth" (loosely) */
if (a_ptr.alloc_min > Misc.p_ptr.depth)
{
/* Get the "out-of-depth factor" */
int d = (a_ptr.alloc_min - Misc.p_ptr.depth) * 2;
/* Roll for out-of-depth creation */
if (Random.randint0(d) != 0)
{
continue;
}
}
/* Enforce maximum depth (strictly) */
if (a_ptr.alloc_max < Misc.p_ptr.depth)
{
continue;
}
/* Artifact "rarity roll" */
if (Random.randint1(100) > a_ptr.alloc_prob)
{
continue;
}
/* Find the base object */
kind = Object_Kind.lookup_kind(a_ptr.tval, a_ptr.sval);
/* Make sure the kind was found */
if (kind == null)
{
continue;
}
/* Enforce minimum "object" level (loosely) */
if (kind.level > level)
{
/* Get the "out-of-depth factor" */
int d = (kind.level - level) * 5;
/* Roll for out-of-depth creation */
if (Random.randint0(d) != 0)
{
continue;
}
}
/* Assign the template */
o_ptr.prep(kind, a_ptr.alloc_min, aspect.RANDOMISE);
/* Mark the item as an artifact */
o_ptr.artifact = a_ptr;
/* Copy across all the data from the artifact struct */
o_ptr.copy_artifact_data(a_ptr);
/* Mark the artifact as "created" */
a_ptr.created = true;
/* Success */
return(true);
}
/* Failure */
return(false);
}
/* Parsing functions for artifact.txt */
public static Parser.Error parse_a_n(Parser p)
{
Bitflag f = new Bitflag(Object_Flag.SIZE);
int idx = p.getint("index");
string name = p.getstr("name");
Artifact h = p.priv as Artifact;
Artifact a = new Artifact();
a.Next = h;
p.priv = a;
a.aidx = (byte)idx;
a.Name = name;
/* Ignore all elements */
Object_Flag.create_mask(f, false, Object_Flag.object_flag_type.IGNORE);
a.flags.union(f);
return Parser.Error.NONE;
}
//This has a single special use
static Parser.Error grab_flag_helper3(string s, Artifact e)
{
string[] t = s.Split(new string[] { " ","|" }, StringSplitOptions.RemoveEmptyEntries);
string temp;
foreach(string token in t) {
temp = token;
if(grab_flag(e.flags, Object_Flag.list, token) == Parser.Error.NONE ||
grab_flag(e.pval_flags[e.num_pvals], Object_Flag.list, token) == Parser.Error.NONE) {
break;
}
}
e.num_pvals++;
if (e.num_pvals > Misc.MAX_PVALS)
return Parser.Error.TOO_MANY_ENTRIES;
return Parser.Error.NONE;
}
/**
* Copy artifact data to a normal object, and set various slightly hacky
* globals.
*/
public void copy_artifact_data(Artifact a_ptr)
{
int i;
/* Extract the data */
for(i = 0; i < a_ptr.num_pvals; i++) {
if(a_ptr.pval[i] != 0) {
pval[i] = a_ptr.pval[i];
pval_flags[i].copy(a_ptr.pval_flags[i]);
}
}
num_pvals = a_ptr.num_pvals;
ac = a_ptr.ac;
dd = a_ptr.dd;
ds = a_ptr.ds;
to_a = a_ptr.to_a;
to_h = a_ptr.to_h;
to_d = a_ptr.to_d;
weight = a_ptr.weight;
flags.union(a_ptr.flags);
}
