Merge branch 'master'.

3rdParty/Radon/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Dmitro Szewczuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

3rdParty/Radon/Radon/include/File.hpp

@@ -0,0 +1,29 @@
+// Copyright Dmitro bjornus Szewczuk 2017 under zlib license
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace radon
+{
+	class Section;
+
+	class File
+	{
+	public:
+
+		File(const std::string & path, bool reading = true);
+
+		Section* getSection(const std::string & name);
+
+		void File::addSection(const std::string & name);
+
+		void saveToFile();
+
+	private:
+		std::vector<Section> sections;
+		std::string path;
+	};
+}

3rdParty/Radon/Radon/include/Key.hpp

@@ -0,0 +1,35 @@
+// Copyright Dmitro bjornus Szewczuk 2017 under zlib license
+
+#pragma once
+
+#include <string>
+
+#include "Named.hpp"
+
+namespace radon
+{
+	class Key
+		: public Named
+	{
+	public:
+
+		Key();
+
+		Key(const std::string & name, const std::string & value);
+
+		Key(const std::string & name, const float & value);
+
+		std::string getStringValue();
+
+		float getFloatValue();
+
+		void setValue(float & value);
+
+		void setValue(std::string & value);
+
+	private:
+		std::string value;
+
+		friend class File;
+	};
+}

3rdParty/Radon/Radon/include/Named.hpp

@@ -0,0 +1,24 @@
+// Copyright Dmitro bjornus Szewczuk 2017 under zlib license
+
+#pragma once
+
+#include <string>
+
+namespace radon
+{
+	class Named
+	{
+	public:
+
+		Named();
+
+		Named(const std::string & name);
+
+		void setName(const std::string & name);
+
+		std::string getName();
+
+	protected:
+		std::string name;
+	};
+}

3rdParty/Radon/Radon/include/Radon.hpp

@@ -0,0 +1,9 @@
+// Copyright Dmitro bjornus Szewczuk 2017 under zlib license
+
+#pragma once
+
+#include "File.hpp"
+#include "Key.hpp"
+#include "Named.hpp"
+#include "Radon.hpp"
+#include "Section.hpp"

3rdParty/Radon/Radon/include/Section.hpp

@@ -0,0 +1,32 @@
+// Copyright Dmitro bjornus Szewczuk 2017 under zlib license
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "Named.hpp"
+
+namespace radon
+{
+	class Key;
+
+	class Section
+		: public Named
+	{
+	public:
+
+		Section();
+
+		Section(const std::string & name);
+
+		Key *getKey(const std::string & name);
+
+		void addKey(Key variable);
+
+	private:
+		std::vector<Key> keys;
+
+		friend class File;
+	};
+}

3rdParty/Radon/Radon/source/File.cpp

@@ -0,0 +1,82 @@
+// Copyright Dmitro bjornus Szewczuk 2017
+
+#include "../include/Radon.hpp"
+
+#include <string>
+#include <fstream>
+#include <algorithm>
+#include <iostream>
+#include <assert.h>
+
+namespace radon
+{
+	File::File(const std::string & path, bool reading)
+	{
+		this->path = path;
+		if (reading)
+		{
+			std::ifstream stream(path);
+
+			if (stream.is_open())
+			{
+				std::string buffer;
+				std::string nameOfCurrent = "";
+
+				while (std::getline(stream, buffer))
+				{
+					if (buffer[0] == ';' || buffer[0] == '#') continue;
+					if (buffer[0] == '[')
+					{
+						nameOfCurrent = buffer.substr(buffer.find("[") + 1, buffer.find("]") - 1);
+						sections.push_back(Section(nameOfCurrent));
+					}
+					else
+					{
+						int equalsPosition = buffer.find('=');
+
+						std::string nameOfElement = buffer.substr(0, equalsPosition);
+						std::string valueOfElement = buffer.substr(equalsPosition + 1, buffer.size());
+
+						sections.back().addKey(Key(nameOfElement, valueOfElement));
+					}
+				}
+			}
+		}
+	}
+
+
+	Section *File::getSection(const std::string & name)
+	{
+		for (auto & section : sections)
+		{
+			if (section.getName() == name)
+			{
+				return &section;
+			}
+		}
+
+		return nullptr;
+	}
+
+
+	void File::addSection(const std::string & name)
+	{
+		sections.push_back(Section(name));
+	}
+
+
+	void File::saveToFile()
+	{
+		std::ofstream file(path.data(), std::ios::out | std::ios::trunc);
+
+		for (auto & section : sections)
+		{
+			file << "[" << section.getName() << "] \n";
+			for (auto & key : section.keys)
+			{
+				file << key.getName() << "=" << key.getStringValue() << "\n";
+			}
+		}
+		file.close();
+	}
+}

