• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

Return-To-The-Roots / s25client / 44076625557

17 Nov 2026 11:43AM UTC coverage: 51.803% (-0.002%) from 51.805%
44076625557

push

github

web-flow
Merge pull request #2018 from Return-To-The-Roots/refactor/lowerCamelCase-methods

Rename Msg_* handlers to lowerCamelCase

8121 of 16693 new or added lines in 565 files covered. (48.65%)

323 existing lines in 133 files now uncovered.

24236 of 46785 relevant lines covered (51.8%)

49647.74 hits per line

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

80.34
/libs/s25main/SavedFile.cpp
1
// Copyright (C) 2005 - 2026 Settlers Freaks (sf-team at siedler25.org)
2
//
3
// SPDX-License-Identifier: GPL-2.0-or-later
4

5
#include "SavedFile.h"
6
#include "BasePlayerInfo.h"
7
#include "RTTR_Version.h"
8
#include "enum_cast.hpp"
9
#include "helpers/format.hpp"
10
#include "gameData/MaxPlayers.h"
11
#include "libendian/ConvertEndianess.h"
12
#include "s25util/BinaryFile.h"
13
#include "s25util/Serializer.h"
14
#include <boost/format.hpp>
15
#include <algorithm>
16
#include <mygettext/mygettext.h>
17
#include <stdexcept>
18

19
SavedFile::SavedFile() : saveTime_(0)
21 ✔
20
{
21
    const std::string rev = rttr::version::getRevision();
21 ✔
22
    std::copy(rev.begin(), rev.begin() + revision.size(), revision.begin());
21 ✔
23
}
21 ✔
24

25
SavedFile::~SavedFile() = default;
21 ✔
26

27
uint8_t SavedFile::getMinorVersion() const
31 ✔
28
{
29
    return minorVersion_.value();
31 ✔
30
}
31

NEW
32
uint8_t SavedFile::getMajorVersion() const
×
33
{
34
    return majorVersion_.value();
×
35
}
36

37
void SavedFile::writeFileHeader(BinaryFile& file) const
9 ✔
38
{
39
    // Signature
40
    const std::string signature = getSignature();
18 ✔
41
    file.WriteRawData(signature.c_str(), signature.length());
9 ✔
42
    // Format version
43
    file.WriteUnsignedChar(getLatestMajorVersion());
9 ✔
44
    file.WriteUnsignedChar(getLatestMinorVersion());
9 ✔
45
}
9 ✔
46

47
void SavedFile::writeExtHeader(BinaryFile& file, const std::string& mapName)
8 ✔
48
{
49
    // Store data in struct
50
    saveTime_ = s25util::Time::CurrentTime();
8 ✔
51
    mapName_ = mapName;
8 ✔
52

53
    // Program version
54
    file.WriteRawData(revision.data(), revision.size());
8 ✔
55
    s25util::time64_t tmpTime = libendian::ConvertEndianess<false>::fromNative(saveTime_);
8 ✔
56
    file.WriteRawData(&tmpTime, sizeof(tmpTime));
8 ✔
57
    file.WriteShortString(mapName);
8 ✔
58
    file.WriteUnsignedInt(playerNames_.size());
8 ✔
59
    for(const std::string& name : playerNames_)
30 ✔
60
        file.WriteShortString(name);
22 ✔
61
}
8 ✔
62

63
bool SavedFile::readFileHeader(BinaryFile& file)
13 ✔
64
{
65
    lastErrorMsg.clear();
13 ✔
66

67
    const std::string signature = getSignature();
26 ✔
68
    std::array<char, 32> read_signature;
69
    if(signature.size() > read_signature.size())
13 ✔
70
        throw std::range_error("Program signature is to long!");
×
71
    try
72
    {
73
        file.ReadRawData(read_signature.data(), signature.size());
13 ✔
74

75
        // Signatur überprüfen
76
        if(!std::equal(signature.begin(), signature.end(), read_signature.begin()))
13 ✔
77
        {
78
            lastErrorMsg = _("File is not in a valid format!");
×
79
            return false;
×
80
        }
81

82
        // Version überprüfen
83
        majorVersion_ = file.ReadUnsignedChar();
13 ✔
84
        minorVersion_ = file.ReadUnsignedChar();
13 ✔
85
        if(majorVersion_ != getLatestMajorVersion() || minorVersion_ > getLatestMinorVersion())
13 ✔
86
        {
87
            boost::format fmt =
NEW
88
              boost::format((majorVersion_ < getLatestMajorVersion()) ?
×
89
                              _("File has an old version and cannot be used (version: %1%.%2%, expected: %3%.%4%)!") :
×
90
                              _("File was created with more recent program and cannot be used (version: %1%.%2%, "
×
91
                                "expected: %3%.%4%)!"));
×
92
            lastErrorMsg =
NEW
93
              (fmt % majorVersion_.value() % minorVersion_.value() % getLatestMajorVersion() % getLatestMinorVersion())
×
94
                .str();
×
95
            return false;
×
96
        }
97
    } catch(const std::runtime_error& e)
×
98
    {
99
        lastErrorMsg = e.what();
×
100
        return false;
×
101
    }
102

103
    return true;
13 ✔
104
}
105

