polsystemmod.cpp

Go to the documentation of this file.

#include "polsystemmod.h"

#include <ctime>
#include <fstream>
#include <string>

#include "../../bscript/berror.h"
#include "../../bscript/bobject.h"
#include "../../bscript/dict.h"
#include "../../bscript/impstr.h"
#include "../../clib/clib.h"
#include "../../clib/clib_MD5.h"
#include "../../clib/compilerspecifics.h"
#include "../../clib/fileutil.h"
#include "../../clib/rawtypes.h"
#include "../../clib/strutil.h"
#include "../../clib/threadhelp.h"
#include "../../plib/pkg.h"
#include "../../plib/systemstate.h"
#include "../cmdlevel.h"
#include "../core.h"
#include "../globals/settings.h"
#include "../globals/uvars.h"
#include "../item/item.h"
#include "../item/itemdesc.h"
#include "../listenpt.h"
#include "../packetscrobj.h"
#include "../polcfg.h"
#include "../proplist.h"
#include "../realms.h"
#include "../realms/realm.h"
#include "../tooltips.h"
#include "../uobject.h"
#include "../uoexhelp.h"

namespace Pol
{
namespace Core
{
void decay_thread_shadow( void* );
void reload_configuration();
}
namespace Module
{
class PackagePtrHolder
{
public:
  explicit PackagePtrHolder( Plib::Package* pkg ) : m_pPkg( pkg ) {}
  Plib::Package* operator->() { return m_pPkg; }
  const Plib::Package* operator->() const { return m_pPkg; }
  Plib::Package* Ptr() { return m_pPkg; }
  const Plib::Package* Ptr() const { return m_pPkg; }

private:
  Plib::Package* m_pPkg;
};

Bscript::BApplicObjType packageobjimp_type;
// typedef BApplicObj< ref_ptr<Package> > PackageObjImpBase;
typedef Bscript::BApplicObj<PackagePtrHolder> PackageObjImpBase;
class PackageObjImp : public PackageObjImpBase
{
  typedef PackageObjImpBase base;

public:
  explicit PackageObjImp( const PackagePtrHolder& other );
  virtual const char* typeOf() const POL_OVERRIDE;
  virtual u8 typeOfInt() const POL_OVERRIDE;
  virtual Bscript::BObjectImp* copy() const POL_OVERRIDE;
  virtual Bscript::BObjectImp* call_method( const char* methodname,
                                            Bscript::Executor& ex ) POL_OVERRIDE;
  virtual Bscript::BObjectRef get_member( const char* membername ) POL_OVERRIDE;
};
PackageObjImp::PackageObjImp( const PackagePtrHolder& other )
    : PackageObjImpBase( &packageobjimp_type, other )
{
}
}
namespace Bscript
{
using namespace Module;
template <>
TmplExecutorModule<PolSystemExecutorModule>::FunctionTable
    TmplExecutorModule<PolSystemExecutorModule>::function_table = {
        {"IncRevision", &PolSystemExecutorModule::mf_IncRevision},
        {"GetCmdLevelName", &PolSystemExecutorModule::mf_GetCmdLevelName},
        {"GetCmdLevelNumber", &PolSystemExecutorModule::mf_GetCmdLevelNumber},
        {"Packages", &PolSystemExecutorModule::mf_Packages},
        {"GetPackageByName", &PolSystemExecutorModule::mf_GetPackageByName},
        {"ListTextCommands", &PolSystemExecutorModule::mf_ListTextCommands},
        {"Realms", &PolSystemExecutorModule::mf_Realms},
        {"ReloadConfiguration", &PolSystemExecutorModule::mf_ReloadConfiguration},
        {"ReadMillisecondClock", &PolSystemExecutorModule::mf_ReadMillisecondClock},
        {"ListenPoints", &PolSystemExecutorModule::mf_ListenPoints},
        {"SetSysTrayPopupText", &PolSystemExecutorModule::mf_SetSysTrayPopupText},
        {"GetItemDescriptor", &PolSystemExecutorModule::mf_GetItemDescriptor},
        {"FormatItemDescription", &PolSystemExecutorModule::mf_FormatItemDescription},
        {"CreatePacket", &PolSystemExecutorModule::mf_CreatePacket},
        {"AddRealm", &PolSystemExecutorModule::mf_AddRealm},
        {"DeleteRealm", &PolSystemExecutorModule::mf_DeleteRealm},
        {"MD5Encrypt", &PolSystemExecutorModule::mf_MD5Encrypt},
        {"LogCPropProfile", &PolSystemExecutorModule::mf_LogCPropProfile},
};
}
namespace Module
{
using namespace Bscript;

const char* PackageObjImp::typeOf() const
{
  return "Package";
}
u8 PackageObjImp::typeOfInt() const
{
  return OTPackage;
}
BObjectImp* PackageObjImp::copy() const
{
  return new PackageObjImp( obj_ );
}
BObjectImp* PackageObjImp::call_method( const char* /*methodname*/, Executor& /*ex*/ )
{
  return new BError( "undefined method" );
}
BObjectRef PackageObjImp::get_member( const char* membername )
{
  if ( stricmp( membername, "name" ) == 0 )
  {
    return BObjectRef( new String( value()->name() ) );
  }
  else if ( stricmp( membername, "version" ) == 0 )
  {
    return BObjectRef( new String( value()->version() ) );
  }
  else if ( stricmp( membername, "supports_http" ) == 0 )
  {
    const Plib::Package* pkg = value().Ptr();
    return BObjectRef( new BLong( Clib::FileExists( pkg->dir() + "www" ) ) );
  }
  else if ( stricmp( membername, "npcdesc" ) == 0 )
  {
    Plib::Package* pkg = value().Ptr();
    std::string filepath = Plib::GetPackageCfgPath( pkg, "npcdesc.cfg" );
    return BObjectRef( new BLong( Clib::FileExists( filepath ) ) );
  }
  else
  {
    return BObjectRef( new BError( "Undefined member" ) );
  }
}

PolSystemExecutorModule::PolSystemExecutorModule( Bscript::Executor& exec )
    : Bscript::TmplExecutorModule<PolSystemExecutorModule>( "polsys", exec )
{
}

BObjectImp* PolSystemExecutorModule::mf_IncRevision( /* uobject */ )
{
  Core::UObject* uobj;
  if ( getUObjectParam( exec, 0, uobj ) )
  {
    uobj->increv();
    send_object_cache_to_inrange( uobj );
    return new BLong( 1 );
  }
  else
  {
    return new BError( "Invalid parameter type" );
  }
}

BObjectImp* PolSystemExecutorModule::mf_GetCmdLevelName()
{
  int cmdlevel_num;
  const String* cmdlevel_alias;

  if ( exec.numParams() != 1 )
    return new BError( "Expected 1 parameter." );
  else if ( getParam( 0, cmdlevel_num ) )
  {
    if ( cmdlevel_num >= static_cast<int>( Core::gamestate.cmdlevels.size() ) )
      cmdlevel_num = static_cast<int>( Core::gamestate.cmdlevels.size() - 1 );

    return new String( Core::gamestate.cmdlevels[cmdlevel_num].name );
  }
  else if ( getStringParam( 0, cmdlevel_alias ) )
  {
    Core::CmdLevel* cmdlevel = Core::FindCmdLevelByAlias( cmdlevel_alias->data() );
    if ( cmdlevel == nullptr )
      return new BError( "Could not find a command level with that alias." );
    else
      return new String( cmdlevel->name );
  }
  else
    return new BError( "Invalid parameter type." );
}

BObjectImp* PolSystemExecutorModule::mf_GetCmdLevelNumber()
{
  const String* cmdlvlname;
  if ( !getStringParam( 0, cmdlvlname ) )
    return new BError( "Invalid parameter type." );

  Core::CmdLevel* cmdlevel_search = Core::find_cmdlevel( cmdlvlname->data() );
  if ( cmdlevel_search == nullptr )
    return new BError( "Could not find a command level with that name." );

  return new BLong( cmdlevel_search->cmdlevel );
}

BObjectImp* PolSystemExecutorModule::mf_Packages()
{
  std::unique_ptr<ObjArray> arr( new ObjArray );
  for ( unsigned i = 0; i < Plib::systemstate.packages.size(); ++i )
  {
    PackageObjImp* imp = new PackageObjImp( PackagePtrHolder( Plib::systemstate.packages[i] ) );
    arr->addElement( imp );
  }
  return arr.release();
}

BObjectImp* PolSystemExecutorModule::mf_GetPackageByName()
{
  const String* pkgname;
  if ( !getStringParam( 0, pkgname ) )
    return new BError( "Invalid parameter type." );

  // pkgname->toLower();
  Plib::Package* pkg = Plib::find_package( pkgname->value() );
  if ( !pkg )
    return new BError( "No package found by that name." );
  else
    return new PackageObjImp( PackagePtrHolder( pkg ) );
}

BObjectImp* PolSystemExecutorModule::mf_ListTextCommands()
{
  std::unique_ptr<BDictionary> pkg_list( new BDictionary );
  // Sets up text commands not in a package.
  {
    std::unique_ptr<BDictionary> cmd_lvl_list( new BDictionary );
    for ( unsigned num = 0; num < Core::gamestate.cmdlevels.size(); ++num )
    {
      ObjArray* script_list = Core::GetCommandsInPackage( nullptr, num );
      if ( script_list == nullptr )
        continue;
      else if ( !script_list->ref_arr.empty() )
        cmd_lvl_list->addMember( new BLong( num ), script_list );
    }
    if ( cmd_lvl_list->contents().size() > 0 )
      pkg_list->addMember( new String( "" ), cmd_lvl_list.release() );
  }
  //
  // Sets up packaged text commands.
  for ( Plib::Packages::iterator itr = Plib::systemstate.packages.begin();
        itr != Plib::systemstate.packages.end(); ++itr )
  {
    Plib::Package* pkg = ( *itr );
    std::unique_ptr<BDictionary> cmd_lvl_list( new BDictionary );
    for ( unsigned num = 0; num < Core::gamestate.cmdlevels.size(); ++num )
    {
      ObjArray* script_list = Core::GetCommandsInPackage( pkg, num );
      if ( script_list == nullptr )
        continue;
      else if ( !script_list->ref_arr.empty() )
        cmd_lvl_list->addMember( new BLong( num ), script_list );
    }
    if ( cmd_lvl_list->contents().size() > 0 )
      pkg_list->addMember( new String( pkg->name().c_str() ), cmd_lvl_list.release() );
  }
  return pkg_list.release();
}

BObjectImp* PolSystemExecutorModule::mf_ReloadConfiguration()
{
  Core::reload_configuration();

  return new BLong( 1 );
}

BObjectImp* PolSystemExecutorModule::mf_ReadMillisecondClock()
{
  return new BLong( Core::polticks_t_to_ms( Core::polclock() ) );
}

BObjectImp* PolSystemExecutorModule::mf_ListenPoints()
{
  return Core::GetListenPoints();
}

BStruct* SetupRealmDetails( Realms::Realm* realm )
{
  std::unique_ptr<BStruct> details( new BStruct() );
  details->addMember( "width", new BLong( realm->width() ) );
  details->addMember( "height", new BLong( realm->height() ) );
  details->addMember( "season", new BLong( realm->season() ) );
  details->addMember( "mapid", new BLong( realm->getUOMapID() ) );
  details->addMember( "toplevel_item_count", new BLong( realm->toplevel_item_count() ) );
  details->addMember( "mobile_count", new BLong( realm->mobile_count() ) );
  details->addMember( "offline_mobs_count", new BLong( realm->offline_mobile_count() ) );
  details->addMember( "multi_count", new BLong( realm->multi_count() ) );

  return details.release();
}

BObjectImp* PolSystemExecutorModule::mf_Realms( /* realm_name:="" */ )
{
  const String* realm_name;
  //  getStringParam(0, realm_name);
  BObjectImp* imp = getParamImp( 0 );
  if ( imp->isa( BObjectImp::OTString ) )
  {
    realm_name = static_cast<const String*>( imp );
  }
  else
  {
    return new BError( std::string( "Parameter must be a String or empty, got " ) +
                       BObjectImp::typestr( imp->type() ) );
  }

  if ( realm_name->length() > 0 )
  {
    Realms::Realm* realm = Core::find_realm( realm_name->value() );
    if ( !realm )
      return new BError( "Realm not found." );
    else
      return SetupRealmDetails( realm );
  }
  else
  {
    BDictionary* dict = new BDictionary;
    std::vector<Realms::Realm*>::iterator itr;
    for ( itr = Core::gamestate.Realms.begin(); itr != Core::gamestate.Realms.end(); ++itr )
    {
      dict->addMember( ( *itr )->name().c_str(), SetupRealmDetails( *itr ) );
    }

    return dict;
  }
}

BObjectImp* PolSystemExecutorModule::mf_SetSysTrayPopupText()
{
#ifdef _WIN32
  const char* text = exec.paramAsString( 0 );

  Core::CoreSetSysTrayToolTip( text, Core::ToolTipPriorityScript );
#endif
  return new BLong( 1 );
}

BObjectImp* PolSystemExecutorModule::mf_GetItemDescriptor()
{
  unsigned int objtype;
  if ( Core::getObjtypeParam( exec, 0, objtype ) )
  {
    const Items::ItemDesc& id = Items::find_itemdesc( objtype );
    if ( id.objtype == 0 && id.graphic == 0 )
      return new BError( "Itemdesc.cfg entry for objtype " + Clib::hexint( objtype ) +
                         " not found." );

    std::unique_ptr<BStruct> descriptor( new BStruct() );

    id.PopulateStruct( descriptor.get() );

    return descriptor.release();
  }
  else
  {
    return new BError( "Invalid parameter type" );
  }
}

BObjectImp* PolSystemExecutorModule::mf_FormatItemDescription()
{
  const String* desc;
  unsigned short amount;
  const String* suffix;

  if ( getStringParam( 0, desc ) && getParam( 1, amount ) && getStringParam( 2, suffix ) )
  {
    return new String( Core::format_description( 0, desc->value(), amount, suffix->value() ) );
  }
  else
  {
    return new BError( "Invalid parameter type" );
  }
}

BObjectImp* PolSystemExecutorModule::mf_CreatePacket()
{
  int size;
  unsigned short type;
  if ( exec.getParam( 0, type ) && exec.getParam( 1, size ) )
  {
    if ( type > 0xFF )
      return new BError( "Packet type too high" );

    return new Core::BPacket( static_cast<u8>( type ), static_cast<signed short>( size ) );
  }
  else
  {
    return new BError( "Invalid parameter type" );
  }
}

BObjectImp* PolSystemExecutorModule::mf_AddRealm( /*name,base*/ )
{
  const String* realm_name;
  const String* base;
  if ( !( getStringParam( 0, realm_name ) && getStringParam( 1, base ) ) )
  {
    return new BError( "Invalid parameter" );
  }
  Realms::Realm* baserealm = Core::find_realm( base->value() );
  if ( !baserealm )
    return new BError( "BaseRealm not found." );
  if ( baserealm->is_shadowrealm )
    return new BError( "BaseRealm is a ShadowRealm." );
  if ( Core::defined_realm( realm_name->value() ) )
    return new BError( "Realmname already defined." );
  Core::add_realm( realm_name->value(), baserealm );
  if ( Core::settingsManager.ssopt.decay_items )
  {
    if ( !Plib::systemstate.config.single_thread_decay )
    {
      std::ostringstream thname;
      thname << "Decay_" << realm_name->value();
      threadhelp::start_thread( Core::decay_thread_shadow, thname.str().c_str(),
                                (void*)Core::find_realm( realm_name->value() ) );
    }
  }
  return new BLong( 1 );
}

BObjectImp* PolSystemExecutorModule::mf_DeleteRealm( /*name*/ )
{
  const String* realm_name;
  if ( !( getStringParam( 0, realm_name ) ) )
    return new BError( "Invalid parameter" );

  Realms::Realm* realm = Core::find_realm( realm_name->value() );

  if ( !realm )
    return new BError( "Realm not found." );
  if ( !realm->is_shadowrealm )
    return new BError( "Realm is not a ShadowRealm." );
  if ( realm->mobile_count() > 0 )
    return new BError( "Mobiles in Realm." );
  if ( realm->offline_mobile_count() > 0 )
    return new BError( "Offline characters in Realm" );
  if ( realm->toplevel_item_count() > 0 )
    return new BError( "Items in Realm." );
  if ( realm->multi_count() > 0 )
    return new BError( "Multis in Realm." );

  Core::remove_realm( realm_name->value() );
  return new BLong( 1 );
}

BObjectImp* PolSystemExecutorModule::mf_MD5Encrypt( /*string*/ )
{
  const String* string;
  if ( !( getStringParam( 0, string ) ) )
    return new BError( "Invalid parameter" );
  if ( string->length() < 1 )
    return new BError( "String is empty" );
  std::string temp;
  if ( !Clib::MD5_Encrypt( string->value(), temp ) )
    return new BError( "Failed to encrypt" );
  return new String( temp );
}

BObjectImp* PolSystemExecutorModule::mf_LogCPropProfile()
{
  const std::string filepath = "log/cpprofile.log";
  std::ofstream ofs( filepath.c_str(), std::ios::out | std::ios::app );

  if ( !ofs.is_open() )
    return new BError( "Unable to open file: " + filepath );

  // Write the header
  auto t = std::time( nullptr );
  auto tm = Clib::localtime( t );
  ofs << std::string( 80, '=' ) << std::endl;
  ofs << "CProp profiling information dumped on " << std::asctime( &tm ) << std::endl;
  ofs << "the profiler is using an estimated amount of "
      << Core::CPropProfiler::instance().estimateSize() << " Bytes of memory." << std::endl;
  ofs << "the profiler is currently "
      << ( Plib::systemstate.config.profile_cprops ? "enabled" : "disabled" ) << "." << std::endl;
  ofs << std::endl;

  // Write the body
  Core::CPropProfiler::instance().dumpProfile( ofs );

  // Write the footer
  ofs << std::string( 80, '=' ) << std::endl;

  if ( ofs.fail() )
    return new BError( "Error during write." );

  ofs.close();
  return new BLong( 1 );
}
}
}