armor.cpp

Go to the documentation of this file.

#include "armor.h"

#include <stddef.h>
#include <stdexcept>

#include <format/format.h>
#include "../../bscript/bstruct.h"
#include "../../bscript/impstr.h"
#include "../../clib/cfgelem.h"
#include "../../clib/logfacility.h"
#include "../../clib/passert.h"
#include "../../clib/streamsaver.h"
#include "../../clib/strutil.h"
#include "../../plib/pkg.h"
#include "../../plib/systemstate.h"
#include "../equipdsc.h"
#include "../extobj.h"
#include "../globals/settings.h"
#include "../layers.h"
#include "../tiles.h"
#include "../uobject.h"
#include "armrtmpl.h"
#include "itemdesc.h"


namespace Pol
{
namespace Mobile
{
const char* zone_to_zone_name( unsigned short zone );
unsigned short layer_to_zone( unsigned short layer );
unsigned short zone_name_to_zone( const char* zname );
}
namespace Items
{
ArmorDesc::ArmorDesc( u32 objtype, Clib::ConfigElem& elem, const Plib::Package* pkg,
                      bool forceShield )
    : EquipDesc( objtype, elem, ARMORDESC, pkg ),
      ar( elem.remove_ushort( "AR", 0 ) ),
      zones(),
      on_hit_script( elem.remove_string( "ONHITSCRIPT", "" ), pkg, "scripts/items/" )
{
  std::string coverage;
  while ( elem.remove_prop( "COVERAGE", &coverage ) )
  {
    try
    {
      zones.insert( Mobile::zone_name_to_zone( coverage.c_str() ) );
    }
    catch ( std::runtime_error& )
    {
      fmt::Writer tmp;
      tmp.Format( "Error in Objtype 0x{:X}" ) << objtype;
      if ( pkg == NULL )
        tmp << "config/itemdesc.cfg\n";
      else
        tmp << pkg->dir() << "itemdesc.cfg\n";

      ERROR_PRINT << tmp.str();
      throw;
    }
  }

  if ( zones.empty() )
  {
    // No 'COVERAGE' entries existed.
    // default coverage based on object type/layer
    unsigned short layer = Plib::systemstate.tile[graphic].layer;
    // special case for shields - they effectively have no coverage.
    if ( !forceShield && layer != Core::LAYER_HAND1 && layer != Core::LAYER_HAND2 )
    {
      try
      {
        zones.insert( Mobile::layer_to_zone( layer ) );
      }
      catch ( std::runtime_error& )
      {
        fmt::Writer tmp;
        tmp.Format( "Error in Objtype 0x{:X}" ) << objtype;
        if ( pkg == NULL )
          tmp << "config/itemdesc.cfg\n";
        else
          tmp << pkg->dir() << "itemdesc.cfg\n";

        ERROR_PRINT << tmp.str();
        throw;
      }
    }
  }
}

void ArmorDesc::PopulateStruct( Bscript::BStruct* descriptor ) const
{
  base::PopulateStruct( descriptor );
  descriptor->addMember( "OnHitScript", new Bscript::String( on_hit_script.relativename( pkg ) ) );
  descriptor->addMember( "AR", new Bscript::BLong( ar ) );

  std::unique_ptr<Bscript::ObjArray> arr_zones( new Bscript::ObjArray() );
  std::set<unsigned short>::const_iterator itr;
  for ( itr = zones.begin(); itr != zones.end(); ++itr )
    arr_zones->addElement( new Bscript::String( Mobile::zone_to_zone_name( *itr ) ) );


  if ( arr_zones->ref_arr.size() > 0 )
    descriptor->addMember( "Coverage", arr_zones.release() );
}

size_t ArmorDesc::estimatedSize() const
{
  size_t size = base::estimatedSize() + sizeof( unsigned short ) /*ar*/
                + on_hit_script.estimatedSize();
  size += 3 * sizeof( void* ) + zones.size() * ( sizeof( unsigned short ) + 3 * sizeof( void* ) );
  return size;
}

UArmor::UArmor( const ArmorDesc& descriptor, const ArmorDesc* permanent_descriptor )
    : Equipment( descriptor, Core::UOBJ_CLASS::CLASS_ARMOR, permanent_descriptor ),
      onhitscript_( descriptor.on_hit_script )
{
}

unsigned short UArmor::ar() const
{
  short ar_mod = this->ar_mod();
  int ar = ar_base() * hp_ / maxhp();
  if ( ar_mod != 0 )
  {
    ar += ar_mod;
  }

  if ( ar < 0 )
    return 0;
  else if ( ar <= USHRT_MAX )
    return static_cast<unsigned short>( ar );
  else
    return USHRT_MAX;
}

unsigned short UArmor::ar_base() const
{
  return ARMOR_TMPL->ar;
}

bool UArmor::covers( unsigned short zlayer ) const
{
  passert( tmpl != NULL );
  return ARMOR_TMPL->zones.find( zlayer ) != ARMOR_TMPL->zones.end();
}

Item* UArmor::clone() const
{
  UArmor* armor = static_cast<UArmor*>( base::clone() );
  armor->ar_mod( this->ar_mod() );
  armor->onhitscript_ = onhitscript_;
  armor->tmpl = tmpl;
  return armor;
}

void UArmor::printProperties( Clib::StreamWriter& sw ) const
{
  base::printProperties( sw );
  if ( has_ar_mod() )
    sw() << "\tAR_mod\t" << ar_mod() << pf_endl;
  if ( tmpl != NULL && onhitscript_ != ARMOR_TMPL->on_hit_script )
    sw() << "\tOnHitScript\t" << onhitscript_.relativename( tmpl->pkg ) << pf_endl;
}

void UArmor::readProperties( Clib::ConfigElem& elem )
{
  base::readProperties( elem );
  this->ar_mod( static_cast<s16>( elem.remove_int( "AR_MOD", 0 ) ) );
  set_onhitscript( elem.remove_string( "ONHITSCRIPT", "" ) );
}

void UArmor::set_onhitscript( const std::string& scriptname )
{
  if ( scriptname.empty() )
  {
    onhitscript_.clear();
  }
  else
  {
    onhitscript_.config( scriptname, itemdesc().pkg, "scripts/items/", true );
  }
}
std::set<unsigned short> UArmor::tmplzones()
{
  passert( tmpl != NULL );
  return ARMOR_TMPL->zones;
}

void validate_intrinsic_shield_template()
{
  const ItemDesc& id = find_itemdesc( Core::settingsManager.extobj.shield );
  if ( id.save_on_exit )
    throw std::runtime_error( "Intrinsic Shield " +
                              Clib::hexint( Core::settingsManager.extobj.shield ) +
                              " must specify SaveOnExit 0" );

  if ( id.type != ItemDesc::ARMORDESC )
    throw std::runtime_error(
        "An Armor template for Intrinsic Shield is required in itemdesc.cfg" );
}

UArmor* create_intrinsic_shield( const char* name, Clib::ConfigElem& elem,
                                 const Plib::Package* pkg )
{
  auto tmpl = new ArmorDesc( Core::settingsManager.extobj.shield, elem, pkg, true );
  tmpl->is_intrinsic = true;
  auto armr = new UArmor( *tmpl, tmpl );
  armr->layer = Core::LAYER_HAND2;
  armr->tmpl = tmpl;

  Items::register_intrinsic_equipment( name, armr );

  return armr;
}

UArmor* create_intrinsic_shield_from_npctemplate( Clib::ConfigElem& elem, const Plib::Package* pkg )
{
  std::string tmp;
  if ( elem.remove_prop( "Shield", &tmp ) )
  {
    // Construct an ArmorTemplate for this NPC template.
    Clib::ConfigElem shieldelem;
    shieldelem.set_rest( elem.rest() );
    shieldelem.set_source( elem );
    shieldelem.add_prop( "Objtype", "0xFFFF" );
    shieldelem.add_prop( "Graphic", "1" );
    shieldelem.add_prop( "SaveOnExit", "0" );
    shieldelem.add_prop( "AR", tmp.c_str() );

    if ( elem.remove_prop( "ShieldMaxHp", &tmp ) )
      shieldelem.add_prop( "MaxHP", tmp.c_str() );
    else
      shieldelem.add_prop( "MaxHP", "1" );

    if ( elem.remove_prop( "ShieldOnHitScript", &tmp ) )
      shieldelem.add_prop( "OnHitScript", tmp.c_str() );

    while ( elem.remove_prop( "ShieldCProp", &tmp ) )
      shieldelem.add_prop( "CProp", tmp.c_str() );

    return create_intrinsic_shield( elem.rest(), shieldelem, pkg );
  }
  else
  {
    return NULL;
  }
}

size_t UArmor::estimatedSize() const
{
  size_t size = base::estimatedSize() + onhitscript_.estimatedSize();
  return size;
}
}
}