106
bool SavedFile::readExtHeader(BinaryFile& file)
11 ✔
107
{
108
    file.ReadRawData(revision.data(), revision.size());
11 ✔
109
    file.ReadRawData(&saveTime_, sizeof(saveTime_));
11 ✔
110
    saveTime_ = libendian::ConvertEndianess<false>::toNative(saveTime_);
11 ✔
111
    mapName_ = file.ReadShortString();
11 ✔
112
    playerNames_.resize(file.ReadUnsignedInt());
11 ✔
113
    for(std::string& name : playerNames_)
42 ✔
114
        name = file.ReadShortString();
31 ✔
115
    return true;
11 ✔
116
}
117

118
void SavedFile::writeAllHeaderData(BinaryFile& file, const std::string& mapName)
8 ✔
119
{
120
    // Versionszeug schreiben
121
    writeFileHeader(file);
8 ✔
122
    writeExtHeader(file, mapName);
8 ✔
123
}
8 ✔
124

125
bool SavedFile::readAllHeaderData(BinaryFile& file)
11 ✔
126
{
127
    if(!readFileHeader(file))
11 ✔
128
        return false;
×
129
    if(!readExtHeader(file))
11 ✔
130
        return false;
×
131
    return true;
11 ✔
132
}
133

134
void SavedFile::writePlayerData(BinaryFile& file)
8 ✔
135
{
136
    Serializer ser;
16 ✔
137
    ser.PushUnsignedChar(players.size());
8 ✔
138
    for(const auto& player : players)
36 ✔
139
        player.serialize(ser, true);
28 ✔
140

141
    ser.WriteToFile(file);
8 ✔
142
}
8 ✔
143

144
void SavedFile::readPlayerData(BinaryFile& file)
8 ✔
145
{
146
    clearPlayers();
8 ✔
147
    Serializer ser;
16 ✔
148
    ser.ReadFromFile(file);
8 ✔
149
    const unsigned playerCt = ser.PopUnsignedChar();
8 ✔
150
    if(playerCt > MAX_PLAYERS)
8 ✔
151
    {
152
        throw std::length_error(
×
153
          helpers::format(_("Number of players (%1%) exceeds maximum allowed of %2%!"), playerCt, MAX_PLAYERS));
×
154
    }
155
    players.reserve(playerCt);
8 ✔
156
    for(unsigned i = 0; i < playerCt; i++)
36 ✔
157
    {
158
        // TODO(Replay) TODO(Savegame) minor versions will change their meaning when major is bumped
159
        BasePlayerInfo player(ser, getMinorVersion() >= 1 ? 1 : 0, true);
56 ✔
160
        // Temporary workaround: The random team was stored in the file but should not anymore, see PR #1331
161
        if(player.team > Team::Team4)
28 ✔
162
            player.team = Team(rttr::enum_cast(player.team) - 3); // Was random team 2-4
×
163
        else if(player.team == Team::Random)
28 ✔
164
            player.team = Team::Team1; // Was random team 1
×
165
        addPlayer(player);
28 ✔
166
    }
167
}
8 ✔
168

169
/**
170
 *  schreibt die GlobalGameSettings in die Datei.
171
 */
172
void SavedFile::writeGGS(BinaryFile& file) const
8 ✔
173
{
174
    Serializer ser;
16 ✔
175
    ggs.serialize(ser);
8 ✔
176
    ser.WriteToFile(file);
8 ✔
177
}
8 ✔
178

179
/**
180
 *  liest die GlobalGameSettings aus der Datei.
181
 */
182
void SavedFile::readGGS(BinaryFile& file)
8 ✔
183
{
184
    Serializer ser;
16 ✔
185
    ser.ReadFromFile(file);
8 ✔
186
    ggs.deserialize(ser);
8 ✔
187
}
8 ✔
188

189
const BasePlayerInfo& SavedFile::getPlayer(unsigned idx) const
28 ✔
190
{
191
    return players[idx];
28 ✔
192
}
193

194
unsigned SavedFile::getNumPlayers()
12 ✔
195
{
196
    return players.size();
12 ✔
197
}
198

199
void SavedFile::addPlayer(const BasePlayerInfo& player)
56 ✔
200
{
201
    players.push_back(player);
56 ✔
202
    if(player.isUsed())
56 ✔
203
        playerNames_.push_back(player.name);
44 ✔
204
}
56 ✔
205

206
void SavedFile::clearPlayers()
19 ✔
207
{
208
    players.clear();
19 ✔
209
    playerNames_.clear();
19 ✔
210
}
19 ✔
211

NEW
212
std::string SavedFile::getRevision() const
×
213
{
214
    return std::string(revision.begin(), revision.end());
×
215
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc