20194965430

Committed 13 Dec 2025 04:48PM UTC coverage: 50.052%. First build

Build # 20194965430

Build Type

Pull #1720

github

Committed by

web-flow

Commit Message

Merge f32c9b7c0 into a8dc3da9a

Pull Request Pull Request #1720: Add leather addon

Run Details

312 of 1143 new or added lines in 68 files covered. (27.3%)

22779 of 45511 relevant lines covered (50.05%)

35641.36 hits per line

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

90.65

/libs/s25main/BuildingRegister.cpp

// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
//
// SPDX-License-Identifier: GPL-2.0-or-later

#include "BuildingRegister.h"
#include "LeatherLoader.h"
#include "SerializedGameData.h"
#include "WineLoader.h"
#include "buildings/noBuildingSite.h"
#include "buildings/nobBaseWarehouse.h"
#include "buildings/nobHarborBuilding.h"
#include "buildings/nobMilitary.h"
#include "buildings/nobUsual.h"
#include "enum_cast.hpp"
#include "helpers/EnumRange.h"
#include "helpers/containerUtils.h"
#include "gameData/BuildingConsts.h"
#include "gameData/BuildingProperties.h"

void BuildingRegister::Serialize(SerializedGameData& sgd) const
{
    sgd.PushObjectContainer(warehouses);
    sgd.PushObjectContainer(harbors, true);
    for(const auto bld : helpers::enumRange<BuildingType>())
    {
        if(BuildingProperties::IsUsual(bld))
            sgd.PushObjectContainer(buildings[bld], true);
    }
    sgd.PushObjectContainer(building_sites, true);
    sgd.PushObjectContainer(military_buildings, true);
}

void BuildingRegister::Deserialize(SerializedGameData& sgd)
{
    sgd.PopObjectContainer(warehouses);
    sgd.PopObjectContainer(harbors, GO_Type::NobHarborbuilding);

    if(sgd.GetGameDataVersion() >= 6)
    {
        for(const auto bld : helpers::enumRange<BuildingType>())
        {
            if(sgd.GetGameDataVersion() < 11 && wineaddon::isWineAddonBuildingType(bld))
                continue;

            if(sgd.GetGameDataVersion() < 12 && leatheraddon::isLeatherAddonBuildingType(bld))
                continue;

            if(BuildingProperties::IsUsual(bld))
                sgd.PopObjectContainer(buildings[bld], GO_Type::NobUsual);
        }
        sgd.PopObjectContainer(building_sites, GO_Type::Buildingsite);
        sgd.PopObjectContainer(military_buildings, GO_Type::NobMilitary);
    } else if(sgd.GetGameDataVersion() >= 2)
        Deserialize2(sgd);
}

void BuildingRegister::Deserialize2(SerializedGameData& sgd)
{
    // Pop all buildings starting at the first usual building
    for(unsigned i = static_cast<uint8_t>(BuildingType::GraniteMine); i < helpers::NumEnumValues_v<BuildingType>; ++i)
        sgd.PopObjectContainer(buildings[BuildingType(i)], GO_Type::NobUsual);
    sgd.PopObjectContainer(building_sites, GO_Type::Buildingsite);
    sgd.PopObjectContainer(military_buildings, GO_Type::NobMilitary);
}

void BuildingRegister::Add(noBuildingSite* building_site)
{
    RTTR_Assert(!helpers::contains(building_sites, building_site));
    building_sites.push_back(building_site);
}

void BuildingRegister::Remove(noBuildingSite* building_site)
{
    RTTR_Assert(helpers::contains(building_sites, building_site));
    building_sites.remove(building_site);
}

void BuildingRegister::Add(noBuilding* bld, BuildingType bldType)
{
    if(BuildingProperties::IsMilitary(bldType))
    {
        RTTR_Assert(!helpers::contains(military_buildings, bld));
        military_buildings.push_back(static_cast<nobMilitary*>(bld));
    } else if(BuildingProperties::IsWareHouse(bldType))
    {
        RTTR_Assert(!helpers::contains(warehouses, bld));
        warehouses.push_back(static_cast<nobBaseWarehouse*>(bld));
    } else
    {
        RTTR_Assert(!helpers::contains(buildings[bldType], bld));
        buildings[bldType].push_back(static_cast<nobUsual*>(bld));
    }
    if(bldType == BuildingType::HarborBuilding)
    {
        RTTR_Assert(!helpers::contains(harbors, bld));
        harbors.push_back(static_cast<nobHarborBuilding*>(bld));
    }
}

