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

94.37

/pol-core/pol/multi/multidef.cpp

/** @file
 *
 * @par History
 * - 2009/09/01 Turley:    VS2005/2008 Support moved inline MultiDef::getkey to .h
 * - 2009/09/03 MuadDib:   Relocation of multi related cpp/h
 */


#include "multidef.h"

#include <cstdio>
#include <sstream>
#include <string>

#include "../../clib/cfgelem.h"
#include "../../clib/cfgfile.h"
#include "../../clib/passert.h"
#include "../../clib/stlutil.h"
#include "../../clib/strutil.h"
#include "../globals/multidefs.h"


namespace Pol::Multi
{
bool BoatShapeExists( u16 graphic );

MultiDef::MultiDef( Clib::ConfigElem& elem, u16 multiid )
    : multiid( multiid ),
      is_boat( false ),
      elems(),

      minrxyz(),
      maxrxyz(),
      max_radius( 0 )
{
  if ( elem.type_is( "BOAT" ) )
  {
    if ( !BoatShapeExists( multiid ) )
      elem.throw_error( "Entry for Boat (multiid " + Clib::hexint( multiid ) +
                        ") not found in boats.cfg" );
    is_boat = true;
  }

  std::string tmp;
  while ( elem.remove_prop( "static", &tmp ) )
  {
    std::istringstream is( tmp );
    MULTI_ELEM multielem;
    multielem.is_static = true;
    s16 x, y, z;
    if ( is >> std::hex >> multielem.objtype >> std::dec >> x >> y >> z )
    {
      multielem.relpos.x( x ).y( y ).z( z );
      elems.push_back( multielem );
    }
    else
    {
      std::string message = "Badly formed static directive: '" + tmp + "'";
      elem.throw_error( message );
    }
  }
  while ( elem.remove_prop( "dynamic", &tmp ) )
  {
    std::istringstream is( tmp );
    MULTI_ELEM multielem;
    multielem.is_static = false;
    s16 x, y, z;
    if ( is >> std::hex >> multielem.objtype >> std::dec >> x >> y >> z )
    {
      multielem.relpos.x( x ).y( y ).z( z );
      elems.push_back( multielem );
    }
    else
    {
      std::string message = "Badly formed dynamic directive: '" + tmp + "'";
      elem.throw_error( message );
    }
  }
}

bool MultiDef::findcomponents( Components::const_iterator& beg, Components::const_iterator& end,
                               const Core::Vec2d& rxy ) const
{
  ItrPair pr = components.equal_range( getkey( rxy ) );
  if ( pr.first == components.end() )
  {
    return false;
  }

  beg = pr.first;
  end = pr.second;
  return true;
}

bool MultiDef::body_contains( const Core::Vec2d& rxy ) const
{
  return ( components.count( getkey( rxy ) ) != 0 );
}
const MULTI_ELEM* MultiDef::find_component( const Core::Vec2d& rxy ) const
{
  if ( body_contains( rxy ) )
    return ( *components.find( getkey( rxy ) ) ).second;
  return nullptr;
}

void MultiDef::add_to_hull( const MULTI_ELEM* elem )
{
  unsigned short k = getkey( elem->relpos.xy() );

  if ( !hull2.count( k ) )
  {
    hull.push_back( elem );
    hull2.insert( k );
  }


  if ( is_boat )
  {
    Core::Vec2d rxy = elem->relpos.xy();
    if ( ( multiid & 1 ) == 0 )  // N/S hull, so squeeze X
    {
      if ( rxy.x() == minrxyz.x() )
        rxy.x( minrxyz.x() + 1 );
      else if ( rxy.x() == maxrxyz.x() )
        rxy.x( maxrxyz.x() - 1 );
    }
    else
    {
      if ( rxy.y() == minrxyz.y() )
        rxy.y( minrxyz.y() + 1 );
      else if ( rxy.y() > 0 )
        rxy.y( maxrxyz.y() - 1 );
    }
    elem = find_component( rxy );
    if ( elem )
      add_to_internal_hull( elem );
  }
}

void MultiDef::add_to_internal_hull( const MULTI_ELEM* elem )
{
  unsigned short k = getkey( elem->relpos.xy() );

  if ( !internal_hull2.count( k ) )
  {
    internal_hull.push_back( elem );
    internal_hull2.insert( k );
  }
}

void MultiDef::add_body_tohull()
{
  short rx, ry;
  for ( ry = minrxyz.y(); ry <= maxrxyz.y(); ++ry )
  {
    for ( rx = minrxyz.x(); rx <= maxrxyz.x(); ++rx )
    {
      const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );
      if ( elem != nullptr )
      {
        add_to_hull( elem );

        break;
      }
    }
    for ( rx = maxrxyz.x(); rx >= minrxyz.x(); --rx )
    {
      const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );
      if ( elem != nullptr )
      {
        add_to_hull( elem );

        break;
      }
    }
  }


  for ( rx = minrxyz.x(); rx <= maxrxyz.x(); ++rx )
  {
    for ( ry = minrxyz.y(); ry <= maxrxyz.y(); ++ry )
    {
      const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );
      if ( elem != nullptr )
      {
        add_to_hull( elem );
        break;
      }
    }
    for ( ry = maxrxyz.y(); ry >= minrxyz.y(); --ry )
    {
      const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );
      if ( elem != nullptr )
      {
        add_to_hull( elem );
        break;
      }
    }
  }
}


