EC-SDK/EC.GameClass.cpp at main · Everything-Compatible/EC-SDK · 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
#include "EC.GameClass.h"
#include <unordered_set>

void Internal_DebugLog(const char* pFormat, ...);
void RaiseReadBlockError();
void RaiseExpectEndOfBlockError();
void RaiseWriteBlockError();

struct ECGameClassToken
{
	ECGameClass_* pClass;
	bool Match(const ECGameClass_* rhs)
	{
		return pClass == rhs;
	}
	struct Hasher
	{
		inline size_t operator()(const ECGameClassToken& rhs) const
		{
			return reinterpret_cast<size_t>(rhs.pClass);
		}
	};
	bool operator==(const ECGameClassToken& rhs)const
	{
		return pClass == rhs.pClass;
	}
};


std::unordered_set<ECGameClassToken, ECGameClassToken::Hasher> GameClassList;

void ECGameClass_::Register()
{
	GameClassList.insert(ECGameClassToken{ this });
}
void ECGameClass_::Unregister()
{
	GameClassList.erase(ECGameClassToken{ this });
}

ECGameClass_::ECGameClass_()
{
	Register();
}
ECGameClass_::ECGameClass_(const ECGameClass_&)
{
	Register();
}
ECGameClass_::ECGameClass_(ECGameClass_&&)
{
	Register();
}

ECGameClass_::~ECGameClass_()
{
	Unregister();
}


void ECGameClass_PointerGotInvalid(AbstractClass* const pObject, bool bRemoved)
{
	for (auto& Token : GameClassList)
		Token.pClass->PointerGotInvalid(pObject, bRemoved);
}
void ECGameClass_FinalSwizzle()
{
	for (auto& Token : GameClassList)
		Token.pClass->FinalSwizzle();
}
void ECGameClass_LoadGame(IStream* pStream)
{
	for (auto& Token : GameClassList)
	{
		ECStreamByte ByteStm(0);
		if (!ByteStm.ReadBlockFromStream(pStream))
		{
			RaiseReadBlockError();
			continue;
		}
		ECStreamReader Stm(ByteStm);

		if(Stm.RegisterChange(Token.pClass))
		{
			Token.pClass->LoadGame(Stm);
		}

		if (!Stm.ExpectEndOfBlock())
		{
			RaiseExpectEndOfBlockError();
		}
	}
}
void ECGameClass_SaveGame(IStream* pStream)
{
	for (auto& Token : GameClassList)
	{
		ECStreamByte ByteStm(Token.pClass->GetSizeMax());
		ECStreamWriter Stm(ByteStm);

		Stm.Save(Token.pClass);

		Token.pClass->SaveGame(Stm);
		if (!ByteStm.WriteBlockToStream(pStream))
		{
			RaiseWriteBlockError();
		}
	}
}