static ast.Node _ExpandMacros(ast.Node node)
{
if (!(node is ast.CallExpression))
{
return(node);
}
ast.CallExpression callExpression = (ast.CallExpression)node;
Object.Macro macro = isMacroCall(callExpression, _env);
if (macro == null)
{
return(node);
}
List <Object.Quote> args = quoteArgs(callExpression);
Object.Environment evalEnv = extendMacroEnv(macro, args);
Object.Object evaluated = evaluator.Eval(macro.Body, evalEnv);
if (!(evaluated is Object.Quote))
{
System.Console.WriteLine("we only support returning AST-nodes from macros");
System.Environment.Exit(-1);
}
Object.Quote quote = (Object.Quote)evaluated;
return(quote.Node);
}
public void OnEnterMap(Object.Object obj)
{
if (obj is Player)
{
var playr = obj as Player;
if (playr == this)
{
return;
}
}
if (obj is Object.Mobile)
{
if (obj is Object.Npc)
{
gameLink.Send(new GameOutMessage.CreateNPC(obj as Object.Npc).Compile());
}
else if (obj is Object.Mineral)
{
gameLink.Send(new GameOutMessage.CreateMineral(obj as Object.Mineral).Compile());
}
else if (obj is Object.Craft)
{
gameLink.Send(new GameOutMessage.CreateMineral(obj as Object.Craft).Compile());
}
else
{
var mobile = obj as Object.Mobile;
gameLink.Send(new GameOutMessage.CreateMobile(mobile).Compile());
gameLink.Send(new GameOutMessage.SetObjectEffects(mobile).Compile());
}
}
}
static Object.Object evalInfixExpression(string operator_, Object.Object left, Object.Object right)
{
if (left.Type() == Object._ObjType.INTEGER_OBJ && right.Type() == Object._ObjType.INTEGER_OBJ)
{
return(evalIntegerInfixExpression(operator_, left, right));
}
if (left.Type() == Object._ObjType.STRING_OBJ && right.Type() == Object._ObjType.STRING_OBJ)
{
return(evalStringInfixExpression(operator_, left, right));
}
if (operator_ == "==")
{
return(nativeToBooleanObject(left == right));
}
if (operator_ == "!=")
{
return(nativeToBooleanObject(left != right));
}
if (left.Type() != right.Type())
{
return(newError("type mismatch: {0} {1} {2}", left.Type(), operator_, right.Type()));
}
// default:
return(newError("unknown operator: {0} {1} {2}", left.Type(), operator_, right.Type()));
}
static Object.Object evalHashLiteral(ast.HashLiteral node, Object.Environment env)
{
Dictionary <Object.HashKey, Object.HashPair> pairs = new Dictionary <Object.HashKey, Object.HashPair>();
foreach (KeyValuePair <ast.Expression, ast.Expression> _node_pair in node.Pairs)
{
Object.Object key = Eval(_node_pair.Key, env);
if (isError(key))
{
return(key);
}
if (!(key is Object.Hashable))
{
return(newError("unusable as hash key: {0}", key.Type()));
}
Object.Hashable hashKey = (Object.Hashable)key;
Object.Object value = Eval(_node_pair.Value, env);
if (isError(value))
{
return(value);
}
Object.HashKey hashed = hashKey.HashKey();
pairs.Add(hashed, new Object.HashPair {
Key = key, Value = value
});
}
return(new Object.Hash {
Pairs = pairs
});
}
private static Object.Object EvalHashLiteral(HashLiteral node, Object.Environment env)
{
var pairs = new Dictionary <HashKey, HashPair>();
foreach (KeyValuePair <Expression, Expression> pair in node.Pairs)
{
Object.Object key = Eval(pair.Key, env);
if (IsError(key))
{
return(key);
}
var hashKey = key as IHash;
if (hashKey == null)
{
return(new Error {
Message = $"unusable as hash key: {key.Type()}"
});
}
var value = Eval(pair.Value, env);
if (IsError(value))
{
return(value);
}
var hashed = hashKey.HashKey();
pairs.Add(hashed, new HashPair {
Key = key, Value = value
});
}
return(new Hash {
Pairs = pairs
});
}
static Object.Object len(List <Object.Object> args) // used List<> instead of params
{
if (args.Count != 1)
{
return(evaluator.newError("wrong number of arguments. got={0}, want={1}", args.Count.ToString()));
}
Object.Object arg = args[0];
if (arg is Object.Array)
{
return new Object.Integer {
Value = (long)((Object.Array)arg).Elements.Count
}
}
;
if (arg is Object.String)
{
return new Object.Integer {
Value = (long)((Object.String)arg).Value.Length
}
}
;
// default:
return(evaluator.newError("argument to 'len' not supported, got {0}", args[0].Type()));
}
private static Object.Object EvalInfixExpression(string op, Object.Object left, Object.Object right)
{
if (left.Type() != right.Type())
{
return(new Object.Error {
Message = $"type mismatch: {left.Type()} {op} {right.Type()}"
});
}
if (left.Type() == Object.ObjectType.INTEGER_OBJ && right.Type() == Object.ObjectType.INTEGER_OBJ)
{
return(EvaIntegerInfixExpression(op, left, right));
}
if (left.Type() == Object.ObjectType.STRING_OBJ && right.Type() == Object.ObjectType.STRING_OBJ)
{
return(EvalStringInfixExpression(op, left, right));
}
switch (op)
{
case "==":
return(NativeBoolToBooleanObject(left == right));
case "!=":
return(NativeBoolToBooleanObject(left != right));
default:
return(new Object.Error {
Message = $"unknown operator: {left.Type()} {op} {right.Type()}"
});
}
}
static Object.Object buildHash(int startIndex, int endIndex, out error _err)
{
Dictionary <Object.HashKey, Object.HashPair> hashedPairs = new Dictionary <Object.HashKey, Object.HashPair>();
for (int i = startIndex; i < endIndex; i += 2)
{
Object.Object key = vm.stack[i];
Object.Object value = vm.stack[i + 1];
Object.HashPair pair = new Object.HashPair {
Key = key, Value = value
};
if (!(key is Object.Hashable))
{
_err = string.Format("unusable as hash key: {0}", key.Type());
return(null);
}
Object.Hashable hashKey = (Object.Hashable)key;
hashedPairs.Add(hashKey.HashKey(), pair);
}
_err = null;
return(new Object.Hash {
Pairs = hashedPairs
});
}
static error executeBinaryIntegerOperation(Opcode op, Object.Object left, Object.Object right)
{
long leftValue = ((Object.Integer)left).Value;
long rightValue = ((Object.Integer)right).Value;
long result;
switch (op)
{
case code.OpAdd:
result = leftValue + rightValue;
break;
case code.OpSub:
result = leftValue - rightValue;
break;
case code.OpMul:
result = leftValue * rightValue;
break;
case code.OpDiv:
result = leftValue / rightValue;
break;
default:
return(string.Format("unknown integer operator: {0:D}", op));
}
return(push(new Object.Integer {
Value = result
}));
}
private static void runFile(string path) // REPL without the loop
{
Object.Environment env = Object.Environment.NewEnvironment();
Object.Environment macroEnv = Object.Environment.NewEnvironment();
string source = readFile(path);
lexer.Lexer l = lexer.Lexer.New(source);
parser.Parser p = parser.Parser.New(l);
ast.Program program = p.ParseProgram();
if (parser.Parser.Errors().Count != 0)
{
repl.printParserErrors(parser.Parser.Errors());
System.Environment.Exit(77);
}
evaluator.macro_expansion.DefineMacros(program, macroEnv);
ast.Node expanded = evaluator.macro_expansion.ExpandMacros(program, macroEnv);
Object.Object evaluated = evaluator.evaluator.Eval(expanded, env);
if (evaluated != null)
{
System.Console.Write(evaluated.Inspect());
System.Console.WriteLine();
}
}
public static void Start()
{
Object.Environment env = Object.Environment.NewEnvironment();
Object.Environment macroEnv = Object.Environment.NewEnvironment();
for (;;)
{
System.Console.Write(PROMPT);
string line = System.Console.ReadLine();
lexer.Lexer l = lexer.Lexer.New(line);
parser.Parser p = parser.Parser.New(l);
ast.Program program = p.ParseProgram();
if (parser.Parser.Errors().Count != 0)
{
printParserErrors(parser.Parser.Errors());
continue;
}
evaluator.macro_expansion.DefineMacros(program, macroEnv);
ast.Node expanded = evaluator.macro_expansion.ExpandMacros(program, macroEnv);
Object.Object evaluated = evaluator.evaluator.Eval(expanded, env);
if (evaluated != null)
{
System.Console.Write(evaluated.Inspect());
System.Console.WriteLine();
}
}
}
public void OnLeave(Object.Object obj)
{
if (_FleaveMap != null)
{
_FleaveMap(obj);
}
}
static error executeIntegerComparison(Opcode op, Object.Object left, Object.Object right)
{
long leftValue = ((Object.Integer)left).Value;
long rightValue = ((Object.Integer)right).Value;
switch (op)
{
case Opcode.OpEqual:
return(push(nativeToBooleanObject(rightValue == leftValue)));
case Opcode.OpNotEqual:
return(push(nativeToBooleanObject(rightValue != leftValue)));
case Opcode.OpGreaterThan:
return(push(nativeToBooleanObject(leftValue > rightValue)));
case Opcode.OpGreaterThanEqual:
return(push(nativeToBooleanObject(leftValue >= rightValue)));
case Opcode.OpLessThan:
return(push(nativeToBooleanObject(leftValue < rightValue)));
case Opcode.OpLessThanEqual:
return(push(nativeToBooleanObject(leftValue <= rightValue)));
default:
return(string.Format("unknown operator: {0:D}", op));
}
}
static Object.Object pop()
{
Object.Object o = vm.stack[vm.sp - 1];
vm.sp--;
return(o);
}
public static void Start(TextReader reader, TextWriter writer)
{
var env = new Object.Environment();
while (true)
{
writer.Write(_PROMPT);
var input = reader.ReadLine();
if (string.IsNullOrWhiteSpace(input))
{
return;
}
try
{
var lexer = Lexer.Create(input);
var parser = new Parser(lexer);
var program = parser.ParseProgram();
Object.Object evaluated = Evaluator.Eval(program, env);
if (evaluated != null)
{
writer.Write(evaluated.Inspect());
writer.Write(Environment.NewLine);
}
}
catch (ParserException e)
{
writer.Write(e.Message);
writer.Write(Environment.NewLine);
}
}
}
public Object.Object addObject(Object.Object _Object, Boolean _InsertInQuadTree, Region.Region _Region)
{
if (_InsertInQuadTree)
{
this.quadTreeObject.Insert(_Object);
}
if (_Region != null)
{
Chunk.Chunk chunk = _Region.getChunkAtPosition(_Object.Position);
if (chunk != null)
{
Block.Block var_Block = chunk.getBlockAtCoordinate(_Object.Position);
if (var_Block != null)
{
var_Block.addObject(_Object);
if (Configuration.Configuration.isHost)
{
Configuration.Configuration.networkManager.addEvent(new GameLibrary.Connection.Message.UpdateObjectMessage(_Object), GameMessageImportance.VeryImportant);
}
}
}
}
else
{
Logger.Logger.LogInfo("World.addObject: Object konnte der Region nicht hinzugefügt werden, da diese null war");
}
return(_Object);
}
private static Object.Object unwrapReturnValue(Object.Object obj)
{
if (obj is Object.ReturnValue)
{
return(((Object.ReturnValue)obj).Value);
}
return(obj);
}
static bool isError(Object.Object obj)
{
if (obj != null)
{
return(obj.Type() == Object._ObjType.ERROR_OBJ);
}
return(false);
}
public void addObject(Object.Object _Object)
{
if (!this.objects.Contains(_Object))
{
this.objects.Add(_Object);
}
_Object.CurrentBlock = this;
}
public void addPreEnvironmentObject(Object.Object _Object)
{
if (!this.objectsPreEnviorment.Contains(_Object))
{
this.objectsPreEnviorment.Add(_Object);
}
_Object.CurrentBlock = this;
}
public async Task <Object.Object> GetObject(GetRequest request, DateTime?deadline = null, CancellationToken context = default)
{
using var call = ObjectClient.Get(request, deadline: deadline, cancellationToken: context);
var obj = new Object.Object();
var payload = Array.Empty <byte>();
int offset = 0;
while (await call.ResponseStream.MoveNext())
{
var resp = call.ResponseStream.Current;
if (!resp.Verify())
{
throw new InvalidOperationException("invalid object get response");
}
CheckStatus(resp);
switch (resp.Body.ObjectPartCase)
{
case GetResponse.Types.Body.ObjectPartOneofCase.Init:
{
obj.ObjectId = resp.Body.Init.ObjectId;
obj.Signature = resp.Body.Init.Signature;
obj.Header = resp.Body.Init.Header;
payload = new byte[obj.PayloadSize];
break;
}
case GetResponse.Types.Body.ObjectPartOneofCase.Chunk:
{
if (payload.Length == 0)
{
throw new InvalidOperationException("missing init");
}
var chunk = resp.Body.Chunk;
if (obj.PayloadSize < (ulong)(offset + chunk.Length))
{
throw new InvalidOperationException("data exceeds PayloadSize");
}
resp.Body.Chunk.CopyTo(payload, offset);
offset += chunk.Length;
break;
}
case GetResponse.Types.Body.ObjectPartOneofCase.SplitInfo:
{
throw new SplitInfoException(resp.Body.SplitInfo);
}
default:
throw new FormatException("malformed object get reponse");
}
}
if ((ulong)offset < obj.PayloadSize)
{
throw new InvalidOperationException("data is less than PayloadSize");
}
obj.Payload = ByteString.CopyFrom(payload);
return(obj);
}
public Object.Object addObject(Object.Object _Object, Boolean _InsertInQuadTree, Region.Region _Region)
{
Dimension.Dimension var_Dimension = this.getDimensionById(_Object.DimensionId);
if (var_Dimension != null)
{
return(var_Dimension.addObject(_Object, _InsertInQuadTree, _Region));
}
return(null);
}
public bool removeObjectFromWorld(Object.Object _Object)
{
Dimension.Dimension var_Dimension = this.getDimensionById(_Object.DimensionId);
if (var_Dimension != null)
{
var_Dimension.removeObjectFromWorld(_Object);
}
return(false);
}
private void DrawPoints(Object.Object obj)
{
for (int i = 0; i < projected.Count; i++)
{
Point point = projected[i];
Rectangle rect = new Rectangle(point.X - PointSize / 2, point.Y - PointSize / 2, PointSize, PointSize);
graph.FillEllipse(brush, rect);
}
}
public void OnLeaveMap(Object.Object objt)
{
if (objt == this)
{
return;
}
gameLink.Send(new GameOutMessage.DeleteObject(objt.objId).Compile());
}
private void DrawLines(Object.Object obj)
{
foreach (Model.Edge edge in obj.Model.Edges)
{
if (projected[edge.AIndex].X != -1 && projected[edge.BIndex].Y != -1)
{
graph.DrawLine(PerspectiveEffect ? new Pen(Color, (float)EvaluateWidth(edge)) : pen, projected[edge.AIndex], projected[edge.BIndex]);
}
}
}
public Object.Object addPreEnvironmentObject(Object.Object _Object)
{
Dimension.Dimension var_Dimension = this.getDimensionById(_Object.DimensionId);
Region.Region var_Region = var_Dimension.getRegionObjectIsIn(_Object);
if (var_Dimension != null)
{
return(var_Dimension.addPreEnvironmentObject(_Object, var_Region));
}
return(null);
}
public static Object.Object EvalPrefixExpression(PrefixExpression expression)
{
Object.Object right = Eval(expression.Right);
Object.IntegerObject rightInteger = right as Object.IntegerObject;
if(rightInteger == null)
{
throw new Exception("Prefix expression right is not Object.IntegerObject");
}
return new Object.IntegerObject { Value = -1 * rightInteger.Value };
}
private void Draw(Object.Object obj)
{
Project(obj);
if (DisplayLines)
{
DrawLines(obj);
}
if (DisplayPoints)
{
DrawPoints(obj);
}
}
static error push(Object.Object o)
{
if (vm.sp >= StackSize)
{
return("stack overflow");
}
vm.stack[vm.sp] = o;
vm.sp++;
return(null);
}
public static void test_breakage_chance()
{
Object.Object obj = new Object.Object();
int c;
obj.prep(UnitTest_Data.Longsword(), 1, aspect.AVERAGE);
c = obj.breakage_chance(true);
Equal(c, 50);
c = obj.breakage_chance(false);
Equal(c, 25);
obj.artifact = UnitTest_Data.Artifact_Sword();
c = obj.breakage_chance(true);
Equal(c, 0);
c = obj.breakage_chance(false);
Equal(c, 0);
Ok();
}
/*
* Attack the player via physical attacks.
*/
//TODO: Submit this function to the Guiness book of world records for "Longest f*****g function"
//TODO: Refactor this. Refactor this so f*****g hard.
public bool make_attack_normal(Player.Player p)
{
Monster_Race r_ptr = Misc.r_info[r_idx];
Monster_Lore l_ptr = Misc.l_list[r_idx];
int i, tmp;
short gold;
string o_name;
// Not allowed to attack
if (r_ptr.flags.has(Monster_Flag.NEVER_BLOW.value)) return false;
// Total armor
int ac = p.state.ac + p.state.to_a;
// Extract the effective monster level
int rlev = ((r_ptr.level >= 1) ? r_ptr.level : 1);
// Get the monster name (or "it")
string m_name = monster_desc(0);
// Get the "died from" information (i.e. "a kobold")
string ddesc = monster_desc(Desc.SHOW | Desc.IND2);
// Assume no blink
bool blinked = false;
// Scan through all blows
for (int ap_cnt = 0; ap_cnt < Monster_Blow.MONSTER_BLOW_MAX; ap_cnt++)
{
bool visible = false;
bool obvious = false;
bool do_break = false;
int power = 0;
int damage = 0;
string act = null;
if(r_ptr.blow[ap_cnt] == null) {
continue;
}
// Extract the attack infomation
RBE effect = r_ptr.blow[ap_cnt].effect;
RBM method = r_ptr.blow[ap_cnt].method;
int d_dice = r_ptr.blow[ap_cnt].d_dice;
int d_side = r_ptr.blow[ap_cnt].d_side;
// Hack -- no more attacks
if (method == RBM.NONE) break;
// Handle "leaving"
if (p.leaving) break;
// Extract visibility (before blink)
if (ml) visible = true;
// Extract visibility from carrying light
if (r_ptr.flags.has(Monster_Flag.HAS_LIGHT.value)) visible = true;
power = effect.power;
// Monster hits player
if (effect == null || check_hit(p, power, rlev))
{
// Always disturbing
Cave.disturb(p, 1, 0);
// Hack -- Apply "protection from evil"
if (p.timed[(int)Timed_Effect.PROTEVIL] > 0)
{
// Learn about the evil flag
if (ml)
{
l_ptr.flags.on(Monster_Flag.EVIL.value);
}
if (r_ptr.flags.has(Monster_Flag.EVIL.value) && p.lev >= rlev && Random.randint0(100) + p.lev > 50)
{
// Message
Utilities.msg("%^s is repelled.", m_name);
// Hack -- Next attack
continue;
}
}
// Assume no cut or stun
bool do_cut = method.do_cut;
bool do_stun = method.do_stun;
// Assume no sound
Message_Type sound_msg = method.sound_msg;
act = method.action;
// Describe the attack method
if (method == RBM.INSULT){
throw new NotImplementedException();
//act = desc_insult[Random.randint0(Misc.MAX_DESC_INSULT)];
} else if (method == RBM.MOAN){
throw new NotImplementedException();
//act = desc_moan[Random.randint0(Misc.MAX_DESC_MOAN)];
}
// Message
if(act != null) {
string name = Char.ToUpper(m_name[0]) + m_name.Substring(1);
Utilities.msgt(sound_msg, "{0} {1}", name, act);
}
// Hack -- assume all attacks are obvious
obvious = true;
// Roll out the damage
if (d_dice > 0 && d_side > 0)
damage = Random.damroll(d_dice, d_side);
else
damage = 0;
// Apply appropriate damage
if (effect.value == 0){
// Hack -- Assume obvious
obvious = true;
// Hack -- No damage
damage = 0;
} else if (effect.value == RBE.HURT.value)
{
// Obvious
obvious = true;
// Hack -- Player armor reduces total damage
damage -= (damage * ((ac < 240) ? ac : 240) / 400);
// Take damage
Spell.take_hit(p, damage, ddesc);
} else if ( effect.value == RBE.POISON.value)
{
damage = Spell.adjust_dam(p, GF.POIS, damage, aspect.RANDOMISE,
Spell.check_for_resist(p, GF.POIS, p.state.flags, true));
// Take damage
Spell.take_hit(p, damage, ddesc);
// Take "poison" effect
if (p.inc_timed(Timed_Effect.POISONED, Random.randint1(rlev) + 5, true, true))
obvious = true;
// Learn about the player
monster_learn_resists(p, GF.POIS);
} else if (effect.value == RBE.UN_BONUS.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Allow complete resist
//if (!check_state(p, OF_RES_DISEN, p.state.flags))
//{
// // Apply disenchantment
// if (apply_disenchant(0)) obvious = true;
//}
//// Learn about the player
//monster_learn_resists(m_ptr, p, GF_DISEN);
} else if (effect.value == RBE.UN_POWER.value)
{
throw new NotImplementedException();
//int unpower = 0, newcharge;
//// Take damage
//take_hit(p, damage, ddesc);
//// Find an item
//for (k = 0; k < 10; k++)
//{
// // Pick an item
// i = randint0(INVEN_PACK);
// // Obtain the item
// o_ptr = &p.inventory[i];
// // Skip non-objects
// if (!o_ptr.kind) continue;
// // Drain charged wands/staves
// if ((o_ptr.tval == TV_STAFF) ||
// (o_ptr.tval == TV_WAND))
// {
// // Charged?
// if (o_ptr.pval[DEFAULT_PVAL])
// {
// // Get number of charge to drain
// unpower = (rlev / (o_ptr.kind.level + 2)) + 1;
// // Get new charge value, don't allow negative
// newcharge = MAX((o_ptr.pval[DEFAULT_PVAL]
// - unpower),0);
// // Remove the charges
// o_ptr.pval[DEFAULT_PVAL] = newcharge;
// }
// }
// if (unpower)
// {
// int heal = rlev * unpower;
// msg("Energy drains from your pack!");
// obvious = true;
// // Don't heal more than max hp
// heal = MIN(heal, maxhp - hp);
// // Heal
// hp += heal;
// // Redraw (later) if needed
// if (cave_monster(cave, p.health_who) == m_ptr)
// p.redraw |= (PR_HEALTH);
// // Combine / Reorder the pack
// p.notice |= (PN_COMBINE | PN_REORDER);
// // Redraw stuff
// p.redraw |= (PR_INVEN);
// // Affect only a single inventory slot
// break;
// }
//}
} else if (effect.value == RBE.EAT_GOLD.value)
{
// Take damage
Spell.take_hit(p, damage, ddesc);
// Obvious
obvious = true;
// Saving throw (unless paralyzed) based on dex and level
if (p.timed[(int)Timed_Effect.PARALYZED] == 0 &&
(Random.randint0(100) < (Player.Player.adj_dex_safe[p.state.stat_ind[(int)Stat.Dex]] + p.lev)))
{
// Saving throw message
Utilities.msg("You quickly protect your money pouch!");
// Occasional blink anyway
if (Random.randint0(3) != 0) blinked = true;
}
// Eat gold
else {
gold = (short)((p.au / 10) + Random.randint1(25));
if (gold < 2) gold = 2;
if (gold > 5000) gold = (short)((p.au / 20) + Random.randint1(3000));
if (gold > p.au) gold = (short)p.au;
p.au -= gold;
if (gold <= 0) {
Utilities.msg("Nothing was stolen.");
break;
}
// Let the player know they were robbed
Utilities.msg("Your purse feels lighter.");
if (p.au != 0)
Utilities.msg("{0} coins were stolen!", (long)gold);
else
Utilities.msg("All of your coins were stolen!");
// While we have gold, put it in objects
while (gold > 0) {
int amt;
// Create a new temporary object
//object_type o;
//object_wipe(&o);
Object.Object o = new Object.Object();
o.prep(Object.Object_Kind.objkind_get(TVal.TV_GOLD, (int)SVal.sval_gold.SV_GOLD), 0, aspect.MINIMISE);
// Amount of gold to put in this object
amt = gold > Misc.MAX_PVAL ? Misc.MAX_PVAL : gold;
o.pval[Misc.DEFAULT_PVAL] = (short)amt;
gold -= (short)amt;
// Set origin to stolen, so it is not confused with
// dropped treasure in monster_death
o.origin = Origin.STOLEN;
// Give the gold to the monster
carry(o);
}
// Redraw gold
p.redraw |= (Misc.PR_GOLD);
// Blink away
blinked = true;
}
} else if (effect.value == RBE.EAT_ITEM.value)
{
// Take damage
Spell.take_hit(p, damage, ddesc);
// Saving throw (unless paralyzed) based on dex and level
if (p.timed[(int)Timed_Effect.PARALYZED] == 0 &&
(Random.randint0(100) < (Player.Player.adj_dex_safe[p.state.stat_ind[(int)Stat.Dex]] +
p.lev)))
{
// Saving throw message
Utilities.msg("You grab hold of your backpack!");
// Occasional "blink" anyway
blinked = true;
// Obvious
obvious = true;
// Done
break;
}
// Find an item
for (int k = 0; k < 10; k++)
{
Object.Object i_ptr;
//object_type object_type_body;
// Pick an item
i = Random.randint0(Misc.INVEN_PACK);
// Obtain the item
Object.Object o_ptr = p.inventory[i];
// Skip non-objects
if (o_ptr.kind == null) continue;
// Skip artifacts
if (o_ptr.artifact != null) continue;
// Get a description
o_name = o_ptr.object_desc(Object.Object.Detail.FULL);
// Message
Utilities.msg("{0}our {1} ({2}) was stolen!",
((o_ptr.number > 1) ? "One of y" : "Y"),
o_name, Object.Object.index_to_label(i));
// Get local object
i_ptr = new Object.Object();//&object_type_body;
// Obtain local object
i_ptr = o_ptr.copy();
// Modify number
i_ptr.number = 1;
// Hack -- If a rod, staff, or wand, allocate total
// maximum timeouts or charges between those
// stolen and those missed. -LM-
o_ptr.distribute_charges(i_ptr, 1);
// Carry the object
carry(i_ptr);
// Steal the items
Object.Object.inven_item_increase(i, -1);
Object.Object.inven_item_optimize(i);
// Obvious
obvious = true;
// Blink away
blinked = true;
// Done
break;
}
} else if (effect.value == RBE.EAT_FOOD.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Steal some food
//for (k = 0; k < 10; k++)
//{
// // Pick an item from the pack
// i = randint0(INVEN_PACK);
// // Get the item
// o_ptr = &p.inventory[i];
// // Skip non-objects
// if (!o_ptr.kind) continue;
// // Skip non-food objects
// if (o_ptr.tval != TV_FOOD) continue;
// // Get a description
// object_desc(o_name, sizeof(o_name), o_ptr,
// ODESC_PREFIX | ODESC_BASE);
// // Message
// msg("%sour %s (%c) was eaten!",
// ((o_ptr.number > 1) ? "One of y" : "Y"),
// o_name, index_to_label(i));
// // Steal the items
// inven_item_increase(i, -1);
// inven_item_optimize(i);
// // Obvious
// obvious = true;
// // Done
// break;
//}
} else if (effect.value == RBE.EAT_LIGHT.value)
{
throw new NotImplementedException();
//bitflag f[OF_SIZE];
//// Take damage
//take_hit(p, damage, ddesc);
//// Get the light, and its flags
//o_ptr = &p.inventory[INVEN_LIGHT];
//object_flags(o_ptr, f);
//// Drain fuel where applicable
//if (!of_has(f, OF_NO_FUEL) && (o_ptr.timeout > 0))
//{
// // Reduce fuel
// o_ptr.timeout -= (250 + randint1(250));
// if (o_ptr.timeout < 1) o_ptr.timeout = 1;
// // Notice
// if (!p.timed[TMD_BLIND])
// {
// msg("Your light dims.");
// obvious = true;
// }
// // Redraw stuff
// p.redraw |= (PR_EQUIP);
//}
} else if (effect.value == RBE.ACID.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Message
//msg("You are covered in acid!");
//// Special damage
//damage = adjust_dam(p, GF_ACID, damage, RANDOMISE,
// check_for_resist(p, GF_ACID, p.state.flags, true));
//if (damage) {
// take_hit(p, damage, ddesc);
// inven_damage(p, GF_ACID, MIN(damage * 5, 300));
//}
//// Learn about the player
//monster_learn_resists(m_ptr, p, GF_ACID);
} else if (effect.value == RBE.ELEC.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Message
//msg("You are struck by electricity!");
//// Take damage (special)
//damage = adjust_dam(p, GF_ELEC, damage, RANDOMISE,
// check_for_resist(p, GF_ELEC, p.state.flags, true));
//if (damage) {
// take_hit(p, damage, ddesc);
// inven_damage(p, GF_ELEC, MIN(damage * 5, 300));
//}
//// Learn about the player
//monster_learn_resists(m_ptr, p, GF_ELEC);
} else if (effect.value == RBE.FIRE.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Message
//msg("You are enveloped in flames!");
//// Take damage (special)
//damage = adjust_dam(p, GF_FIRE, damage, RANDOMISE,
// check_for_resist(p, GF_FIRE, p.state.flags, true));
//if (damage) {
// take_hit(p, damage, ddesc);
// inven_damage(p, GF_FIRE, MIN(damage * 5, 300));
//}
//// Learn about the player
//monster_learn_resists(m_ptr, p, GF_FIRE);
} else if (effect.value == RBE.COLD.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Message
//msg("You are covered with frost!");
//// Take damage (special)
//damage = adjust_dam(p, GF_COLD, damage, RANDOMISE,
// check_for_resist(p, GF_COLD, p.state.flags, true));
//if (damage) {
// take_hit(p, damage, ddesc);
// inven_damage(p, GF_COLD, MIN(damage * 5, 300));
//}
//// Learn about the player
//monster_learn_resists(m_ptr, p, GF_COLD);
} else if (effect.value == RBE.BLIND.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Increase "blind"
//if (player_inc_timed(p, TMD_BLIND, 10 + randint1(rlev), true, true))
// obvious = true;
//// Learn about the player
//update_smart_learn(m_ptr, p, OF_RES_BLIND);
} else if (effect.value == RBE.CONFUSE.value)
{
// Take damage
Spell.take_hit(p, damage, ddesc);
// Increase "confused"
if (p.inc_timed(Timed_Effect.CONFUSED, 3 + Random.randint1(rlev), true, true))
obvious = true;
// Learn about the player
update_smart_learn(p, Object.Object_Flag.RES_CONFU);
} else if (effect.value == RBE.TERRIFY.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Increase "afraid"
//if (randint0(100) < p.state.skills[SKILL_SAVE])
//{
// msg("You stand your ground!");
// obvious = true;
//}
//else
//{
// if (player_inc_timed(p, TMD_AFRAID, 3 + randint1(rlev), true,
// true))
// obvious = true;
//}
//// Learn about the player
//update_smart_learn(m_ptr, p, OF_RES_FEAR);
} else if(effect.value == RBE.PARALYZE.value)
{
// Hack -- Prevent perma-paralysis via damage
if (p.timed[(int)Timed_Effect.PARALYZED] != 0 && (damage < 1)) damage = 1;
// Take damage
Spell.take_hit(p, damage, ddesc);
// Increase "paralyzed"
if (Random.randint0(100) < p.state.skills[(int)Skill.SAVE])
{
Utilities.msg("You resist the effects!");
obvious = true;
}
else
{
if (p.inc_timed(Timed_Effect.PARALYZED, 3 + Random.randint1(rlev), true, true))
obvious = true;
}
// Learn about the player
update_smart_learn(p, Object_Flag.FREE_ACT);
} else if (effect.value == RBE.LOSE_STR.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Damage (stat)
//if (do_dec_stat(A_STR, false)) obvious = true;
} else if (effect.value == RBE.LOSE_INT.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Damage (stat)
//if (do_dec_stat(A_INT, false)) obvious = true;
} else if (effect.value == RBE.LOSE_WIS.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Damage (stat)
//if (do_dec_stat(A_WIS, false)) obvious = true;
} else if (effect.value == RBE.LOSE_DEX.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Damage (stat)
//if (do_dec_stat(A_DEX, false)) obvious = true;
} else if (effect.value == RBE.LOSE_CON.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Damage (stat)
//if (do_dec_stat(A_CON, false)) obvious = true;
} else if (effect.value == RBE.LOSE_CHR.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Damage (stat)
//if (do_dec_stat(A_CHR, false)) obvious = true;
} else if (effect.value == RBE.LOSE_ALL.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Damage (stats)
//if (do_dec_stat(A_STR, false)) obvious = true;
//if (do_dec_stat(A_DEX, false)) obvious = true;
//if (do_dec_stat(A_CON, false)) obvious = true;
//if (do_dec_stat(A_INT, false)) obvious = true;
//if (do_dec_stat(A_WIS, false)) obvious = true;
//if (do_dec_stat(A_CHR, false)) obvious = true;
} else if (effect.value == RBE.SHATTER.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Hack -- Reduce damage based on the player armor class
//damage -= (damage * ((ac < 240) ? ac : 240) / 400);
//// Take damage
//take_hit(p, damage, ddesc);
//// Radius 8 earthquake centered at the monster
//if (damage > 23)
//{
// int px_old = p.px;
// int py_old = p.py;
// earthquake(fy, fx, 8);
// // Stop the blows if the player is pushed away
// if ((px_old != p.px) ||
// (py_old != p.py))
// do_break = true;
//}
} else if (effect.value == RBE.EXP_10.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Take damage
//take_hit(p, damage, ddesc);
//update_smart_learn(m_ptr, p_ptr, OF_HOLD_LIFE);
//if (check_state(p, OF_HOLD_LIFE, p.state.flags) && (randint0(100) < 95))
//{
// msg("You keep hold of your life force!");
//}
//else
//{
// s32b d = damroll(10, 6) + (p.exp/100) * MON_DRAIN_LIFE;
// if (check_state(p, OF_HOLD_LIFE, p.state.flags))
// {
// msg("You feel your life slipping away!");
// player_exp_lose(p, d / 10, false);
// }
// else
// {
// msg("You feel your life draining away!");
// player_exp_lose(p, d, false);
// }
//}
} else if (effect.value == RBE.EXP_20.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Take damage
//take_hit(p, damage, ddesc);
//update_smart_learn(m_ptr, p_ptr, OF_HOLD_LIFE);
//if (check_state(p, OF_HOLD_LIFE, p.state.flags) && (randint0(100) < 90))
//{
// msg("You keep hold of your life force!");
//}
//else
//{
// s32b d = damroll(20, 6) + (p.exp / 100) * MON_DRAIN_LIFE;
// if (check_state(p, OF_HOLD_LIFE, p.state.flags))
// {
// msg("You feel your life slipping away!");
// player_exp_lose(p, d / 10, false);
// }
// else
// {
// msg("You feel your life draining away!");
// player_exp_lose(p, d, false);
// }
//}
} else if (effect.value == RBE.EXP_40.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Take damage
//take_hit(p, damage, ddesc);
//update_smart_learn(m_ptr, p_ptr, OF_HOLD_LIFE);
//if (check_state(p, OF_HOLD_LIFE, p.state.flags) && (randint0(100) < 75))
//{
// msg("You keep hold of your life force!");
//}
//else
//{
// s32b d = damroll(40, 6) + (p.exp / 100) * MON_DRAIN_LIFE;
// if (check_state(p, OF_HOLD_LIFE, p.state.flags))
// {
// msg("You feel your life slipping away!");
// player_exp_lose(p, d / 10, false);
// }
// else
// {
// msg("You feel your life draining away!");
// player_exp_lose(p, d, false);
// }
//}
} else if (effect.value == RBE.EXP_80.value)
{
throw new NotImplementedException();
//// Obvious
//obvious = true;
//// Take damage
//take_hit(p, damage, ddesc);
//update_smart_learn(m_ptr, p_ptr, OF_HOLD_LIFE);
//if (check_state(p, OF_HOLD_LIFE, p.state.flags) && (randint0(100) < 50))
//{
// msg("You keep hold of your life force!");
//}
//else
//{
// s32b d = damroll(80, 6) + (p.exp / 100) * MON_DRAIN_LIFE;
// if (check_state(p, OF_HOLD_LIFE, p.state.flags))
// {
// msg("You feel your life slipping away!");
// player_exp_lose(p, d / 10, false);
// }
// else
// {
// msg("You feel your life draining away!");
// player_exp_lose(p, d, false);
// }
//}
} else if (effect.value == RBE.HALLU.value)
{
throw new NotImplementedException();
//// Take damage
//take_hit(p, damage, ddesc);
//// Increase "image"
//if (player_inc_timed(p, TMD_IMAGE, 3 + randint1(rlev / 2), true, true))
// obvious = true;
//// Learn about the player
//monster_learn_resists(m_ptr, p, GF_CHAOS);
} else {
throw new NotImplementedException();
}
// Hack -- only one of cut or stun
if (do_cut && do_stun)
{
// Cancel cut
if (Random.randint0(100) < 50)
{
do_cut = false;
}
// Cancel stun
else
{
do_stun = false;
}
}
// Handle cut
if (do_cut)
{
int k = 0;
// Critical hit (zero if non-critical)
tmp = monster_critical(d_dice, d_side, damage);
// Roll for damage
switch (tmp)
{
case 0: k = 0; break;
case 1: k = Random.randint1(5); break;
case 2: k = Random.randint1(5) + 5; break;
case 3: k = Random.randint1(20) + 20; break;
case 4: k = Random.randint1(50) + 50; break;
case 5: k = Random.randint1(100) + 100; break;
case 6: k = 300; break;
default: k = 500; break;
}
// Apply the cut
if (k != 0) {
p.inc_timed(Timed_Effect.CUT, k, true, true);
}
}
// Handle stun
if (do_stun)
{
int k;
// Critical hit (zero if non-critical)
tmp = monster_critical(d_dice, d_side, damage);
// Roll for damage
switch (tmp)
{
case 0: k = 0; break;
case 1: k = Random.randint1(5); break;
case 2: k = Random.randint1(10) + 10; break;
case 3: k = Random.randint1(20) + 20; break;
case 4: k = Random.randint1(30) + 30; break;
case 5: k = Random.randint1(40) + 40; break;
case 6: k = 100; break;
default: k = 200; break;
}
// Apply the stun
if (k != 0){
p.inc_timed(Timed_Effect.STUN, k, true, true);
}
}
}
// Monster missed player
else
{
// Analyze failed attacks
if (method == RBM.HIT ||
method == RBM.TOUCH ||
method == RBM.PUNCH ||
method == RBM.KICK ||
method == RBM.CLAW ||
method == RBM.BITE ||
method == RBM.STING ||
method == RBM.BUTT ||
method == RBM.CRUSH ||
method == RBM.ENGULF){
// Visible monsters
if (ml)
{
// Disturbing
Cave.disturb(p, 1, 0);
// Message
//Utilities.msg("%^s misses you.", m_name);
Utilities.msg("{0} misses you.", m_name);
}
}
}
// Analyze "visible" monsters only
if (visible)
{
// Count "obvious" attacks (and ones that cause damage)
if (obvious || damage != 0 || (l_ptr.blows[ap_cnt] > 10))
{
// Count attacks of this type
if (l_ptr.blows[ap_cnt] < byte.MaxValue)
{
l_ptr.blows[ap_cnt]++;
}
}
}
// Skip the other blows if necessary
if (do_break) break;
}
// Blink away
if (blinked)
{
Utilities.msg("There is a puff of smoke!");
throw new NotImplementedException();
//teleport_away(m_ptr, MAX_SIGHT * 2 + 5);
}
// Always notice cause of death
if (p.is_dead && (l_ptr.deaths < short.MaxValue))
{
l_ptr.deaths++;
}
// Assume we attacked
// Nick: Because, based on the length of this function,
// literally a million other things could have happened
return true;
}
public Player()
{
instance = this;
bool keep_randarts = false;
inventory = null;
/* Preserve p_ptr.randarts so that players can use loaded randarts even
* if they create a completely different character */
if (randarts)
keep_randarts = true;
/* Wipe the player */
//(void)WIPE(p, struct player); //Already have a clean slate
randarts = keep_randarts;
//Enable below else later
/* Start with no artifacts made yet */
for (int i = 0; Misc.z_info != null && i < Misc.z_info.a_max; i++)
{
Artifact a_ptr = Misc.a_info[i];
if(a_ptr == null)
continue;
a_ptr.created = false;
a_ptr.seen = false;
}
/* Start with no quests */
for (int i = 0; Misc.q_list != null && i < Misc.MAX_Q_IDX; i++)
{
if(Misc.q_list[i] == null)
Misc.q_list[i] = new Quest();
Misc.q_list[i].level = 0;
}
if (Misc.q_list != null) {
Misc.q_list[0].level = 99;
Misc.q_list[1].level = 100;
}
for (int i = 1; Misc.z_info != null && i < Misc.z_info.k_max; i++) {
Object.Object_Kind k_ptr = Misc.k_info[i];
if(k_ptr == null)
continue;
k_ptr.tried = false;
k_ptr.aware = false;
}
for (int i = 1; Misc.z_info != null && i < Misc.z_info.r_max; i++)
{
Monster_Race r_ptr = Misc.r_info[i];
Monster_Lore l_ptr = Misc.l_list[i];
if(r_ptr == null || l_ptr == null)
continue;
r_ptr.cur_num = 0;
r_ptr.max_num = 100;
if (r_ptr.flags.has(Monster_Flag.UNIQUE.value))
r_ptr.max_num = 1;
l_ptr.pkills = 0;
}
/* Hack -- no ghosts */
if (Misc.z_info != null && Misc.r_info[Misc.z_info.r_max-1] != null)
Misc.r_info[Misc.z_info.r_max-1].max_num = 0;
/* Always start with a well fed player (this is surely in the wrong fn) */
food = Misc.PY_FOOD_FULL - 1;
/* None of the spells have been learned yet */
for (int i = 0; i < Misc.PY_MAX_SPELLS; i++)
spell_order[i] = 99;
inventory = new Object.Object[Misc.ALL_INVEN_TOTAL];
for(int i = 0; i < Misc.ALL_INVEN_TOTAL; i++) {
inventory[i] = new Object.Object();
}
/* First turn. */
Misc.turn = 1;
total_energy = 0;
resting_turn = 0;
/* XXX default race/class */
Race = Misc.races;
Class = Misc.classes;
}
/**
* Create a specific monster's drop, including any specified drops.
*
* Returns true if anything is created, false if nothing is.
*/
static bool mon_create_drop(int m_idx, byte origin)
{
Monster_Drop drop;
Monster m_ptr = Cave.cave_monster(Cave.cave, m_idx);
Monster_Race r_ptr = Misc.r_info[m_ptr.r_idx];
bool great = (r_ptr.flags.has(Monster_Flag.DROP_GREAT.value)) ? true : false;
bool good = (r_ptr.flags.has(Monster_Flag.DROP_GOOD.value) ? true : false) || great;
bool any = false;
bool gold_ok = (!r_ptr.flags.has(Monster_Flag.ONLY_ITEM.value));
bool item_ok = (!r_ptr.flags.has(Monster_Flag.ONLY_GOLD.value));
int number = 0, level, j;
int force_coin = get_coin_type(r_ptr);
Object.Object i_ptr;
//object_type object_type_body;
/* Determine how much we can drop */
if (r_ptr.flags.has(Monster_Flag.DROP_20.value) && Random.randint0(100) < 20) number++;
if (r_ptr.flags.has(Monster_Flag.DROP_40.value) && Random.randint0(100) < 40) number++;
if (r_ptr.flags.has(Monster_Flag.DROP_60.value) && Random.randint0(100) < 60) number++;
if (r_ptr.flags.has(Monster_Flag.DROP_4.value)) number += Random.rand_range(2, 6);
if (r_ptr.flags.has(Monster_Flag.DROP_3.value)) number += Random.rand_range(2, 4);
if (r_ptr.flags.has(Monster_Flag.DROP_2.value)) number += Random.rand_range(1, 3);
if (r_ptr.flags.has(Monster_Flag.DROP_1.value)) number++;
/* Take the best of average of monster level and current depth,
and monster level - to reward fighting OOD monsters */
level = Math.Max((r_ptr.level + Misc.p_ptr.depth) / 2, r_ptr.level);
/* Specified drops */
for (drop = r_ptr.drops; drop != null; drop = drop.Next) {
if (Random.randint0(100) >= drop.percent_chance)
continue;
//i_ptr = &object_type_body;
i_ptr = new Object.Object();
if (drop.artifact != null) {
throw new NotImplementedException();
//object_prep(i_ptr, objkind_get(drop.artifact.tval,
// drop.artifact.sval), level, RANDOMISE);
//i_ptr.artifact = drop.artifact;
//copy_artifact_data(i_ptr, i_ptr.artifact);
//i_ptr.artifact.created = 1;
} else {
i_ptr.prep(drop.kind, level, aspect.RANDOMISE);
i_ptr.apply_magic(level, true, good, great);
}
i_ptr.origin = (Object.Origin)origin;
i_ptr.origin_depth = (byte)Misc.p_ptr.depth;
i_ptr.origin_xtra = m_ptr.r_idx;
i_ptr.number = (byte)(Random.randint0((int)(drop.max - drop.min)) + drop.min);
if (m_ptr.carry(i_ptr) != 0)
any = true;
}
/* Make some objects */
for (j = 0; j < number; j++) {
//i_ptr = &object_type_body;
//object_wipe(i_ptr);
i_ptr = new Object.Object();
if (gold_ok && (!item_ok || (Random.randint0(100) < 50))) {
Object.Object.make_gold(ref i_ptr, level, force_coin);
} else {
int q = 0;
if (!Object.Object.make_object(Cave.cave, ref i_ptr, level, good, great, ref q)) continue;
}
i_ptr.origin = (Origin)origin;
i_ptr.origin_depth = (byte)Misc.p_ptr.depth;
i_ptr.origin_xtra = m_ptr.r_idx;
if (m_ptr.carry(i_ptr) != 0)
any = true;
}
return any;
}
