21108840797

Committed 18 Jan 2026 08:35AM UTC coverage: 60.508% (+0.02%) from 60.492%

Build # 21108840797

Build Type

push

github

Committed by

web-flow

Commit Message

ClangTidy readability-else-after-return (#857)

* trigger tidy

* Automated clang-tidy change: readability-else-after-return

* compile test

* rerun

* Automated clang-tidy change: readability-else-after-return

* trigger..

* Automated clang-tidy change: readability-else-after-return

* manually removed a few

* Automated clang-tidy change: readability-else-after-return

* removed duplicate code

* fix remaining warnings

* fixed scope

---------

Co-authored-by: Clang Tidy <clang-tidy@users.noreply.github.com>

Run Details

837 of 1874 new or added lines in 151 files covered. (44.66%)

46 existing lines in 25 files now uncovered.

44448 of 73458 relevant lines covered (60.51%)

525066.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

47.98

/pol-core/pol/module/guildmod.cpp

/** @file
 *
 * @par History
 * - 2005/11/26 Shinigami: changed "strcmp" into "stricmp" to suppress Script Errors
 * - 2006/09/27 Shinigami: GCC 3.4.x fix - added "template<>" to TmplExecutorModule
 * - 2007/06/17 Shinigami: added config.world_data_path
 * - 2009/12/21 Turley:    ._method() call fix
 */


#include "guildmod.h"
#include <stddef.h>

#include "../../bscript/berror.h"
#include "../../bscript/executor.h"
#include "../../bscript/objmembers.h"
#include "../../bscript/objmethods.h"
#include "../../clib/rawtypes.h"
#include "../../clib/stlutil.h"
#include "../fnsearch.h"
#include "../globals/uvars.h"
#include "../guilds.h"
#include "../guildscrobj.h"
#include "../mobile/charactr.h"
#include "../polobject.h"
#include "../uoexec.h"
#include "../uoscrobj.h"
#include <module_defs/guilds.h>

#include <memory>


namespace Pol::Module
{
using namespace Bscript;
using UOExecutor = Core::UOExecutor;
/// Guild Object
///  Properties:
///   guild.guildid : integer
///   guild.members : array of offline mobilerefs
///   guild.allyguilds  : array of allied guilds
///   guild.enemyguilds : array of enemy guilds
///
///  Methods:
///   guild.ismember( who )
///   guild.isallyguild( guild )
///   guild.isenemyguild(guild)
///
///   guild.addmember( who )
///   guild.addallyguild( guild )
///   guild.addenemyguild( guild )
///
///   guild.removemember( who )
///   guild.removeallyguild( guild )
///   guild.removeenemyguild( guild )
///
///   guild.getprop( propname )
///   guild.setprop( propname, propvalue )
///   guild.eraseprop( propname )
///

BObjectImp* GuildExecutorModule::CreateGuildRefObjImp( Core::Guild* guild )
{
  return new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) );
}

bool getGuildParam( Executor& exec, unsigned param, Core::Guild*& guild, BError*& err )
{
  BApplicObjBase* aob = nullptr;
  if ( exec.hasParams( param + 1 ) )
    aob = exec.getApplicObjParam( param, &guild_type );

  if ( aob == nullptr )
  {
    err = new BError( "Invalid parameter type" );
    return false;
  }

  EGuildRefObjImp* gr = static_cast<EGuildRefObjImp*>( aob );
  guild = gr->value().get();
  if ( guild->disbanded() )
  {
    err = new BError( "Guild has disbanded" );
    return false;
  }
  return true;
}

