perf: apply clang-tidy performance checks

LICENSE.txt

@@ -10,8 +10,6 @@ Terminus Font (data/font/terminus.ttf) is licensed under the SIL Open Font Licen
 
 CATCH unit-test framework (tests/catch/catch.hpp) is licensed under the Boost Software License. Visit https://github.com/philsquared/Catch/blob/master/LICENSE.txt to read the license.
 
-PLF List and PLF Colony (src/list.h, src/colony.h) are licensed under the zLib license (https://www.zlib.net/zlib_license.html).
-
 getpost (tools/json_tools/format/getpost.h) is licensed under the MIT license, see file for text of license.
 
 Lua (src/lua/*) is licensed under the MIT license, see src_lua/LICENSE.md for text of license.

doc/GAME_OBJECTS.md

@@ -0,0 +1,70 @@
+# Game Objects
+
+Many of the things that physically exist within the game world are **game objects(GO)**. Currently
+this only covers items, but creatures and vehicles are coming soon and then probably furniture at
+some point. GOs have a small common interface with methods like name and position that you can find
+in [`game_object.h`](../src/game_object.h). GOs use private constructors, this means **your
+variables must always be references or pointers**. Trying to assign a variable without a layer of
+indirection like that will cause a compile error. Likewise trying to copy one object over another
+will cause a similar error.
+
+```c++
+item& it_ref = ...; // Good
+item* it_pointer; // Good
+
+item it = ...; // Compile error
+it_ref = other; // Compile error
+*it_pointer = other; // Compile error
+```
+
+New GOs can be created via `::spawn` static methods that return a `detached_ptr` to the newly
+created game object. A `detached_ptr` represents an object that does not currently exist in the game
+world. There can only be one `detached_ptr` to an object at a time (those who know
+[`std::unique_ptr`](https://en.cppreference.com/w/cpp/memory/unique_ptr) will be familiar with this
+behavior). Functions that add an object to the world will require that you `std::move` in a
+`detached_ptr`. In general `detached_ptr`s must be `std::move`'d when they're passed into a
+function. Note that you should never use any variable after it has been moved. Likewise functions
+that remove an object from the world will return a `detached_ptr`. This ensures that you can't add
+the same thing to the world twice.
+
+Functions that don't add things to the world just accept normal pointers. You can turn a
+`detached_ptr` into a normal pointer by doing this. Note that you can use this to keep a valid
+pointer to something even after you `std::move` it, but you must do this before the `std::move`
+happens.
+
+```c++
+&*detached
+```
+
+And you can go the other way using this. Though note that it removes the object from the game world
+in the process and will cause errors if called on an object that isn't in the game world.
+
+```c++
+detached_ptr<item> as_detached=normal_ptr->detach();
+```
+
+Trying to access an invalid `detached_ptr` (for instance one that has been `std::move`'d from) will
+cause a debugmsg and give you the null version of that object.
+
+## Safe References
+
+Game objects support safe references. `safe_reference<item>` will refuse access to an object that
+has been destroyed or is outside of the reality bubble without losing track of it, and they can be
+saved and loaded. You must check them as a boolean (e.g. `if( ref )`) to see if they're valid.
+Trying to access them when they're not will cause debugmsgs and give you a null object instead. They
+have a small interface that lets you check if they're destroyed or unloaded etc. If they were
+destroyed or unloaded this turn, they have a method that will allow you to access the object in a
+const fashion, for instance to display an error message.
+
+If you're moving objects around you need to use `detached_ptr`s, but otherwise when choosing which
+reference to use the most important thing to consider is how long you want to hold onto it. If
+you're just using something temporarily, for instance most arguments and variables, you should use a
+normal reference or pointer. If you need to store it for longer you should use a safe reference and
+this means it can be easily stored in the save file. In the rare case that you do want to save it
+across turns but don't want to store it in the save file, which means caches, there's also a fast
+`cache_reference<item>`, which does last across turns but can't be saved.
+
+Game objects can sometimes be split into pieces or merged together. Item stacks are the main example
+of this but there are others like vehicles being split or dissoluted devourers merging. When a stack
+of items is split, the stack that stays in place is the one that safe references will follow. When
+they are merged safe references to either half of the merge will now point to the merge result.

doc/src/content/docs/en/dev/explanation/game_objects.md

@@ -0,0 +1,71 @@
+---
+title: Game Objects
+---
+
+Many of the things that physically exist within the game world are **game objects(GO)**. Currently
+this only covers items, but creatures and vehicles are coming soon and then probably furniture at
+some point. GOs have a small common interface with methods like name and position that you can find
+in `game_object.h`. GOs use private constructors, this means **your variables must always be
+references or pointers**. Trying to assign a variable without a layer of indirection like that will
+cause a compile error. Likewise trying to copy one object over another will cause a similar error.
+
+```cpp
+item& it_ref = ...; // Good
+item* it_pointer; // Good
+
+item it = ...; // Compile error
+it_ref = other; // Compile error
+*it_pointer = other; // Compile error
+```
+
+New GOs can be created via `::spawn` static methods that return a `detached_ptr` to the newly
+created game object. A `detached_ptr` represents an object that does not currently exist in the game
+world. There can only be one `detached_ptr` to an object at a time (those who know
+[`std::unique_ptr`](https://en.cppreference.com/w/cpp/memory/unique_ptr) will be familiar with this
+behavior). Functions that add an object to the world will require that you `std::move` in a
+`detached_ptr`. In general `detached_ptr`s must be `std::move`'d when they're passed into a
+function. Note that you should never use any variable after it has been moved. Likewise functions
+that remove an object from the world will return a `detached_ptr`. This ensures that you can't add
+the same thing to the world twice.
+
+Functions that don't add things to the world just accept normal pointers. You can turn a
+`detached_ptr` into a normal pointer by doing this. Note that you can use this to keep a valid
+pointer to something even after you `std::move` it, but you must do this before the `std::move`
+happens.
+
+```cpp
+&*detached
+```
+
+And you can go the other way using this. Though note that it removes the object from the game world
+in the process and will cause errors if called on an object that isn't in the game world.
+
+```cpp
+detached_ptr<item> as_detached = normal_ptr->detach();
+```
+
+Trying to access an invalid `detached_ptr` (for instance one that has been `std::move`'d from) will
+cause a debugmsg and give you the null version of that object.
+
+## Safe References
+
+Game objects support safe references. `safe_reference<item>` will refuse access to an object that
+has been destroyed or is outside of the reality bubble without losing track of it, and they can be
+saved and loaded. You must check them as a boolean (e.g. `if( ref )`) to see if they're valid.
+Trying to access them when they're not will cause debugmsgs and give you a null object instead. They
+have a small interface that lets you check if they're destroyed or unloaded etc. If they were
+destroyed or unloaded this turn, they have a method that will allow you to access the object in a
+const fashion, for instance to display an error message.
+
+If you're moving objects around you need to use `detached_ptr`s, but otherwise when choosing which
+reference to use the most important thing to consider is how long you want to hold onto it. If
+you're just using something temporarily, for instance most arguments and variables, you should use a
+normal reference or pointer. If you need to store it for longer you should use a safe reference and
+this means it can be easily stored in the save file. In the rare case that you do want to save it
+across turns but don't want to store it in the save file, which means caches, there's also a fast
+`cache_reference<item>`, which does last across turns but can't be saved.
+
+Game objects can sometimes be split into pieces or merged together. Item stacks are the main example
+of this but there are others like vehicles being split or dissoluted devourers merging. When a stack
+of items is split, the stack that stays in place is the one that safe references will follow. When
+they are merged safe references to either half of the merge will now point to the merge result.

doc/src/content/docs/en/dev/guides/items.md

@@ -0,0 +1,18 @@
+---
+title: Items Cookbook
+---
+
+Here are some common tasks that you might want to do with items.
+[For more on item(game objects), check here.](../explanation/game_objects.md)
+
+## Moving items from one tripoint to another
+
+```cpp
+auto move_item( map &here, const tripoint &src, const tripoint &dest ) -> void
+{
+    map_stack items_src = here.i_at( src );
+    map_stack items_dest = here.i_at( dest );
+
+    items_src.move_all_to( &items_dest );
+}
+```

msvc-full-features/stdafx.h

@@ -74,7 +74,6 @@
 #include <vector>
 
 #include "../src/platform_win.h"
-#include "../src/colony.h"
 
 #if defined(TILES)
 #   if defined(_MSC_VER) && defined(USE_VCPKG)

pch/main-pch.hpp

@@ -55,4 +55,3 @@
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include "../src/colony.h"

src/achievement.cpp

@@ -228,7 +228,7 @@ void achievement::add_kill_requirements( const JsonObject &jo, const std::string
     }
 }
 
-void achievement::add_kill_requirement( const JsonObject inner, const std::string & )
+void achievement::add_kill_requirement( const JsonObject &inner, const std::string & )
 {
     if( inner.has_string( "monster" ) && inner.has_string( "species" ) ) {
         inner.throw_error( "Cannot have both id and species identifiers" );
@@ -268,7 +268,7 @@ void achievement::add_skill_requirements( const JsonObject &jo, const std::strin
     }
 }
 
-void achievement::add_skill_requirement( const JsonObject inner, const std::string & )
+void achievement::add_skill_requirement( const JsonObject &inner, const std::string & )
 {
     const skill_id skill = static_cast<skill_id>( inner.get_string( "skill" ) );
     const achievement_comparison compare = inner.get_enum_value<achievement_comparison>( "is" );

src/achievement.h

@@ -136,11 +136,11 @@ class achievement
         /** Retrieves kill requirement JsonObjects and feeds it to add_skill_requirement*/
         void add_kill_requirements( const JsonObject &jo, const std::string &src );
         /** Organizes variables provided and adds kill_requirements to achievements*/
-        void add_kill_requirement( const JsonObject inner, const std::string &src );
+        void add_kill_requirement( const JsonObject &inner, const std::string &src );
         /** Retrieves skill requirement JsonObjects and feeds it to add_skill_requirement*/
         void add_skill_requirements( const JsonObject &jo, const std::string &src );
         /** Organizes variables provided and adds skill_requirements to achievements*/
-        void add_skill_requirement( const JsonObject inner, const std::string &src );
+        void add_skill_requirement( const JsonObject &inner, const std::string &src );
 };
 
 template<>

src/action.cpp

@@ -562,12 +562,12 @@ bool can_butcher_at( const tripoint &p )
     bool has_corpse = false;
 
     const inventory &crafting_inv = you.crafting_inventory();
-    for( item &items_it : items ) {
-        if( items_it.is_corpse() ) {
+    for( item *&items_it : items ) {
+        if( items_it->is_corpse() ) {
             if( factor != INT_MIN  || factorD != INT_MIN ) {
                 has_corpse = true;
             }
-        } else if( crafting::can_disassemble( you, items_it, crafting_inv ).success() ) {
+        } else if( crafting::can_disassemble( you, *items_it, crafting_inv ).success() ) {
             has_item = true;
         }
     }