void BuildingRegister::Remove(noBuilding* bld, BuildingType bldType)
{
    if(BuildingProperties::IsMilitary(bldType))
    {
        RTTR_Assert(helpers::contains(military_buildings, bld));
        military_buildings.remove(static_cast<nobMilitary*>(bld));
    } else if(BuildingProperties::IsWareHouse(bldType))
    {
        RTTR_Assert(helpers::contains(warehouses, bld));
        warehouses.remove(static_cast<nobBaseWarehouse*>(bld));
    } else
    {
        RTTR_Assert(helpers::contains(buildings[bldType], bld));
        buildings[bldType].remove(static_cast<nobUsual*>(bld));
    }
    if(bldType == BuildingType::HarborBuilding)
    {
        RTTR_Assert(helpers::contains(harbors, bld));
        harbors.remove(static_cast<nobHarborBuilding*>(bld));
    }
}

/// Gibt Liste von Gebäuden des Spieler zurück
const std::list<nobUsual*>& BuildingRegister::GetBuildings(const BuildingType type) const
{
    RTTR_Assert(BuildingProperties::IsUsual(type));
    return buildings[type];
}

/// Liefert die Anzahl aller Gebäude einzeln
BuildingCount BuildingRegister::GetBuildingNums() const
{
    BuildingCount bc{};

    // Normale Gebäude zählen
    for(const auto bld : helpers::enumRange<BuildingType>())
        bc.buildings[bld] = buildings[bld].size();
    // Lagerhäuser zählen
    for(const nobBaseWarehouse* bld : warehouses)
        ++bc.buildings[bld->GetBuildingType()];
    // Militärgebäude zählen
    for(const nobMilitary* bld : military_buildings)
        ++bc.buildings[bld->GetBuildingType()];
    // Baustellen zählen
    for(const noBuildingSite* bld : building_sites)
        ++bc.buildingSites[bld->GetBuildingType()];
    return bc;
}

helpers::EnumArray<uint16_t, BuildingType> BuildingRegister::CalcProductivities() const
{
    helpers::EnumArray<uint16_t, BuildingType> productivities;

    for(const auto bld : helpers::enumRange<BuildingType>())
        productivities[bld] = static_cast<uint16_t>(CalcAverageProductivity(bld));
    return productivities;
}

unsigned BuildingRegister::CalcAverageProductivity(BuildingType bldType) const
{
    if(!BLD_WORK_DESC[bldType].producedWare)
        return 0;
    unsigned productivity = 0;
    const auto& buildings = GetBuildings(bldType);
    const unsigned numBlds = buildings.size();
    if(numBlds > 0)
    {
        for(const nobUsual* bld : buildings)
            productivity += bld->GetProductivity();
        productivity /= numBlds;
    }
    return productivity;
}

unsigned short BuildingRegister::CalcAverageProductivity() const
{
    unsigned totalProductivity = 0;
    unsigned numBlds = 0;
    for(const auto bldType : helpers::enumRange<BuildingType>())
    {
        if(!BLD_WORK_DESC[bldType].producedWare)
            continue;

        const auto& buildings = GetBuildings(bldType);
        numBlds += buildings.size();
        for(const nobUsual* bld : buildings)
            totalProductivity += bld->GetProductivity();
    }
    if(numBlds == 0)
        return 0;
    return totalProductivity / numBlds;
}