BObjectRef EGuildRefObjImp::get_member_id( const int id )  // id test
{
  if ( obj_->_disbanded )
    return BObjectRef( new BError( "Guild has disbanded" ) );

  switch ( id )
  {
  case MBR_MEMBERS:
  {
    std::unique_ptr<ObjArray> arr;
    arr = std::make_unique<ObjArray>();
    for ( Core::SerialSet::iterator itr = obj_->_member_serials.begin();
          itr != obj_->_member_serials.end();
          /* do this earlier */ )
    {
      unsigned int mserial = ( *itr );
      Core::SerialSet::iterator last_itr = itr;
      ++itr;

      Mobile::Character* chr = Core::system_find_mobile( mserial );
      if ( chr != nullptr )
      {
        arr->addElement( new EOfflineCharacterRefObjImp( chr ) );
      }
      else
      {
        obj_->_member_serials.erase( last_itr );
      }
    }
    return BObjectRef( arr.release() );
  }

  case MBR_ALLYGUILDS:
  {
    std::unique_ptr<ObjArray> arr;
    arr = std::make_unique<ObjArray>();
    for ( Core::SerialSet::iterator itr = obj_->_allyguild_serials.begin();
          itr != obj_->_allyguild_serials.end();
          /* do this earlier */ )
    {
      unsigned int gserial = ( *itr );
      Core::SerialSet::iterator last_itr = itr;
      ++itr;

      Core::Guild* guild = Core::Guild::FindGuild( gserial );

      if ( guild != nullptr )
      {
        arr->addElement( new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) ) );
      }
      else
      {
        obj_->_allyguild_serials.erase( last_itr );
      }
    }
    return BObjectRef( arr.release() );
  }

  case MBR_ENEMYGUILDS:
  {
    std::unique_ptr<ObjArray> arr;
    arr = std::make_unique<ObjArray>();
    for ( Core::SerialSet::iterator itr = obj_->_enemyguild_serials.begin();
          itr != obj_->_enemyguild_serials.end();
          /* do this earlier */ )
    {
      unsigned int gserial = ( *itr );
      Core::SerialSet::iterator last_itr = itr;
      ++itr;

      Core::Guild* guild = Core::Guild::FindGuild( gserial );

      if ( guild != nullptr )
      {
        arr->addElement( new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) ) );
      }
      else
      {
        obj_->_enemyguild_serials.erase( last_itr );
      }
    }
    return BObjectRef( arr.release() );
  }

  case MBR_GUILDID:
    return BObjectRef( new BLong( obj_->_guildid ) );
  default:
    return BObjectRef( UninitObject::create() );
  }
}
BObjectRef EGuildRefObjImp::get_member( const char* membername )
{
  if ( obj_->_disbanded )
    return BObjectRef( new BError( "Guild has disbanded" ) );

  ObjMember* objmember = getKnownObjMember( membername );
  if ( objmember != nullptr )
    return this->get_member_id( objmember->id );
  return BObjectRef( UninitObject::create() );
}

