mines/Inventory.cpp at master · numpad/mines · GitHub

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
#include "Inventory.hpp"

/* InventoryStack: */

InventoryStack::InventoryStack(size_t count, blockid type, size_t maxSize) {
	InventoryStack::count = count;
	InventoryStack::size = maxSize;
	InventoryStack::type = type;
}

InventoryStack::InventoryStack() : InventoryStack(0, BLOCK_AIR, 0) {
}

bool InventoryStack::operator==(const  InventoryStack &rhs) {
	return (InventoryStack::type == rhs.type && InventoryStack::count > 0 && rhs.count > 0);
}


bool InventoryStack::isFree() {
	return (type == BLOCK_AIR || count == 0);
}

size_t InventoryStack::spaceLeft() {
	return size - count;
}

size_t InventoryStack::add(size_t elements) {
	if (InventoryStack::spaceLeft() < elements) {
		size_t spaceLeft = InventoryStack::spaceLeft();
		InventoryStack::count = InventoryStack::size;
		return elements - spaceLeft;
	}
	InventoryStack::count += elements;
	return 0;
}

blockid InventoryStack::get() {
	if (InventoryStack::count > 0) {
		return InventoryStack::type;
	}
	InventoryStack::size = 0;
	InventoryStack::type = BLOCK_AIR;
	return BLOCK_AIR;
}

blockid InventoryStack::take() {
	if (InventoryStack::count > 0) {
		InventoryStack::count--;
		return InventoryStack::type;
	}

	InventoryStack::size = 0;
	InventoryStack::type = BLOCK_AIR;
	return BLOCK_AIR;
}

void InventoryStack::render(sf::RenderTarget &target, BitmapFont &bmf, Vec2 pos) {
	Block asBlock(get());
	if (asBlock.id < 0)
		return;

	asBlock.render(target, pos);

	/* Blocks left */
	wchar_t itemCountStr[5];
	swprintf(itemCountStr, 4, L"%lu", InventoryStack::count);

	bmf.write(target, pos + Vec2(1, 1), itemCountStr, sf::Color(80, 80, 80));
	bmf.write(target, pos, itemCountStr);
}

/* Inventory: */

Inventory::Inventory(size_t elements) {
	Inventory::content = std::vector<InventoryStack>();

	for (size_t i = 0; i < elements; ++i) {
		content.push_back(InventoryStack());
	}

}

size_t Inventory::getSize() {
	return content.size();
}

bool Inventory::hasSpace() {
	for (size_t i = 0; i < Inventory::getSize(); ++i) {
		if (Inventory::at(i).isFree()) {
			return true;
		}
	}
	return false;
}

bool Inventory::hasSpaceFor(blockid type) {
	for (size_t i = 0; i < Inventory::getSize(); ++i) {
		if (Inventory::at(i).isFree() || (Inventory::at(i).type == type && Inventory::at(i).count < Inventory::at(i).size)) {
			return true;
		}
	}
	return false;
}

InventoryStack &Inventory::at(size_t idx) {
	return content.at(idx);
}

bool Inventory::add(InventoryStack elems) {
	/* Check if Inventory contains stack of same type */
	for (size_t i = 0; i < Inventory::getSize(); ++i) {
		if (Inventory::at(i).type == elems.type) {
			/* Add elements if stack type is */
			elems.count = Inventory::at(i).add(elems.count);

			if (elems.count == 0)
				return true;
		}
	}

	for (size_t i = 0; i < Inventory::getSize(); ++i) {
		if (Inventory::at(i).isFree()) {
			Inventory::at(i) = elems;
			return true;
		}
	}
	return false;
}