3rdParty/Radon/Radon/source/Key.cpp

@@ -0,0 +1,47 @@
+// Copyright Dmitro bjornus Szewczuk 2017
+
+#include "../include/Radon.hpp"
+
+namespace radon
+{
+	Key::Key()
+		: Named()
+	{
+	}
+
+
+	Key::Key(const std::string & name, const std::string & value)
+		: Named(name), value(value)
+	{
+	}
+
+
+	Key::Key(const std::string & name, const float & value)
+		: Named(name), value(std::to_string(value))
+	{
+	}
+
+
+	std::string Key::getStringValue()
+	{
+		return value;
+	}
+
+
+	float Key::getFloatValue()
+	{
+		return (float)(atof(value.data()));
+	}
+
+
+	void Key::setValue(float & value)
+	{
+		this->value = std::to_string(value);
+	}
+
+
+	void Key::setValue(std::string & value)
+	{
+		this->value = value;
+	}
+}

3rdParty/Radon/Radon/source/Named.cpp

@@ -0,0 +1,29 @@
+// Copyright Dmitro bjornus Szewczuk 2017
+
+#include "../include/Radon.hpp"
+
+namespace radon
+{
+	Named::Named()
+	{
+		setName("You need to set name!");
+	}
+
+
+	Named::Named(const std::string & name)
+	{
+		setName(name);
+	}
+
+
+	void Named::setName(const std::string & name)
+	{
+		this->name = name;
+	}
+
+
+	std::string Named::getName()
+	{
+		return name;
+	}
+}

3rdParty/Radon/Radon/source/Section.cpp

@@ -0,0 +1,35 @@
+// Copyright Dmitro bjornus Szewczuk 2017
+
+#include "../include/Radon.hpp"
+
+#include <assert.h>
+
+namespace radon
+{
+	Section::Section()
+		: Named()
+	{
+	}
+
+
+	Section::Section(const std::string & name)
+		: Named(name)
+	{
+	}
+
+	Key *Section::getKey(const std::string & name)
+	{
+		for (auto & key : keys)
+		{
+			if (key.getName() == name)
+				return &key;
+		}
+
+		return nullptr;
+	}
+
+	void Section::addKey(Key key)
+	{
+		keys.push_back(key);
+	}
+}

CMakeLists.txt

@@ -163,6 +163,11 @@ set(STUB_SOURCES
     3rdParty/libsmacker/smk_hufftree.c
     3rdParty/libsmacker/smacker.c
 
+    3rdParty/Radon/Radon/source/File.cpp
+    3rdParty/Radon/Radon/source/Key.cpp
+    3rdParty/Radon/Radon/source/Named.cpp
+    3rdParty/Radon/Radon/source/Section.cpp
+
     3rdParty/StormLib/src/FileStream.cpp
     3rdParty/StormLib/src/SBaseCommon.cpp
     3rdParty/StormLib/src/SBaseFileTable.cpp

Stub/dx.cpp

@@ -361,6 +361,7 @@ void __fastcall dx_init(HWND hWnd)
 	lpDDSPrimary = &stub_surface;
 	lpDDSBackBuf = &stub_surface;
 	lpDDPalette = &stub_palette;
+	LoadGamma();
 }
 
 void __cdecl dx_cleanup()

Stub/miniwin.cpp

@@ -107,7 +107,7 @@ DWORD WINAPI GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize)
 	SDL_free(name);
 
 	int len = strlen(lpFilename);
-	lpFilename[len-1] = '\\';
+	lpFilename[len - 1] = '\\';
 
 	return len;
 }
@@ -290,7 +290,10 @@ DWORD WINAPI GetWindowThreadProcessId(HWND hWnd, LPDWORD lpdwProcessId)
 DWORD WINAPI GetPrivateProfileStringA(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpDefault, LPSTR lpReturnedString,
     DWORD nSize, LPCSTR lpFileName)
 {
-	UNIMPLEMENTED();
+	if (!SRegLoadString(lpAppName, lpKeyName, 0, lpReturnedString, nSize)) {
+		strncpy(lpReturnedString, lpDefault, nSize);
+		SRegSaveString(lpAppName, lpKeyName, 0, lpReturnedString);
+	}
 }
 
 int MessageBoxA(HWND hWnd, const char *Text, const char *Title, UINT Flags)

Stub/miniwin.h