BObjectImp* EGuildRefObjImp::call_polmethod_id( const int id, UOExecutor& ex, bool forcebuiltin )
{
  if ( obj_->_disbanded )
    return new BError( "Guild has disbanded" );
  ObjMethod* mth = getObjMethod( id );
  if ( mth->overridden && !forcebuiltin )
  {
    auto* result = Core::gamestate.system_hooks.call_script_method( mth->code, &ex, this );
    if ( result )
      return result;
  }

  switch ( id )
  {
  case MTH_ISMEMBER:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Mobile::Character* chr;
    if ( !ex.getCharacterParam( 0, chr ) )
      return new BError( "Invalid parameter type" );

    return new BLong( static_cast<int>( obj_->_member_serials.count( chr->serial ) ) );
  }

  case MTH_ISALLYGUILD:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Core::Guild* allyguild;
    BError* err;
    if ( getGuildParam( ex, 0, allyguild, err ) )
      return new BLong(
          static_cast<int>( obj_->_allyguild_serials.count( allyguild->guildid() ) ) );
    return err;
  }

  case MTH_ISENEMYGUILD:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Core::Guild* enemyguild;
    BError* err;
    if ( getGuildParam( ex, 0, enemyguild, err ) )
      return new BLong(
          static_cast<int>( obj_->_enemyguild_serials.count( enemyguild->guildid() ) ) );
    return err;
  }

  case MTH_ADDMEMBER:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Mobile::Character* chr;
    if ( !ex.getCharacterParam( 0, chr ) )
      return new BError( "Invalid parameter type" );
    if ( chr->guildid() )
      return new BError( "Character already belongs to a guild" );

    chr->guild( obj_.get() );
    obj_->_member_serials.insert( chr->serial );

    // MuadDib Added to update online members when status changes.
    obj_->update_online_members();

    return new BLong( 1 );
  }

  case MTH_ADDALLYGUILD:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Core::Guild* allyguild;
    BError* err;
    if ( getGuildParam( ex, 0, allyguild, err ) )
    {
      if ( obj_->_enemyguild_serials.count( allyguild->guildid() ) )
        return new BError( "That is an enemy guild" );
      if ( allyguild->guildid() == obj_->guildid() )
        return new BError( "Passed self as new ally guild" );

      obj_->_allyguild_serials.insert( allyguild->guildid() );
      allyguild->_allyguild_serials.insert( obj_->_guildid );

      // MuadDib Added to update online members when status changes.
      obj_->update_online_members();
      allyguild->update_online_members();

      return new BLong( 1 );
    }
    return err;
  }

  case MTH_ADDENEMYGUILD:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Core::Guild* enemyguild;
    BError* err;
    if ( getGuildParam( ex, 0, enemyguild, err ) )
    {
      if ( obj_->_allyguild_serials.count( enemyguild->guildid() ) )
        return new BError( "That is an ally guild" );
      if ( enemyguild->guildid() == obj_->guildid() )
        return new BError( "Passed self as new enemy guild" );

      obj_->_enemyguild_serials.insert( enemyguild->guildid() );
      enemyguild->_enemyguild_serials.insert( obj_->_guildid );

      // MuadDib Added to update online members when status changes.
      obj_->update_online_members();
      enemyguild->update_online_members();

      return new BLong( 1 );
    }
    return err;
  }

  case MTH_REMOVEMEMBER:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Mobile::Character* chr;
    if ( !ex.getCharacterParam( 0, chr ) )
      return new BError( "Invalid parameter type" );
    if ( chr->guildid() != obj_->_guildid )
      return new BError( "Character does not belong to this guild" );

    chr->guild( nullptr );
    obj_->_member_serials.erase( chr->serial );

    // MuadDib Added to update online members when status changes.
    obj_->update_online_members_remove( chr );

    return new BLong( 1 );
  }

  case MTH_REMOVEALLYGUILD:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Core::Guild* allyguild;
    BError* err;
    if ( getGuildParam( ex, 0, allyguild, err ) )
    {
      if ( !obj_->_allyguild_serials.count( allyguild->guildid() ) )
        return new BError( "That is not an ally guild" );

      obj_->_allyguild_serials.erase( allyguild->guildid() );
      allyguild->_allyguild_serials.erase( obj_->_guildid );

      // MuadDib Added to update online members when status changes.
      obj_->update_online_members();
      allyguild->update_online_members();

      return new BLong( 1 );
    }
    return err;
  }

  case MTH_REMOVEENEMYGUILD:
  {
    if ( !ex.hasParams( 1 ) )
      return new BError( "Not enough parameters" );
    Core::Guild* enemyguild;
    BError* err;
    if ( getGuildParam( ex, 0, enemyguild, err ) )
    {
      if ( !obj_->_enemyguild_serials.count( enemyguild->guildid() ) )
        return new BError( "That is not an enemy guild" );

      obj_->_enemyguild_serials.erase( enemyguild->guildid() );
      enemyguild->_enemyguild_serials.erase( obj_->_guildid );

      // MuadDib Added to update online members when status changes.
      obj_->update_online_members();
      enemyguild->update_online_members();

      return new BLong( 1 );
    }
    return err;
  }
  default:
  {
    bool changed = false;
    return CallPropertyListMethod_id( obj_->_proplist, id, ex, changed );
  }
  }
}

BObjectImp* EGuildRefObjImp::call_polmethod( const char* methodname, UOExecutor& ex )
{
  if ( obj_->_disbanded )
    return new BError( "Guild has disbanded" );
  bool forcebuiltin{ Executor::builtinMethodForced( methodname ) };
  Bscript::ObjMethod* objmethod = Bscript::getKnownObjMethod( methodname );
  if ( objmethod != nullptr )
    return call_polmethod_id( objmethod->id, ex, forcebuiltin );
  auto* res = Core::gamestate.system_hooks.call_script_method( methodname, &ex, this );
  if ( res )
    return res;

  bool changed = false;
  return CallPropertyListMethod( obj_->_proplist, methodname, ex, changed );
}