1	// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
2	//
3	// SPDX-License-Identifier: GPL-2.0-or-later
4
5	#include "BuildingRegister.h"
6	#include "LeatherLoader.h"
7	#include "SerializedGameData.h"
8	#include "WineLoader.h"
9	#include "buildings/noBuildingSite.h"
10	#include "buildings/nobBaseWarehouse.h"
11	#include "buildings/nobHarborBuilding.h"
12	#include "buildings/nobMilitary.h"
13	#include "buildings/nobUsual.h"
14	#include "enum_cast.hpp"
15	#include "helpers/EnumRange.h"
16	#include "helpers/containerUtils.h"
17	#include "gameData/BuildingConsts.h"
18	#include "gameData/BuildingProperties.h"
19
20	void BuildingRegister::Serialize(SerializedGameData& sgd) const	14✔
21	{
22	sgd.PushObjectContainer(warehouses);	14✔
23	sgd.PushObjectContainer(harbors, true);	14✔
24	for(const auto bld : helpers::enumRange<BuildingType>())	1,176✔
25	{
26	if(BuildingProperties::IsUsual(bld))	560✔
27	sgd.PushObjectContainer(buildings[bld], true);	448✔
28	}
29	sgd.PushObjectContainer(building_sites, true);	14✔
30	sgd.PushObjectContainer(military_buildings, true);	14✔
31	}	14✔
32
33	void BuildingRegister::Deserialize(SerializedGameData& sgd)	7✔
34	{
35	sgd.PopObjectContainer(warehouses);	7✔
36	sgd.PopObjectContainer(harbors, GO_Type::NobHarborbuilding);	7✔
37
38	if(sgd.GetGameDataVersion() >= 6)	7✔
39	{
40	for(const auto bld : helpers::enumRange<BuildingType>())	588✔
41	{
42	if(sgd.GetGameDataVersion() < 11 && wineaddon::isWineAddonBuildingType(bld))	280✔
43	continue;	×
44
45	if(sgd.GetGameDataVersion() < 12 && leatheraddon::isLeatherAddonBuildingType(bld))	280✔
NEW 46	continue;	×
47
48	if(BuildingProperties::IsUsual(bld))	280✔
49	sgd.PopObjectContainer(buildings[bld], GO_Type::NobUsual);	224✔
50	}
51	sgd.PopObjectContainer(building_sites, GO_Type::Buildingsite);	7✔
52	sgd.PopObjectContainer(military_buildings, GO_Type::NobMilitary);	7✔
53	} else if(sgd.GetGameDataVersion() >= 2)	×
54	Deserialize2(sgd);	×
55	}	7✔
56
57	void BuildingRegister::Deserialize2(SerializedGameData& sgd)	×
58	{
59	// Pop all buildings starting at the first usual building
60	for(unsigned i = static_cast<uint8_t>(BuildingType::GraniteMine); i < helpers::NumEnumValues_v<BuildingType>; ++i)	×
61	sgd.PopObjectContainer(buildings[BuildingType(i)], GO_Type::NobUsual);	×
62	sgd.PopObjectContainer(building_sites, GO_Type::Buildingsite);	×
63	sgd.PopObjectContainer(military_buildings, GO_Type::NobMilitary);	×
64	}	×
65
66	void BuildingRegister::Add(noBuildingSite* building_site)	28✔
67	{
68	RTTR_Assert(!helpers::contains(building_sites, building_site));	28✔
69	building_sites.push_back(building_site);	28✔
70	}	28✔
71
72	void BuildingRegister::Remove(noBuildingSite* building_site)	15✔
73	{
74	RTTR_Assert(helpers::contains(building_sites, building_site));	15✔
75	building_sites.remove(building_site);	15✔
76	}	15✔
77
78	void BuildingRegister::Add(noBuilding* bld, BuildingType bldType)	547✔
79	{
80	if(BuildingProperties::IsMilitary(bldType))	547✔
81	{
82	RTTR_Assert(!helpers::contains(military_buildings, bld));	114✔
83	military_buildings.push_back(static_cast<nobMilitary*>(bld));	114✔
84	} else if(BuildingProperties::IsWareHouse(bldType))	433✔
85	{
86	RTTR_Assert(!helpers::contains(warehouses, bld));	322✔
87	warehouses.push_back(static_cast<nobBaseWarehouse*>(bld));	322✔
88	} else
89	{
90	RTTR_Assert(!helpers::contains(buildings[bldType], bld));	111✔
91	buildings[bldType].push_back(static_cast<nobUsual*>(bld));	111✔
92	}
93	if(bldType == BuildingType::HarborBuilding)	547✔
94	{
95	RTTR_Assert(!helpers::contains(harbors, bld));	38✔
96	harbors.push_back(static_cast<nobHarborBuilding*>(bld));	38✔
97	}
98	}	547✔
99
100	void BuildingRegister::Remove(noBuilding* bld, BuildingType bldType)	106✔
101	{
102	if(BuildingProperties::IsMilitary(bldType))	106✔
103	{
104	RTTR_Assert(helpers::contains(military_buildings, bld));	33✔
105	military_buildings.remove(static_cast<nobMilitary*>(bld));	33✔
106	} else if(BuildingProperties::IsWareHouse(bldType))	73✔
107	{
108	RTTR_Assert(helpers::contains(warehouses, bld));	40✔
109	warehouses.remove(static_cast<nobBaseWarehouse*>(bld));	40✔
110	} else
111	{
112	RTTR_Assert(helpers::contains(buildings[bldType], bld));	33✔
113	buildings[bldType].remove(static_cast<nobUsual*>(bld));	33✔
114	}
115	if(bldType == BuildingType::HarborBuilding)	106✔
116	{
117	RTTR_Assert(helpers::contains(harbors, bld));	15✔
118	harbors.remove(static_cast<nobHarborBuilding*>(bld));	15✔
119	}
120	}	106✔
121
122	/// Gibt Liste von Gebäuden des Spieler zurück
123	const std::list<nobUsual*>& BuildingRegister::GetBuildings(const BuildingType type) const	16,472✔
124	{
125	RTTR_Assert(BuildingProperties::IsUsual(type));	16,472✔
126	return buildings[type];	16,472✔
127	}
128
129	/// Liefert die Anzahl aller Gebäude einzeln
130	BuildingCount BuildingRegister::GetBuildingNums() const	5,101✔
131	{
132	BuildingCount bc{};	5,101✔
133
134	// Normale Gebäude zählen
135	for(const auto bld : helpers::enumRange<BuildingType>())	428,484✔
136	bc.buildings[bld] = buildings[bld].size();	204,040✔
137	// Lagerhäuser zählen
138	for(const nobBaseWarehouse* bld : warehouses)	10,202✔
139	++bc.buildings[bld->GetBuildingType()];	5,101✔
140	// Militärgebäude zählen
141	for(const nobMilitary* bld : military_buildings)	5,269✔
142	++bc.buildings[bld->GetBuildingType()];	168✔
143	// Baustellen zählen
144	for(const noBuildingSite* bld : building_sites)	14,061✔
145	++bc.buildingSites[bld->GetBuildingType()];	8,960✔
146	return bc;	5,101✔
147	}
148
149	helpers::EnumArray<uint16_t, BuildingType> BuildingRegister::CalcProductivities() const	3✔
150	{
151	helpers::EnumArray<uint16_t, BuildingType> productivities;
152
153	for(const auto bld : helpers::enumRange<BuildingType>())	252✔
154	productivities[bld] = static_cast<uint16_t>(CalcAverageProductivity(bld));	120✔
155	return productivities;	3✔
156	}
157
158	unsigned BuildingRegister::CalcAverageProductivity(BuildingType bldType) const	231✔
159	{
160	if(!BLD_WORK_DESC[bldType].producedWare)	231✔
161	return 0;	34✔
162	unsigned productivity = 0;	197✔
163	const auto& buildings = GetBuildings(bldType);	197✔
164	const unsigned numBlds = buildings.size();	197✔
165	if(numBlds > 0)	197✔
166	{
167	for(const nobUsual* bld : buildings)	216✔
168	productivity += bld->GetProductivity();	123✔
169	productivity /= numBlds;	93✔
170	}
171	return productivity;	197✔
172	}
173
174	unsigned short BuildingRegister::CalcAverageProductivity() const	9✔
175	{
176	unsigned totalProductivity = 0;	9✔
177	unsigned numBlds = 0;	9✔
178	for(const auto bldType : helpers::enumRange<BuildingType>())	756✔
179	{
180	if(!BLD_WORK_DESC[bldType].producedWare)	360✔
181	continue;	90✔
182
183	const auto& buildings = GetBuildings(bldType);	270✔
184	numBlds += buildings.size();	270✔
185	for(const nobUsual* bld : buildings)	360✔
186	totalProductivity += bld->GetProductivity();	90✔
187	}
188	if(numBlds == 0)	9✔
189	return 0;	7✔
190	return totalProductivity / numBlds;	2✔
191	}

Return-To-The-Roots / s25client / 20194965430

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