house.h

main 316 lines · 6.8 KB Raw
Alex Alex Commit Server upload 18/10/2026 23:38
1/**
2 * The Forgotten Server - a free and open-source MMORPG server emulator
3 * Copyright (C) 2019 Mark Samman <mark.samman@gmail.com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20#ifndef FS_HOUSE_H_EB9732E7771A438F9CD0EFA8CB4C58C4
21#define FS_HOUSE_H_EB9732E7771A438F9CD0EFA8CB4C58C4
22
23#include <set>
24#include <unordered_set>
25
26#include "container.h"
27#include "housetile.h"
28#include "position.h"
29
30class House;
31class BedItem;
32class Player;
33
34class AccessList
35{
36 public:
37 void parseList(const std::string& list);
38 void addPlayer(const std::string& name);
39 void addGuild(const std::string& name);
40 void addGuildRank(const std::string& name, const std::string& rankName);
41
42 bool isInList(const Player* player);
43
44 void getList(std::string& list) const;
45
46 private:
47 std::string list;
48 std::unordered_set<uint32_t> playerList;
49 std::unordered_set<uint32_t> guildRankList;
50 bool allowEveryone = false;
51};
52
53class Door final : public Item
54{
55 public:
56 explicit Door(uint16_t type);
57
58 // non-copyable
59 Door(const Door&) = delete;
60 Door& operator=(const Door&) = delete;
61
62 Door* getDoor() override {
63 return this;
64 }
65 const Door* getDoor() const override {
66 return this;
67 }
68
69 House* getHouse() {
70 return house;
71 }
72
73 //serialization
74 Attr_ReadValue readAttr(AttrTypes_t attr, PropStream& propStream) override;
75 void serializeAttr(PropWriteStream&) const override {}
76
77 void setDoorId(uint32_t doorId) {
78 setIntAttr(ITEM_ATTRIBUTE_DOORID, doorId);
79 }
80 uint32_t getDoorId() const {
81 return getIntAttr(ITEM_ATTRIBUTE_DOORID);
82 }
83
84 bool canUse(const Player* player);
85
86 void setAccessList(const std::string& textlist);
87 bool getAccessList(std::string& list) const;
88
89 void onRemoved() override;
90
91 private:
92 void setHouse(House* house);
93
94 House* house = nullptr;
95 std::unique_ptr<AccessList> accessList;
96 friend class House;
97};
98
99enum AccessList_t {
100 GUEST_LIST = 0x100,
101 SUBOWNER_LIST = 0x101,
102};
103
104enum AccessHouseLevel_t {
105 HOUSE_NOT_INVITED = 0,
106 HOUSE_GUEST = 1,
107 HOUSE_SUBOWNER = 2,
108 HOUSE_OWNER = 3,
109};
110
111using HouseTileList = std::list<HouseTile*>;
112using HouseBedItemList = std::list<BedItem*>;
113
114class HouseTransferItem final : public Item
115{
116 public:
117 static HouseTransferItem* createHouseTransferItem(House* house);
118
119 explicit HouseTransferItem(House* house) : Item(0), house(house) {}
120
121 void onTradeEvent(TradeEvents_t event, Player* owner) override;
122 bool canTransform() const override {
123 return false;
124 }
125
126 private:
127 House* house;
128};
129
130class House
131{
132 public:
133 explicit House(uint32_t houseId);
134
135 void addTile(HouseTile* tile);
136 void updateDoorDescription() const;
137
138 bool canEditAccessList(uint32_t listId, const Player* player);
139 // listId special values:
140 // GUEST_LIST guest list
141 // SUBOWNER_LIST subowner list
142 void setAccessList(uint32_t listId, const std::string& textlist);
143 bool getAccessList(uint32_t listId, std::string& list) const;
144
145 bool isInvited(const Player* player);
146
147 AccessHouseLevel_t getHouseAccessLevel(const Player* player);
148 bool kickPlayer(Player* player, Player* target);
149
150 void setEntryPos(Position pos) {
151 posEntry = pos;
152 }
153 const Position& getEntryPosition() const {
154 return posEntry;
155 }
156
157 void setName(std::string houseName) {
158 this->houseName = houseName;
159 }
160 const std::string& getName() const {
161 return houseName;
162 }
163
164 void setOwner(uint32_t guid, bool updateDatabase = true, Player* player = nullptr);
165 uint32_t getOwner() const {
166 return owner;
167 }
168
169 void setPaidUntil(time_t paid) {
170 paidUntil = paid;
171 }
172 time_t getPaidUntil() const {
173 return paidUntil;
174 }
175
176 void setRent(uint32_t rent) {
177 this->rent = rent;
178 }
179 uint32_t getRent() const {
180 return rent;
181 }
182
183 void setPayRentWarnings(uint32_t warnings) {
184 rentWarnings = warnings;
185 }
186 uint32_t getPayRentWarnings() const {
187 return rentWarnings;
188 }
189
190 void setTownId(uint32_t townId) {
191 this->townId = townId;
192 }
193 uint32_t getTownId() const {
194 return townId;
195 }
196
197 uint32_t getId() const {
198 return id;
199 }
200
201 void addDoor(Door* door);
202 void removeDoor(Door* door);
203 Door* getDoorByNumber(uint32_t doorId) const;
204 Door* getDoorByPosition(const Position& pos);
205
206 HouseTransferItem* getTransferItem();
207 void resetTransferItem();
208 bool executeTransfer(HouseTransferItem* item, Player* newOwner);
209
210 const HouseTileList& getTiles() const {
211 return houseTiles;
212 }
213
214 const std::set<Door*>& getDoors() const {
215 return doorSet;
216 }
217
218 void addBed(BedItem* bed);
219 const HouseBedItemList& getBeds() const {
220 return bedsList;
221 }
222 uint32_t getBedCount() {
223 return static_cast<uint32_t>(std::ceil(bedsList.size() / 2.)); //each bed takes 2 sqms of space, ceil is just for bad maps
224 }
225
226 private:
227 bool transferToDepot() const;
228 bool transferToDepot(Player* player) const;
229
230 AccessList guestList;
231 AccessList subOwnerList;
232
233 Container transfer_container{ITEM_LOCKER1};
234
235 HouseTileList houseTiles;
236 std::set<Door*> doorSet;
237 HouseBedItemList bedsList;
238
239 std::string houseName;
240 std::string ownerName;
241
242 HouseTransferItem* transferItem = nullptr;
243
244 time_t paidUntil = 0;
245
246 uint32_t id;
247 uint32_t owner = 0;
248 uint32_t ownerAccountId = 0;
249 uint32_t rentWarnings = 0;
250 uint32_t rent = 0;
251 uint32_t townId = 0;
252
253 Position posEntry = {};
254
255 bool isLoaded = false;
256};
257
258using HouseMap = std::map<uint32_t, House*>;
259
260enum RentPeriod_t {
261 RENTPERIOD_DAILY,
262 RENTPERIOD_WEEKLY,
263 RENTPERIOD_MONTHLY,
264 RENTPERIOD_YEARLY,
265 RENTPERIOD_NEVER,
266};
267
268class Houses
269{
270 public:
271 Houses() = default;
272 ~Houses() {
273 for (const auto& it : houseMap) {
274 delete it.second;
275 }
276 }
277
278 // non-copyable
279 Houses(const Houses&) = delete;
280 Houses& operator=(const Houses&) = delete;
281
282 House* addHouse(uint32_t id) {
283 auto it = houseMap.find(id);
284 if (it != houseMap.end()) {
285 return it->second;
286 }
287
288 House* house = new House(id);
289 houseMap[id] = house;
290 return house;
291 }
292
293 House* getHouse(uint32_t houseId) {
294 auto it = houseMap.find(houseId);
295 if (it == houseMap.end()) {
296 return nullptr;
297 }
298 return it->second;
299 }
300
301 House* getHouseByPlayerId(uint32_t playerId);
302
303 bool loadHousesXML(const std::string& filename);
304
305 void payHouses(RentPeriod_t rentPeriod) const;
306
307 const HouseMap& getHouses() const {
308 return houseMap;
309 }
310
311 private:
312 HouseMap houseMap;
313};
314
315#endif
316
Top