GuildExecutorModule::GuildExecutorModule( Bscript::Executor& exec )
    : TmplExecutorModule<GuildExecutorModule, Core::PolModule>( exec )
{
}

///  ListGuilds returns an array of Guild objects
BObjectImp* GuildExecutorModule::mf_ListGuilds()
{
  std::unique_ptr<ObjArray> result( new ObjArray );
  for ( Core::Guilds::iterator itr = Core::gamestate.guilds.begin(),
                               end = Core::gamestate.guilds.end();
        itr != end; ++itr )
  {
    Core::Guild* guild = ( *itr ).second.get();
    result->addElement( new EGuildRefObjImp( Core::GuildRef( guild ) ) );
  }
  return result.release();
}

///  CreateGuild returns a new Guild object
BObjectImp* GuildExecutorModule::mf_CreateGuild()
{
  Core::Guild* guild = new Core::Guild( Core::gamestate.nextguildid++ );

  Core::gamestate.guilds[guild->guildid()].set( guild );

  return new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) );
}

BObjectImp* GuildExecutorModule::mf_DestroyGuild()
{
  Core::Guild* guild;
  BError* err;
  if ( getGuildParam( exec, 0, guild, err ) )
  {
    if ( guild->hasMembers() )
      return new BError( "Guild has members" );
    if ( guild->hasAllies() )
      return new BError( "Guild has allies" );
    if ( guild->hasEnemies() )
      return new BError( "Guild has enemies" );

    guild->disband();
    Core::gamestate.guilds.erase( guild->guildid() );
    return new BLong( 1 );
  }

  return err;
}

///  FindGuild( guildid );
BObjectImp* GuildExecutorModule::mf_FindGuild()
{
  int guildid;
  if ( getParam( 0, guildid ) )
  {
    Core::Guilds::iterator itr = Core::gamestate.guilds.find( guildid );
    if ( itr != Core::gamestate.guilds.end() )
      return new EGuildRefObjImp( ref_ptr<Core::Guild>( ( *itr ).second.get() ) );
    return new BError( "Guild not found" );
  }

  return new BError( "Invalid parameter type" );
}
}  // namespace Pol::Module