void MultiDef::computehull()
{
  add_body_tohull();
}

void MultiDef::addrec( const MULTI_ELEM* elem )
{
  minrxyz.x( std::min( minrxyz.x(), elem->relpos.x() ) )
      .y( std::min( minrxyz.y(), elem->relpos.y() ) )
      .z( std::min( minrxyz.z(), elem->relpos.z() ) );
  maxrxyz.x( std::max( maxrxyz.x(), elem->relpos.x() ) )
      .y( std::max( maxrxyz.y(), elem->relpos.y() ) )
      .z( std::max( maxrxyz.z(), elem->relpos.z() ) );
  max_radius = (u8)std::max( { std::abs( minrxyz.x() ), std::abs( minrxyz.y() ),
                               std::abs( maxrxyz.x() ), std::abs( maxrxyz.y() ) } );
  components.insert( Components::value_type( getkey( elem->relpos.xy() ), elem ) );
}

void MultiDef::init()
{
  for ( unsigned i = 0; i < elems.size(); i++ )
  {
    addrec( &elems[i] );
  }
  computehull();
}

bool MultiDef::within_multi( const Core::Vec2d& relxy ) const
{
  return relxy.x() >= minrxyz.x() && relxy.x() <= maxrxyz.x() && relxy.y() >= minrxyz.y() &&
         relxy.y() <= maxrxyz.y();
}

size_t MultiDef::estimateSize() const
{
  size_t size = sizeof( MultiDef );
  size += Clib::memsize( elems ) + Clib::memsize( hull ) + Clib::memsize( internal_hull ) +
          Clib::memsize( hull2 ) + Clib::memsize( internal_hull2 ) + Clib::memsize( components );
  return size;
}

bool MultiDefByMultiIDExists( u16 multiid )
{
  return multidef_buffer.multidefs_by_multiid.count( multiid ) != 0;
}
const MultiDef* MultiDefByMultiID( u16 multiid )
{
  passert( multidef_buffer.multidefs_by_multiid.count( multiid ) != 0 );

  MultiDefs::const_iterator citr = multidef_buffer.multidefs_by_multiid.find( multiid );
  if ( citr != multidef_buffer.multidefs_by_multiid.end() )
    return ( *citr ).second;
  return nullptr;
}


void read_multidefs()
{
  // Include HOUSE and STAIRS for backwards-compatibility, but uoconvert no
  // longer generates these elements.
  Clib::ConfigFile cf( "config/multis.cfg", "BOAT HOUSE STAIRS MULTI" );
  Clib::ConfigElem elem;
  while ( cf.read( elem ) )
  {
    u16 multiid = static_cast<u16>( strtoul( elem.rest(), nullptr, 0 ) );
    MultiDef* mdef = new MultiDef( elem, multiid );
    mdef->init();

    multidef_buffer.multidefs_by_multiid[mdef->multiid] = mdef;
  }
}
}  // namespace Pol::Multi