@@ -41,8 +41,6 @@
 
 #define VOID void
 
-extern void *prealpha_mpq;
-
 typedef char CHAR;
 typedef uint16_t SHORT;
 typedef int32_t LONG;

Stub/movie.cpp

@@ -31,7 +31,7 @@ void __fastcall play_movie(char *pszMovie, BOOL user_can_close)
 	}
 
 	/* file meta-info */
-	unsigned int width, height, nFrames;
+	unsigned long width, height, nFrames;
 	/* arrays for audio track metadata */
 	unsigned char a_trackmask, a_channels[7], a_depth[7];
 	unsigned long a_rate[7];

Stub/storm.cpp

@@ -1,7 +1,20 @@
+#include "../3rdParty/Radon/Radon/include/Radon.hpp"
 #include "../types.h"
 
 DWORD nLastError = 0;
 
+std::string getIniPath()
+{
+	char path[280];
+	int len = GetModuleFileName(ghInst, path, 260);
+	path[len - 1] = '/';
+	strcat(path, "diablo.ini");
+
+	return path;
+}
+
+radon::File ini(getIniPath());
+
 // BOOL STORMAPI SFileCloseArchive(HANDLE hArchive)
 // {
 // 	UNIMPLEMENTED();
@@ -254,37 +267,87 @@ void *STORMAPI SMemReAlloc(void *location, unsigned int amount, char *logfilenam
 	UNIMPLEMENTED();
 }
 
-BOOL STORMAPI SRegLoadData(const char *keyname, const char *valuename, int size, LPBYTE lpData, BYTE flags,
-    LPDWORD lpcbData)
+bool getIniValue(const char *sectionName, const char *keyName, char *string, int stringSize, int *dataSize = NULL)
 {
-	DUMMY();
-	return 0;
+	radon::Section* section = ini.getSection(sectionName);
+	if (!section)
+		return false;
+
+	radon::Key *key = section->getKey(keyName);
+	if (!key)
+		return false;
+
+	std::string value = key->getStringValue();
+	if (dataSize)
+		*dataSize = value.length();
+
+	if (string)
+		strncpy(string, value.c_str(), stringSize);
+
+	return true;
+}
+
+void setIniValue(const char *sectionName, const char *keyName, char *value, int len = 0)
+{
+	radon::Section* section = ini.getSection(sectionName);
+	if (!section) {
+		ini.addSection(sectionName);
+		section = ini.getSection(sectionName);
+	}
+
+	std::string stringValue(value, len ?: strlen(value));
+
+	radon::Key *key = section->getKey(keyName);
+	if (!key) {
+		section->addKey(radon::Key(keyName, stringValue));
+	} else {
+		key->setValue(stringValue);
+	}
+
+	ini.saveToFile();
+}
+
+BOOL STORMAPI SRegLoadData(const char *keyname, const char *valuename, int size, LPBYTE lpData, BYTE flags, LPDWORD lpcbData)
+{
+	return getIniValue(keyname, valuename, lpData, size, lpcbData);
 }
 
 BOOL STORMAPI SRegLoadString(const char *keyname, const char *valuename, BYTE flags, char *buffer, unsigned int buffersize)
 {
-	UNIMPLEMENTED();
+	return getIniValue(keyname, valuename, buffer, buffersize);
 }
 
 BOOL STORMAPI SRegLoadValue(const char *keyname, const char *valuename, BYTE flags, int *value)
 {
-	DUMMY_PRINT("key: %s value: %s", keyname, valuename);
+	char string[10];
+	if (getIniValue(keyname, valuename, string, 10)) {
+		*value = strtol(string, NULL, 10);
+		return TRUE;
+	}
+
 	return FALSE;
 }
 
 BOOL STORMAPI SRegSaveData(const char *keyname, const char *valuename, int size, BYTE *lpData, DWORD cbData)
 {
-	UNIMPLEMENTED();
+	setIniValue(keyname, valuename, (char *)lpData, cbData);
+
+	return TRUE;
 }
 
 BOOL STORMAPI SRegSaveString(const char *keyname, const char *valuename, BYTE flags, char *string)
 {
-	UNIMPLEMENTED();
+	setIniValue(keyname, valuename, string);
+
+	return TRUE;
 }
 
 BOOL STORMAPI SRegSaveValue(const char *keyname, const char *valuename, BYTE flags, DWORD result)
 {
-	DUMMY_PRINT("key: %s value: %s", keyname, valuename);
+	char str[10];
+	sprintf(str, "%d", result);
+	setIniValue(keyname, valuename, str);
+
 	return TRUE;
 }