/* /lib/std/armor.c
* From the Dead Souls Object Library
* The standard armor object
* Created by Descartes of Borg 950408
* Version: @(#) armor.c 1.9@(#)
* Last modified: 97/01/01
*/
#include <lib.h>
#include <function.h>
#include <armor_types.h>
#include <damage_types.h>
#include <vendor_types.h>
inherit LIB_BURY;
inherit LIB_DETECT;
inherit LIB_DETERIORATION;
inherit LIB_DROP;
inherit LIB_EQUIP;
inherit LIB_GET;
inherit LIB_GIVE;
inherit LIB_LOCK_WITH;
inherit LIB_MASS;
inherit LIB_MOVE;
inherit LIB_OBJECT;
inherit LIB_PERSIST;
inherit LIB_POISON;
inherit LIB_PUT;
inherit LIB_READ;
inherit LIB_SELL;
inherit LIB_SHOW;
inherit LIB_STEAL;
inherit LIB_UNIQUENESS;
inherit LIB_VALUE;
inherit LIB_WEAR;
inherit LIB_HOLDER;
inherit LIB_SEAL;
inherit LIB_MONEY;
inherit LIB_FALL;
inherit LIB_SINK;
private int Fingers = 5;
private int Size = 0;
private mapping Protection = ([]);
private string array RestrictLimbs = 0;
private static mixed Wear = 0;
private static mapping MaxProtection = ([]);
private int CanClose = 0;
private int CanLock = 0;
private int MaxRecurseDepth = 3;
private int RecurseDepth = 1;
private int RetainOnDeath = 0;
void PutCheck();
int GetMaxProtection(int type);
int SetRetainOnDeath(int x ){ return (RetainOnDeath = x); }
int GetRetainOnDeath(){ return RetainOnDeath; }
/* *************** /lib/armor.c data functions *************** */
varargs string GetEquippedDescription(object who){
if(!who) who = this_player();
if( GetWorn() ){
string tmp = "It is worn on ";
if(who == environment()){
tmp += "your";
}
else {
tmp += possessive_noun(environment());
}
tmp += " " + item_list(GetWorn()) + ".";
return tmp;
}
return 0;
}
varargs string GetExternalDesc(object who){
string desc;
desc = ::GetExternalDesc(who);
if(GetWorn()) desc += " "+GetEquippedDescription(who);
return desc;
}
string GetEquippedShort(){
string tmp = GetShort();
if( GetWorn() ){
tmp += " (%^GREEN%^worn%^RESET%^)";
}
return tmp;
}
int GetFingers(){
return Fingers;
}
int SetFingers(int x){
return (Fingers = x);
}
int GetSize(){
return Size;
}
int SetSize(int x){
return (Size = x);
}
/* Just check the surface for blade/knife/blunt damage
* Other damage types will be checked via more costly methods
* -blitz
*/
string GetItemCondition(){
int cuts, dents;
string ret;
cuts = dents = -1;
foreach(int type, int val in Protection){
int x;
if( BLADE & type || KNIFE & type ){
x = to_float(val) / GetMaxProtection(type) * 100;
if( cuts == -1 || x < cuts ) cuts = x;
}
else if( BLUNT & type ){
x = to_float(val) / GetMaxProtection(type) * 100;
if( dents == -1 || x > dents ) dents = x;
}
}
if( cuts == -1 && dents == -1 ) return 0;
if( cuts > -1 ) switch( cuts ){
case 0..10: ret = "shredded to pieces"; break;
case 11..20: ret = "shredded"; break;
case 21..40: ret = "mildly shredded"; break;
case 41..60: ret = "slashed up"; break;
case 61..80: ret = "scratched"; break;
case 81..90: ret = "somewhat nicked"; break;
default: ret = "unbroken";
}
if( dents > -1 ){
if( ret ) ret += " and ";
else ret = "";
switch( dents ){
case 0..10: ret += "utterly battered"; break;
case 11..20: ret += "terribly pounded"; break;
case 21..40: ret += "serverly dented"; break;
case 41..60: ret += "pretty dented"; break;
case 61..80: ret += "dented"; break;
case 81..90: ret += "slightly dented"; break;
default: ret += "unmarred";
}
}
return "Its surface is " + ret + ".";
}
int GetMaxProtection(int type){
return MaxProtection[type];
}
int GetProtection(int type){
int array types;
int i;
foreach(int t, int val in Protection){
if( t & type ){
int blessing = GetProperty("blessed");
if( !intp(blessing) ){
blessing = 0;
}
return (val + blessing);
}
}
return 0;
}
int SetProtection(int type, int amount){
MaxProtection[type] = amount;
return (Protection[type] = amount);
}
string array GetRestrictLimbs(){
return RestrictLimbs;
}
string array SetRestrictLimbs(string array limbs){
return (RestrictLimbs = limbs);
}
static mixed array AddSave(mixed array vars){
if(!vars) vars = ({});
vars += ({ "Properties" });
return persist::AddSave(vars);
}
string array GetSave(){
return persist::GetSave();
}
mixed GetWear(){
return Wear;
}
mixed SetWear(mixed val){
return (Wear = val);
}
/* ****************** armor.c modals ********************* */
mixed CanEquip(object who, string array limbs){
mixed tmp;
if(Size && !( Size & who->GetSize() ) ){
return "It doesn't fit.";
}
if( !limbs ){ /* let's try and guess */
string array guess = who->GetLimbs();
int armor = GetArmorType();
string limb;
if( !guess ){
return "You have no limbs!";
}
limbs = ({});
foreach(limb in guess){
mapping data;
data = who->GetLimb(limb);
if( data["armors"] & armor ){
limbs += ({ limb });
}
}
if( equip::CanEquip(who, limbs) != 1 ){
string ret = "Wear " + GetDefiniteShort() + " on which ";
int type = this_object()->GetArmorType();
if(type & A_RING) ret += "hand?";
else ret += "limb?";
return ret;
}
else {
return 1;
}
}
else if( sizeof(limbs) == 1 ){
string which;
switch(GetArmorType()){
case A_SHIELD:
if( which = who->GetLimbParent(limbs[0]) ){
limbs = ({ limbs[0], "torso", which });
}
break;
case A_LONG_GLOVE: case A_LONG_BOOT:
if( which = who->GetLimbParent(limbs[0]) ){
limbs = ({ limbs[0], which });
}
else {
limbs = ({ limbs[0] });
}
break;
default:
limbs = ({ limbs[0] });
break;
}
}
return equip::CanEquip(who, limbs);
}
mixed CanRepair(object who){
return 1;
}
mixed CanSteal(object who){
if( GetWorn() ){
return "You can't steal something equipped!";
}
return steal::CanSteal(who);
}
/* ********************* armor.c events *********************** */
static int Destruct(){
if( GetWorn() && environment() ){
eventUnequip(environment());
}
return object::Destruct();
}
void eventDeteriorate(int type){
foreach(int t, int val in Protection){
if( (t & type) && val ){
if( GetProperty("blessed") ){
Protection[t] -= 2;
}
else {
Protection[t]--;
}
if( Protection[t] < 1 ){
Protection[t] = 0;
}
}
}
SetDestroyOnSell(1);
SetValue(GetValue()/2);
}
mixed eventEquip(object who, string array limbs){
mixed tmp;
if( !limbs ){ /* let's try and guess */
int armor = GetArmorType();
string limb;
limbs = ({});
foreach(limb in who->GetLimbs()){
mapping data = who->GetLimb(limb);
if( data["armors"] & armor ){
limbs += ({ limb });
}
}
if( equip::CanEquip(who, limbs) != 1 ){
string ret = "Wear " + GetDefiniteShort() + " on which ";
int type = this_object()->GetArmorType();
if(type & A_RING) ret += "hand?";
else ret += "limb?";
return ret;
}
}
else if( sizeof(limbs) == 1 ){
string which;
switch(GetArmorType()){
case A_SHIELD:
if( which = who->GetLimbParent(limbs[0]) ){
limbs = ({ limbs[0], "torso", which });
}
break;
case A_LONG_GLOVE: case A_LONG_BOOT:
if( which = who->GetLimbParent(limbs[0]) ){
limbs = ({ limbs[0], which });
}
else {
limbs = ({ limbs[0] });
}
break;
default:
limbs = ({ limbs[0] });
break;
}
}
if( functionp(Wear) ){
if( functionp(Wear) & FP_OWNER_DESTED ){
return "You can't wear that there at the moment.";
}
if( !evaluate(Wear, who, limbs) ){
return 1;
}
}
tmp = equip::eventEquip(who, limbs);
if( tmp != 1 ){
if( tmp ){
who->eventPrint(tmp);
}
else {
who->eventPrint("You can't wear that there right now.");
}
return 1;
}
tmp = GetShort();
SetWorn(limbs);
if( functionp(Wear) ){
return 1;
}
else if( stringp(Wear) ){
who->eventPrint(Wear);
}
else {
who->eventPrint("You wear " + tmp + ".");
}
environment(who)->eventPrint(who->GetName() + " wears " + tmp + ".", who);
return 1;
}
int eventMove(mixed dest){
if( !environment() && GetWorn() ){
mixed array limbs = GetWorn();
SetWorn(0);
call_out((: eventRestoreEquip :), 0, limbs);
}
if( GetWorn() && environment() ){
eventUnequip(environment());
}
return move::eventMove(dest);
}
varargs mixed eventRepair(object who, int strength, int type){
if( !who || !strength ){
return 0;
}
if( !type ){
type = ALL_DAMAGE;
}
foreach(int i in keys(Protection)){
if( !(i & type) || !MaxProtection[i]){
continue;
}
Protection[i] += strength;
if( Protection[i] > MaxProtection[i] ){
Protection[i] = MaxProtection[i];
}
}
return 1;
}
mixed eventShow(object who, string component){
mixed tmp = object::eventShow(who, component);
if( component || tmp != 1 ){
return tmp;
}
if( GetPoison() ){
if( random(100) < who->GetSkillLevel("stealth") ){
who->eventPrint("You notice a strange substance on it.");
}
}
return 1;
}
varargs mixed eventUnequip(object who){
mixed tmp = equip::eventUnequip(who);
if( tmp != 1 ){
return tmp;
}
send_messages("remove", "$agent_name $agent_verb $target_name.",
who, this_object(), environment(who));
return 1;
}
int restrict(mixed arg){
if(!arg) return 1;
if(arg) SetRestrictLimbs(arg);
return 2;
}
/* ******************** armor.c driver applies ******************** */
static void create(){
AddSave( ({ "Closed", "CanClose", "CanLock", "RecurseDepth" , "MaxRecurseDepth" }) +
(equip::GetSave()) + (value::GetSave()) + (mass::GetSave()) +
(poison::GetSave()) + (deterioration::GetSave()));
steal::create();
object::create();
holder::create();
seal::create();
PutCheck();
SetVendorType(VT_ARMOR);
}
void init(){
int atype;
atype = GetArmorType();
if(atype & A_HELMET ) restrict(({"head"}));
if(atype & A_VISOR ) restrict(({"head"}));
if(atype & A_PANTS ) restrict(({"right leg","left leg"}));
if(atype & A_BELT ) restrict(({"torso"}));
if(atype & A_SHIRT ) restrict(({"torso"}));
if(atype & A_CLOAK ) restrict(({"torso"}));
if(atype & A_VEST ) restrict(({"torso"}));
if(atype & A_ARMOR ) restrict(({"torso","right arm","left arm"}));
if(atype & A_COLLAR ) restrict(({"neck"}));
if(atype & A_BODY_ARMOR ) restrict(({"torso","right arm","left arm","left leg","right leg"}) );
}
int GetMaxRecurseDepth(){
return MaxRecurseDepth;
}
int GetRecurseDepth(){
return RecurseDepth;
}
int SetMaxRecurseDepth(int i){
MaxRecurseDepth =i;
return 1;
}
int SetRecurseDepth(int i){
RecurseDepth=i;
return 1;
}
int AddRecurseDepth(int i){
RecurseDepth += i;
return 1;
}
int GetCanClose(){
return CanClose;
}
int SetCanClose(int x){
CanClose = x;
}
int GetCanLock(){
return CanLock;
}
int SetCanLock(int x){
return SetCanClose(CanLock = x);
}
void SetKey(string key){
SetKeys(key);
}
int GetOpacity(){
return holder::GetOpacity();
}
int GetRadiantLight(int ambient){
return (object::GetRadiantLight(ambient)) + (holder::GetRadiantLight(ambient));
}
int SetSaveRecurse(int x){
return persist::SetSaveRecurse(x);
}
mixed CanClose(object who, string id){
if( !GetCanClose() ){
return 0;
}
else {
return seal::CanClose(who, id);
}
}
mixed CanGetFrom(object who, object item){
mixed tmp = holder::CanGetFrom(who, item);
if( tmp != 1 ){
return tmp;
}
if( GetClosed() ){
return capitalize(GetDefiniteShort()) + " is closed.";
}
return 1;
}
mixed CanLock(object who, string id){
if( !GetCanLock() ){
return 0;
}
else {
return seal::CanLock(who, id);
}
}
mixed CanOpen(object who, string id){
if( !GetCanClose() ){
return 0;
}
else {
return seal::CanOpen(who, id);
}
}
mixed CanPick(object who, string id){
if( !GetCanLock() ){
return "It isn't lockable in the first place.";
}
else {
return seal::CanPick(who, id);
}
}
mixed CanPutInto(object who, object what){
mixed tmp;
int mydepth,yourdepth,total,indirectp,indirectpp;
string wherefrom,stackstring;
string *callstack;
if(!tmp = holder::CanPutInto(who, what)){
if(GetClosed()) return capitalize(GetDefiniteShort()) + " is closed right now.";
else return "You can't do that right now.";
}
wherefrom=origin();
callstack=call_stack(2);
stackstring=implode(callstack," ");
indirectp=member_array("indirect_put_obj_word_obj",callstack);
indirectpp=member_array("indirect_put_objs_word_obj",callstack);
if( tmp != 1 ){
if( GetClosed() ) return capitalize(GetDefiniteShort()) + " is closed.";
else return "You can't do that at this time.";
}
if( GetClosed() ){
return capitalize(GetDefiniteShort()) + " is closed.";
}
if(inherits("/lib/std/storage",what) ){
yourdepth = what->GetRecurseDepth();
mydepth = this_object()->GetRecurseDepth();
if(yourdepth && mydepth) total = yourdepth + mydepth;
if(total && total > this_object()->GetMaxRecurseDepth()) return "Doesn't fit.";
}
return 1;
}
varargs mixed CanShowInterior(object who, object target){
if( GetClosed() && this_object()->GetOpacity() > 33){
return capitalize(GetDefiniteShort()) + " is closed.";
}
else return holder::CanShowInterior();
}
mixed CanUnlock(object who, string id, object key){
if( !GetCanLock() ){
return 0;
}
else {
return seal::CanUnlock(who, id, key);
}
}
int eventReceiveObject(object ob){
if( GetClosed() ){
return 0;
}
return holder::eventReceiveObject(ob);
}
void PutCheck(){
if(RecurseDepth >= MaxRecurseDepth){
SetPreventPut("You have enough containers inside containers there. This one will have to stay out.");
}
}
int inventory_accessible(){
return seal::inventory_accessible();
}
int inventory_visible(){
return (seal::inventory_visible() || holder::inventory_visible());
}
mapping GetProtectionMap(){
return copy(Protection);
}
