1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
#include "RLE_reader.hpp"
#include "engine/data/bounds.hpp"
#include "engine/data/vector2.hpp"
#include "errors/RLE_reader.hpp"
#include "util/algorithm.hpp"
#include "util/io.hpp"
#include "util/string.hpp"
#include <ctre.hpp>
#include <cctype>
#include <fstream>
#include <string>
#include <vector>
#include <iostream>
RLEReader::RLEReader(const IMatrixFactory<MatrixElement> &matrix_factory) noexcept
: _matrix_factory(matrix_factory)
{
}
auto RLEReader::read_RLE_file(const std::filesystem::path &path) const
-> std::unique_ptr<IMatrix<MatrixElement>>
{
auto content_lines = read_file_lines<std::vector<std::string>>(path);
if (content_lines.empty())
{
throw InvalidRLEFileError(path, "File is empty");
}
if (content_lines.back().empty())
{
content_lines.pop_back();
}
const auto header_line_iter = container_find(
content_lines,
[](const std::string &line)
{
return ctre::starts_with<"x = \\d+, y = \\d+">(line);
// return ctre::match<"x = \\d+, y = \\d+(, rule = [a-zA-Z0-9/]+)?">(line);
});
if (header_line_iter == content_lines.end())
{
throw InvalidRLEFileError(path, "No header line");
}
const auto &header_line = *header_line_iter;
const auto header_parts = split_string<std::vector<std::string>>(header_line, ',');
const auto &header_x_part = header_parts[0];
const auto &header_y_part = header_parts[1].substr(1);
const auto pattern_width =
static_cast<Bounds::Value>(std::stoul(header_x_part.substr(4)));
const auto pattern_height =
static_cast<Bounds::Value>(std::stoul(header_y_part.substr(4)));
const auto pattern_size = Bounds({.width = pattern_width, .height = pattern_height});
auto pattern_matrix = _matrix_factory(pattern_size);
auto pattern_pos = Vector2({.x = 0, .y = 0});
const auto first_pattern_line_iter = header_line_iter + 1;
for (auto pattern_line_iter = first_pattern_line_iter;
pattern_line_iter != content_lines.end();
++pattern_line_iter)
{
if (!ctre::match<"[bo$0-9!]+">(*pattern_line_iter))
{
throw InvalidRLEFileError(path, "Invalid pattern line");
}
}
auto pattern = std::string();
for (auto pattern_line_iter = first_pattern_line_iter;
pattern_line_iter != content_lines.end();
++pattern_line_iter)
{
pattern.append(*pattern_line_iter);
}
auto run_count_str = std::string();
for (const auto &character : pattern)
{
if (static_cast<bool>(isdigit(character)))
{
run_count_str += character;
continue;
}
if (character == '!')
{
break;
}
const auto run_count = run_count_str.empty() ? 1 : std::stoi(run_count_str);
run_count_str.clear();
if (character == '$')
{
pattern_pos.set_x(0);
pattern_pos += Vector2({.x = 0, .y = run_count});
continue;
}
for (auto run_index = 0; run_index < run_count; run_index++)
{
if (pattern_size.validate_coords(pattern_pos) != CoordsValidation::VALID)
{
throw InvalidRLEFileError(path, "Pattern goes out of bounds");
}
pattern_matrix->set(pattern_pos, character == 'o' ? 'x' : ' ');
pattern_pos += Vector2::right();
}
}
return pattern_matrix;
}
|