1	/** @file
2	*
3	* @par History
4	* - 2009/09/01 Turley: VS2005/2008 Support moved inline MultiDef::getkey to .h
5	* - 2009/09/03 MuadDib: Relocation of multi related cpp/h
6	*/
7
8
9	#include "multidef.h"
10
11	#include <cstdio>
12	#include <sstream>
13	#include <string>
14
15	#include "../../clib/cfgelem.h"
16	#include "../../clib/cfgfile.h"
17	#include "../../clib/passert.h"
18	#include "../../clib/stlutil.h"
19	#include "../../clib/strutil.h"
20	#include "../globals/multidefs.h"
21
22
23	namespace Pol::Multi
24	{
25	bool BoatShapeExists( u16 graphic );
26
27	MultiDef::MultiDef( Clib::ConfigElem& elem, u16 multiid )	60✔
28	: multiid( multiid ),	60✔
29	is_boat( false ),	60✔
30	elems(),	60✔
31
32	minrxyz(),	60✔
33	maxrxyz(),	60✔
34	max_radius( 0 )	120✔
35	{
36	if ( elem.type_is( "BOAT" ) )	60✔
37	{
38	if ( !BoatShapeExists( multiid ) )	36✔
39	elem.throw_error( "Entry for Boat (multiid " + Clib::hexint( multiid ) +	×
40	") not found in boats.cfg" );
41	is_boat = true;	36✔
42	}
43
44	std::string tmp;	60✔
45	while ( elem.remove_prop( "static", &tmp ) )	2,370✔
46	{
47	std::istringstream is( tmp );	2,310✔
48	MULTI_ELEM multielem;	2,310✔
49	multielem.is_static = true;	2,310✔
50	s16 x, y, z;
51	if ( is >> std::hex >> multielem.objtype >> std::dec >> x >> y >> z )	2,310✔
52	{
53	multielem.relpos.x( x ).y( y ).z( z );	2,310✔
54	elems.push_back( multielem );	2,310✔
55	}
56	else
57	{
58	std::string message = "Badly formed static directive: '" + tmp + "'";	×
59	elem.throw_error( message );	×
60	}	×
61	}	2,310✔
62	while ( elem.remove_prop( "dynamic", &tmp ) )	210✔
63	{
64	std::istringstream is( tmp );	150✔
65	MULTI_ELEM multielem;	150✔
66	multielem.is_static = false;	150✔
67	s16 x, y, z;
68	if ( is >> std::hex >> multielem.objtype >> std::dec >> x >> y >> z )	150✔
69	{
70	multielem.relpos.x( x ).y( y ).z( z );	150✔
71	elems.push_back( multielem );	150✔
72	}
73	else
74	{
75	std::string message = "Badly formed dynamic directive: '" + tmp + "'";	×
76	elem.throw_error( message );	×
77	}	×
78	}	150✔
79	}	60✔
80
81	bool MultiDef::findcomponents( Components::const_iterator& beg, Components::const_iterator& end,	18,945✔
82	const Core::Vec2d& rxy ) const
83	{
84	ItrPair pr = components.equal_range( getkey( rxy ) );	18,945✔
85	if ( pr.first == components.end() )	18,945✔
86	{
87	return false;	10✔
88	}
89
90	beg = pr.first;	18,935✔
91	end = pr.second;	18,935✔
92	return true;	18,935✔
93	}
94
95	bool MultiDef::body_contains( const Core::Vec2d& rxy ) const	22,580✔
96	{
97	return ( components.count( getkey( rxy ) ) != 0 );	22,580✔
98	}
99	const MULTI_ELEM* MultiDef::find_component( const Core::Vec2d& rxy ) const	4,530✔
100	{
101	if ( body_contains( rxy ) )	4,530✔
102	return ( *components.find( getkey( rxy ) ) ).second;	3,150✔
103	return nullptr;	1,380✔
104	}
105
106	void MultiDef::add_to_hull( const MULTI_ELEM* elem )	1,998✔
107	{
108	unsigned short k = getkey( elem->relpos.xy() );	1,998✔
109
110	if ( !hull2.count( k ) )	1,998✔
111	{
112	hull.push_back( elem );	1,290✔
113	hull2.insert( k );	1,290✔
114	}
115
116
117	if ( is_boat )	1,998✔
118	{
119	Core::Vec2d rxy = elem->relpos.xy();	1,152✔
120	if ( ( multiid & 1 ) == 0 ) // N/S hull, so squeeze X	1,152✔
121	{
122	if ( rxy.x() == minrxyz.x() )	576✔
123	rxy.x( minrxyz.x() + 1 );	108✔
124	else if ( rxy.x() == maxrxyz.x() )	468✔
125	rxy.x( maxrxyz.x() - 1 );	90✔
126	}
127	else
128	{
129	if ( rxy.y() == minrxyz.y() )	576✔
130	rxy.y( minrxyz.y() + 1 );	108✔
131	else if ( rxy.y() > 0 )	468✔
132	rxy.y( maxrxyz.y() - 1 );	234✔
133	}
134	elem = find_component( rxy );	1,152✔
135	if ( elem )	1,152✔
136	add_to_internal_hull( elem );	1,152✔
137	}
138	}	1,998✔
139
140	void MultiDef::add_to_internal_hull( const MULTI_ELEM* elem )	1,152✔
141	{
142	unsigned short k = getkey( elem->relpos.xy() );	1,152✔
143
144	if ( !internal_hull2.count( k ) )	1,152✔
145	{
146	internal_hull.push_back( elem );	720✔
147	internal_hull2.insert( k );	720✔
148	}
149	}	1,152✔
150
151	void MultiDef::add_body_tohull()	60✔
152	{
153	short rx, ry;
154	for ( ry = minrxyz.y(); ry <= maxrxyz.y(); ++ry )	471✔
155	{
156	for ( rx = minrxyz.x(); rx <= maxrxyz.x(); ++rx )	756✔
157	{
158	const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );	756✔
159	if ( elem != nullptr )	756✔
160	{
161	add_to_hull( elem );	411✔
162
163	break;	411✔
164	}
165	}
166	for ( rx = maxrxyz.x(); rx >= minrxyz.x(); --rx )	756✔
167	{
168	const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );	756✔
169	if ( elem != nullptr )	756✔
170	{
171	add_to_hull( elem );	411✔
172
173	break;	411✔
174	}
175	}
176	}
177
178
179	for ( rx = minrxyz.x(); rx <= maxrxyz.x(); ++rx )	648✔
180	{
181	for ( ry = minrxyz.y(); ry <= maxrxyz.y(); ++ry )	933✔
182	{
183	const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );	933✔
184	if ( elem != nullptr )	933✔
185	{
186	add_to_hull( elem );	588✔
187	break;	588✔
188	}
189	}
190	for ( ry = maxrxyz.y(); ry >= minrxyz.y(); --ry )	933✔
191	{
192	const MULTI_ELEM* elem = find_component( Core::Vec2d( rx, ry ) );	933✔
193	if ( elem != nullptr )	933✔
194	{
195	add_to_hull( elem );	588✔
196	break;	588✔
197	}
198	}
199	}
200	}	60✔
201
202
203	void MultiDef::computehull()	60✔
204	{
205	add_body_tohull();	60✔
206	}	60✔
207
208	void MultiDef::addrec( const MULTI_ELEM* elem )	2,460✔
209	{
210	minrxyz.x( std::min( minrxyz.x(), elem->relpos.x() ) )	2,460✔
211	.y( std::min( minrxyz.y(), elem->relpos.y() ) )	2,460✔
212	.z( std::min( minrxyz.z(), elem->relpos.z() ) );	2,460✔
213	maxrxyz.x( std::max( maxrxyz.x(), elem->relpos.x() ) )	2,460✔
214	.y( std::max( maxrxyz.y(), elem->relpos.y() ) )	2,460✔
215	.z( std::max( maxrxyz.z(), elem->relpos.z() ) );	2,460✔
216	max_radius = (u8)std::max( { std::abs( minrxyz.x() ), std::abs( minrxyz.y() ),	2,460✔
217	std::abs( maxrxyz.x() ), std::abs( maxrxyz.y() ) } );	2,460✔
218	components.insert( Components::value_type( getkey( elem->relpos.xy() ), elem ) );	2,460✔
219	}	2,460✔
220
221	void MultiDef::init()	60✔
222	{
223	for ( unsigned i = 0; i < elems.size(); i++ )	2,520✔
224	{
225	addrec( &elems[i] );	2,460✔
226	}
227	computehull();	60✔
228	}	60✔
229
230	bool MultiDef::within_multi( const Core::Vec2d& relxy ) const	23,551✔
231	{
232	return relxy.x() >= minrxyz.x() && relxy.x() <= maxrxyz.x() && relxy.y() >= minrxyz.y() &&	42,500✔
233	relxy.y() <= maxrxyz.y();	42,500✔
234	}
235
236	size_t MultiDef::estimateSize() const	20✔
237	{
238	size_t size = sizeof( MultiDef );	20✔
239	size += Clib::memsize( elems ) + Clib::memsize( hull ) + Clib::memsize( internal_hull ) +	20✔
240	Clib::memsize( hull2 ) + Clib::memsize( internal_hull2 ) + Clib::memsize( components );	20✔
241	return size;	20✔
242	}
243
244	bool MultiDefByMultiIDExists( u16 multiid )	24,430✔
245	{
246	return multidef_buffer.multidefs_by_multiid.count( multiid ) != 0;	24,430✔
247	}
248	const MultiDef* MultiDefByMultiID( u16 multiid )	24,382✔
249	{
250	passert( multidef_buffer.multidefs_by_multiid.count( multiid ) != 0 );	24,382✔
251
252	MultiDefs::const_iterator citr = multidef_buffer.multidefs_by_multiid.find( multiid );	24,382✔
253	if ( citr != multidef_buffer.multidefs_by_multiid.end() )	24,382✔
254	return ( *citr ).second;	24,382✔
NEW 255	return nullptr;	×
256	}
257
258
259	void read_multidefs()	3✔
260	{
261	// Include HOUSE and STAIRS for backwards-compatibility, but uoconvert no
262	// longer generates these elements.
263	Clib::ConfigFile cf( "config/multis.cfg", "BOAT HOUSE STAIRS MULTI" );	3✔
264	Clib::ConfigElem elem;	3✔
265	while ( cf.read( elem ) )	63✔
266	{
267	u16 multiid = static_cast<u16>( strtoul( elem.rest(), nullptr, 0 ) );	60✔
268	MultiDef* mdef = new MultiDef( elem, multiid );	60✔
269	mdef->init();	60✔
270
271	multidef_buffer.multidefs_by_multiid[mdef->multiid] = mdef;	60✔
272	}
273	}	3✔
274	} // namespace Pol::Multi

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