1	/** @file
2	*
3	* @par History
4	* - 2005/11/26 Shinigami: changed "strcmp" into "stricmp" to suppress Script Errors
5	* - 2006/09/27 Shinigami: GCC 3.4.x fix - added "template<>" to TmplExecutorModule
6	* - 2007/06/17 Shinigami: added config.world_data_path
7	* - 2009/12/21 Turley: ._method() call fix
8	*/
9
10
11	#include "guildmod.h"
12	#include <stddef.h>
13
14	#include "../../bscript/berror.h"
15	#include "../../bscript/executor.h"
16	#include "../../bscript/objmembers.h"
17	#include "../../bscript/objmethods.h"
18	#include "../../clib/rawtypes.h"
19	#include "../../clib/stlutil.h"
20	#include "../fnsearch.h"
21	#include "../globals/uvars.h"
22	#include "../guilds.h"
23	#include "../guildscrobj.h"
24	#include "../mobile/charactr.h"
25	#include "../polobject.h"
26	#include "../uoexec.h"
27	#include "../uoscrobj.h"
28	#include <module_defs/guilds.h>
29
30	#include <memory>
31
32
33	namespace Pol::Module
34	{
35	using namespace Bscript;
36	using UOExecutor = Core::UOExecutor;
37	/// Guild Object
38	/// Properties:
39	/// guild.guildid : integer
40	/// guild.members : array of offline mobilerefs
41	/// guild.allyguilds : array of allied guilds
42	/// guild.enemyguilds : array of enemy guilds
43	///
44	/// Methods:
45	/// guild.ismember( who )
46	/// guild.isallyguild( guild )
47	/// guild.isenemyguild(guild)
48	///
49	/// guild.addmember( who )
50	/// guild.addallyguild( guild )
51	/// guild.addenemyguild( guild )
52	///
53	/// guild.removemember( who )
54	/// guild.removeallyguild( guild )
55	/// guild.removeenemyguild( guild )
56	///
57	/// guild.getprop( propname )
58	/// guild.setprop( propname, propvalue )
59	/// guild.eraseprop( propname )
60	///
61
62	BObjectImp* GuildExecutorModule::CreateGuildRefObjImp( Core::Guild* guild )	×
63	{
64	return new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) );	×
65	}
66
67	bool getGuildParam( Executor& exec, unsigned param, Core::Guild& guild, BError& err )	2✔
68	{
69	BApplicObjBase* aob = nullptr;	2✔
70	if ( exec.hasParams( param + 1 ) )	2✔
71	aob = exec.getApplicObjParam( param, &guild_type );	2✔
72
73	if ( aob == nullptr )	2✔
74	{
75	err = new BError( "Invalid parameter type" );	×
76	return false;	×
77	}
78
79	EGuildRefObjImp* gr = static_cast<EGuildRefObjImp*>( aob );	2✔
80	guild = gr->value().get();	2✔
81	if ( guild->disbanded() )	2✔
82	{
83	err = new BError( "Guild has disbanded" );	×
84	return false;	×
85	}
86	return true;	2✔
87	}
88
89	BObjectRef EGuildRefObjImp::get_member_id( const int id ) // id test	3✔
90	{
91	if ( obj_->_disbanded )	3✔
92	return BObjectRef( new BError( "Guild has disbanded" ) );	×
93
94	switch ( id )	3✔
95	{
96	case MBR_MEMBERS:	1✔
97	{
98	std::unique_ptr<ObjArray> arr;	1✔
99	arr = std::make_unique<ObjArray>();	1✔
100	for ( Core::SerialSet::iterator itr = obj_->_member_serials.begin();	1✔
101	itr != obj_->_member_serials.end();	3✔
102	/* do this earlier */ )
103	{
104	unsigned int mserial = ( *itr );	2✔
105	Core::SerialSet::iterator last_itr = itr;	2✔
106	++itr;	2✔
107
108	Mobile::Character* chr = Core::system_find_mobile( mserial );	2✔
109	if ( chr != nullptr )	2✔
110	{
111	arr->addElement( new EOfflineCharacterRefObjImp( chr ) );	2✔
112	}
113	else
114	{
115	obj_->_member_serials.erase( last_itr );	×
116	}
117	}
118	return BObjectRef( arr.release() );	1✔
119	}	1✔
120
121	case MBR_ALLYGUILDS:	1✔
122	{
123	std::unique_ptr<ObjArray> arr;	1✔
124	arr = std::make_unique<ObjArray>();	1✔
125	for ( Core::SerialSet::iterator itr = obj_->_allyguild_serials.begin();	1✔
126	itr != obj_->_allyguild_serials.end();	2✔
127	/* do this earlier */ )
128	{
129	unsigned int gserial = ( *itr );	1✔
130	Core::SerialSet::iterator last_itr = itr;	1✔
131	++itr;	1✔
132
133	Core::Guild* guild = Core::Guild::FindGuild( gserial );	1✔
134
135	if ( guild != nullptr )	1✔
136	{
137	arr->addElement( new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) ) );	1✔
138	}
139	else
140	{
141	obj_->_allyguild_serials.erase( last_itr );	×
142	}
143	}
144	return BObjectRef( arr.release() );	1✔
145	}	1✔
146
147	case MBR_ENEMYGUILDS:	1✔
148	{
149	std::unique_ptr<ObjArray> arr;	1✔
150	arr = std::make_unique<ObjArray>();	1✔
151	for ( Core::SerialSet::iterator itr = obj_->_enemyguild_serials.begin();	1✔
152	itr != obj_->_enemyguild_serials.end();	2✔
153	/* do this earlier */ )
154	{
155	unsigned int gserial = ( *itr );	1✔
156	Core::SerialSet::iterator last_itr = itr;	1✔
157	++itr;	1✔
158
159	Core::Guild* guild = Core::Guild::FindGuild( gserial );	1✔
160
161	if ( guild != nullptr )	1✔
162	{
163	arr->addElement( new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) ) );	1✔
164	}
165	else
166	{
167	obj_->_enemyguild_serials.erase( last_itr );	×
168	}
169	}
170	return BObjectRef( arr.release() );	1✔
171	}	1✔
172
173	case MBR_GUILDID:	×
174	return BObjectRef( new BLong( obj_->_guildid ) );	×
175	default:	×
176	return BObjectRef( UninitObject::create() );	×
177	}
178	}
179	BObjectRef EGuildRefObjImp::get_member( const char* membername )	×
180	{
181	if ( obj_->_disbanded )	×
182	return BObjectRef( new BError( "Guild has disbanded" ) );	×
183
184	ObjMember* objmember = getKnownObjMember( membername );	×
185	if ( objmember != nullptr )	×
186	return this->get_member_id( objmember->id );	×
NEW 187	return BObjectRef( UninitObject::create() );	×
188	}
189
190	BObjectImp* EGuildRefObjImp::call_polmethod_id( const int id, UOExecutor& ex, bool forcebuiltin )	14✔
191	{
192	if ( obj_->_disbanded )	14✔
193	return new BError( "Guild has disbanded" );	×
194	ObjMethod* mth = getObjMethod( id );	14✔
195	if ( mth->overridden && !forcebuiltin )	14✔
196	{
197	auto* result = Core::gamestate.system_hooks.call_script_method( mth->code, &ex, this );	×
198	if ( result )	×
199	return result;	×
200	}
201
202	switch ( id )	14✔
203	{
204	case MTH_ISMEMBER:	2✔
205	{
206	if ( !ex.hasParams( 1 ) )	2✔
207	return new BError( "Not enough parameters" );	×
208	Mobile::Character* chr;
209	if ( !ex.getCharacterParam( 0, chr ) )	2✔
210	return new BError( "Invalid parameter type" );	×
211
212	return new BLong( static_cast<int>( obj_->_member_serials.count( chr->serial ) ) );	2✔
213	}
214
215	case MTH_ISALLYGUILD:	×
216	{
217	if ( !ex.hasParams( 1 ) )	×
218	return new BError( "Not enough parameters" );	×
219	Core::Guild* allyguild;
220	BError* err;
221	if ( getGuildParam( ex, 0, allyguild, err ) )	×
222	return new BLong(
223	static_cast<int>( obj_->_allyguild_serials.count( allyguild->guildid() ) ) );	×
NEW 224	return err;	×
225	}
226
227	case MTH_ISENEMYGUILD:	×
228	{
229	if ( !ex.hasParams( 1 ) )	×
230	return new BError( "Not enough parameters" );	×
231	Core::Guild* enemyguild;
232	BError* err;
233	if ( getGuildParam( ex, 0, enemyguild, err ) )	×
234	return new BLong(
235	static_cast<int>( obj_->_enemyguild_serials.count( enemyguild->guildid() ) ) );	×
NEW 236	return err;	×
237	}
238
239	case MTH_ADDMEMBER:	2✔
240	{
241	if ( !ex.hasParams( 1 ) )	2✔
242	return new BError( "Not enough parameters" );	×
243	Mobile::Character* chr;
244	if ( !ex.getCharacterParam( 0, chr ) )	2✔
245	return new BError( "Invalid parameter type" );	×
246	if ( chr->guildid() )	2✔
247	return new BError( "Character already belongs to a guild" );	×
248
249	chr->guild( obj_.get() );	2✔
250	obj_->_member_serials.insert( chr->serial );	2✔
251
252	// MuadDib Added to update online members when status changes.
253	obj_->update_online_members();	2✔
254
255	return new BLong( 1 );	2✔
256	}
257
258	case MTH_ADDALLYGUILD:	1✔
259	{
260	if ( !ex.hasParams( 1 ) )	1✔
261	return new BError( "Not enough parameters" );	×
262	Core::Guild* allyguild;
263	BError* err;
264	if ( getGuildParam( ex, 0, allyguild, err ) )	1✔
265	{
266	if ( obj_->_enemyguild_serials.count( allyguild->guildid() ) )	1✔
267	return new BError( "That is an enemy guild" );	×
268	if ( allyguild->guildid() == obj_->guildid() )	1✔
269	return new BError( "Passed self as new ally guild" );	×
270
271	obj_->_allyguild_serials.insert( allyguild->guildid() );	1✔
272	allyguild->_allyguild_serials.insert( obj_->_guildid );	1✔
273
274	// MuadDib Added to update online members when status changes.
275	obj_->update_online_members();	1✔
276	allyguild->update_online_members();	1✔
277
278	return new BLong( 1 );	1✔
279	}
NEW 280	return err;	×
281	}
282
283	case MTH_ADDENEMYGUILD:	1✔
284	{
285	if ( !ex.hasParams( 1 ) )	1✔
286	return new BError( "Not enough parameters" );	×
287	Core::Guild* enemyguild;
288	BError* err;
289	if ( getGuildParam( ex, 0, enemyguild, err ) )	1✔
290	{
291	if ( obj_->_allyguild_serials.count( enemyguild->guildid() ) )	1✔
292	return new BError( "That is an ally guild" );	×
293	if ( enemyguild->guildid() == obj_->guildid() )	1✔
294	return new BError( "Passed self as new enemy guild" );	×
295
296	obj_->_enemyguild_serials.insert( enemyguild->guildid() );	1✔
297	enemyguild->_enemyguild_serials.insert( obj_->_guildid );	1✔
298
299	// MuadDib Added to update online members when status changes.
300	obj_->update_online_members();	1✔
301	enemyguild->update_online_members();	1✔
302
303	return new BLong( 1 );	1✔
304	}
NEW 305	return err;	×
306	}
307
308	case MTH_REMOVEMEMBER:	×
309	{
310	if ( !ex.hasParams( 1 ) )	×
311	return new BError( "Not enough parameters" );	×
312	Mobile::Character* chr;
313	if ( !ex.getCharacterParam( 0, chr ) )	×
314	return new BError( "Invalid parameter type" );	×
315	if ( chr->guildid() != obj_->_guildid )	×
316	return new BError( "Character does not belong to this guild" );	×
317
318	chr->guild( nullptr );	×
319	obj_->_member_serials.erase( chr->serial );	×
320
321	// MuadDib Added to update online members when status changes.
322	obj_->update_online_members_remove( chr );	×
323
324	return new BLong( 1 );	×
325	}
326
327	case MTH_REMOVEALLYGUILD:	×
328	{
329	if ( !ex.hasParams( 1 ) )	×
330	return new BError( "Not enough parameters" );	×
331	Core::Guild* allyguild;
332	BError* err;
333	if ( getGuildParam( ex, 0, allyguild, err ) )	×
334	{
335	if ( !obj_->_allyguild_serials.count( allyguild->guildid() ) )	×
336	return new BError( "That is not an ally guild" );	×
337
338	obj_->_allyguild_serials.erase( allyguild->guildid() );	×
339	allyguild->_allyguild_serials.erase( obj_->_guildid );	×
340
341	// MuadDib Added to update online members when status changes.
342	obj_->update_online_members();	×
343	allyguild->update_online_members();	×
344
345	return new BLong( 1 );	×
346	}
NEW 347	return err;	×
348	}
349
350	case MTH_REMOVEENEMYGUILD:	×
351	{
352	if ( !ex.hasParams( 1 ) )	×
353	return new BError( "Not enough parameters" );	×
354	Core::Guild* enemyguild;
355	BError* err;
356	if ( getGuildParam( ex, 0, enemyguild, err ) )	×
357	{
358	if ( !obj_->_enemyguild_serials.count( enemyguild->guildid() ) )	×
359	return new BError( "That is not an enemy guild" );	×
360
361	obj_->_enemyguild_serials.erase( enemyguild->guildid() );	×
362	enemyguild->_enemyguild_serials.erase( obj_->_guildid );	×
363
364	// MuadDib Added to update online members when status changes.
365	obj_->update_online_members();	×
366	enemyguild->update_online_members();	×
367
368	return new BLong( 1 );	×
369	}
NEW 370	return err;	×
371	}
372	default:	8✔
373	{
374	bool changed = false;	8✔
375	return CallPropertyListMethod_id( obj_->_proplist, id, ex, changed );	8✔
376	}
377	}
378	}
379
380	BObjectImp* EGuildRefObjImp::call_polmethod( const char* methodname, UOExecutor& ex )	×
381	{
382	if ( obj_->_disbanded )	×
383	return new BError( "Guild has disbanded" );	×
384	bool forcebuiltin{ Executor::builtinMethodForced( methodname ) };	×
385	Bscript::ObjMethod* objmethod = Bscript::getKnownObjMethod( methodname );	×
386	if ( objmethod != nullptr )	×
387	return call_polmethod_id( objmethod->id, ex, forcebuiltin );	×
388	auto* res = Core::gamestate.system_hooks.call_script_method( methodname, &ex, this );	×
389	if ( res )	×
390	return res;	×
391
392	bool changed = false;	×
393	return CallPropertyListMethod( obj_->_proplist, methodname, ex, changed );	×
394	}
395
396
397	GuildExecutorModule::GuildExecutorModule( Bscript::Executor& exec )	371✔
398	: TmplExecutorModule<GuildExecutorModule, Core::PolModule>( exec )	371✔
399	{
400	}	371✔
401
402	/// ListGuilds returns an array of Guild objects
403	BObjectImp* GuildExecutorModule::mf_ListGuilds()	1✔
404	{
405	std::unique_ptr<ObjArray> result( new ObjArray );	1✔
406	for ( Core::Guilds::iterator itr = Core::gamestate.guilds.begin(),	2✔
407	end = Core::gamestate.guilds.end();	1✔
408	itr != end; ++itr )	4✔
409	{
410	Core::Guild* guild = ( *itr ).second.get();	3✔
411	result->addElement( new EGuildRefObjImp( Core::GuildRef( guild ) ) );	3✔
412	}
413	return result.release();	2✔
414	}	1✔
415
416	/// CreateGuild returns a new Guild object
417	BObjectImp* GuildExecutorModule::mf_CreateGuild()	3✔
418	{
419	Core::Guild* guild = new Core::Guild( Core::gamestate.nextguildid++ );	3✔
420
421	Core::gamestate.guilds[guild->guildid()].set( guild );	3✔
422
423	return new EGuildRefObjImp( ref_ptr<Core::Guild>( guild ) );	3✔
424	}
425
426	BObjectImp* GuildExecutorModule::mf_DestroyGuild()	×
427	{
428	Core::Guild* guild;
429	BError* err;
430	if ( getGuildParam( exec, 0, guild, err ) )	×
431	{
432	if ( guild->hasMembers() )	×
433	return new BError( "Guild has members" );	×
434	if ( guild->hasAllies() )	×
435	return new BError( "Guild has allies" );	×
436	if ( guild->hasEnemies() )	×
437	return new BError( "Guild has enemies" );	×
438
439	guild->disband();	×
440	Core::gamestate.guilds.erase( guild->guildid() );	×
441	return new BLong( 1 );	×
442	}
443
NEW 444	return err;	×
445	}
446
447	/// FindGuild( guildid );
448	BObjectImp* GuildExecutorModule::mf_FindGuild()	×
449	{
450	int guildid;
451	if ( getParam( 0, guildid ) )	×
452	{
453	Core::Guilds::iterator itr = Core::gamestate.guilds.find( guildid );	×
454	if ( itr != Core::gamestate.guilds.end() )	×
455	return new EGuildRefObjImp( ref_ptr<Core::Guild>( ( *itr ).second.get() ) );	×
NEW 456	return new BError( "Guild not found" );	×
457	}
458
NEW 459	return new BError( "Invalid parameter type" );	×
460	}
461	} // namespace Pol::Module

polserver / polserver / 21108840797

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous