X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futility.h;h=28732a099f3a8cc77b6361530f4cde4ebe6d7d94;hb=ea3c653a8b6352b1df234e6a9663499e9a42bf90;hp=8f34c871163084424c9c3ecca3e25dd8939c9769;hpb=69dbc046eb5a82b38c6d5c3302e9b3b0b3c1bcf1;p=dragonfireclient.git

diff --git a/src/utility.h b/src/utility.h
index 8f34c8711..28732a099 100644
--- a/src/utility.h
+++ b/src/utility.h
@@ -24,6 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <fstream>
 #include <string>
 #include <sstream>
+#include <vector>
 #include <jthread.h>
 #include <jmutex.h>
 #include <jmutexautolock.h>
@@ -34,11 +35,25 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "exceptions.h"
 #include "porting.h"
 
+extern const v3s16 g_6dirs[6];
+
 extern const v3s16 g_26dirs[26];
 
 // 26th is (0,0,0)
 extern const v3s16 g_27dirs[27];
 
+inline void writeU64(u8 *data, u64 i)
+{
+	data[0] = ((i>>56)&0xff);
+	data[1] = ((i>>48)&0xff);
+	data[2] = ((i>>40)&0xff);
+	data[3] = ((i>>32)&0xff);
+	data[4] = ((i>>24)&0xff);
+	data[5] = ((i>>16)&0xff);
+	data[6] = ((i>> 8)&0xff);
+	data[7] = ((i>> 0)&0xff);
+}
+
 inline void writeU32(u8 *data, u32 i)
 {
 	data[0] = ((i>>24)&0xff);
@@ -58,6 +73,14 @@ inline void writeU8(u8 *data, u8 i)
 	data[0] = ((i>> 0)&0xff);
 }
 
+inline u64 readU64(u8 *data)
+{
+	return ((u64)data[0]<<56) | ((u64)data[1]<<48)
+		| ((u64)data[2]<<40) | ((u64)data[3]<<32)
+		| ((u64)data[4]<<24) | ((u64)data[5]<<16)
+		| ((u64)data[6]<<8) | ((u64)data[7]<<0);
+}
+
 inline u32 readU32(u8 *data)
 {
 	return (data[0]<<24) | (data[1]<<16) | (data[2]<<8) | (data[3]<<0);
@@ -73,8 +96,6 @@ inline u8 readU8(u8 *data)
 	return (data[0]<<0);
 }
 
-// Signed variants of the above
-
 inline void writeS32(u8 *data, s32 i){
 	writeU32(data, (u32)i);
 }
@@ -82,6 +103,13 @@ inline s32 readS32(u8 *data){
 	return (s32)readU32(data);
 }
 
+inline void writeF1000(u8 *data, f32 i){
+	writeS32(data, i*1000);
+}
+inline f32 readF1000(u8 *data){
+	return (f32)readS32(data)/1000.;
+}
+
 inline void writeS16(u8 *data, s16 i){
 	writeU16(data, (u16)i);
 }
@@ -95,7 +123,6 @@ inline void writeV3S32(u8 *data, v3s32 p)
 	writeS32(&data[4], p.Y);
 	writeS32(&data[8], p.Z);
 }
-
 inline v3s32 readV3S32(u8 *data)
 {
 	v3s32 p;
@@ -105,6 +132,21 @@ inline v3s32 readV3S32(u8 *data)
 	return p;
 }
 
+inline void writeV3F1000(u8 *data, v3f p)
+{
+	writeF1000(&data[0], p.X);
+	writeF1000(&data[4], p.Y);
+	writeF1000(&data[8], p.Z);
+}
+inline v3f readV3F1000(u8 *data)
+{
+	v3f p;
+	p.X = (float)readF1000(&data[0]);
+	p.Y = (float)readF1000(&data[4]);
+	p.Z = (float)readF1000(&data[8]);
+	return p;
+}
+
 inline void writeV2S16(u8 *data, v2s16 p)
 {
 	writeS16(&data[0], p.X);
@@ -149,6 +191,62 @@ inline v3s16 readV3S16(u8 *data)
 	return p;
 }
 
+/*
+	The above stuff directly interfaced to iostream
+*/
+
+inline void writeU8(std::ostream &os, u8 p)
+{
+	char buf[1];
+	writeU8((u8*)buf, p);
+	os.write(buf, 1);
+}
+inline u8 readU8(std::istream &is)
+{
+	char buf[1];
+	is.read(buf, 1);
+	return readU8((u8*)buf);
+}
+
+inline void writeU16(std::ostream &os, u16 p)
+{
+	char buf[2];
+	writeU16((u8*)buf, p);
+	os.write(buf, 2);
+}
+inline u16 readU16(std::istream &is)
+{
+	char buf[2];
+	is.read(buf, 2);
+	return readU16((u8*)buf);
+}
+
+inline void writeF1000(std::ostream &os, f32 p)
+{
+	char buf[2];
+	writeF1000((u8*)buf, p);
+	os.write(buf, 2);
+}
+inline f32 readF1000(std::istream &is)
+{
+	char buf[2];
+	is.read(buf, 2);
+	return readF1000((u8*)buf);
+}
+
+inline void writeV3F1000(std::ostream &os, v3f p)
+{
+	char buf[12];
+	writeV3F1000((u8*)buf, p);
+	os.write(buf, 12);
+}
+inline v3f readV3F1000(std::istream &is)
+{
+	char buf[12];
+	is.read(buf, 12);
+	return readV3F1000((u8*)buf);
+}
+
 /*
 	None of these are used at the moment
 */
@@ -399,8 +497,6 @@ class MutexedVariable
 	TimeTaker
 */
 
-class IrrlichtWrapper;
-
 class TimeTaker
 {
 public:
@@ -616,8 +712,10 @@ inline v3s16 arealim(v3s16 p, s16 d)
 inline std::wstring narrow_to_wide(const std::string& mbs)
 {
 	size_t wcl = mbs.size();
-	SharedBuffer<wchar_t> wcs(wcl+1);
+	Buffer<wchar_t> wcs(wcl+1);
 	size_t l = mbstowcs(*wcs, mbs.c_str(), wcl);
+	if(l == (size_t)(-1))
+		return L"<invalid multibyte string>";
 	wcs[l] = 0;
 	return *wcs;
 }
@@ -627,13 +725,26 @@ inline std::string wide_to_narrow(const std::wstring& wcs)
 	size_t mbl = wcs.size()*4;
 	SharedBuffer<char> mbs(mbl+1);
 	size_t l = wcstombs(*mbs, wcs.c_str(), mbl);
-	if((int)l == -1)
+	if(l == (size_t)(-1))
 		mbs[0] = 0;
 	else
 		mbs[l] = 0;
 	return *mbs;
 }
 
+// Split a string using the given delimiter. Returns a vector containing
+// the component parts.
+inline std::vector<std::wstring> str_split(const std::wstring &str, wchar_t delimiter)
+{
+	std::vector<std::wstring> parts;
+	std::wstringstream sstr(str);
+	std::wstring part;
+	while(std::getline(sstr, part, delimiter))
+		parts.push_back(part);
+	return parts;
+}
+
+
 /*
 	See test.cpp for example cases.
 	wraps degrees to the range of -360...360
@@ -689,6 +800,10 @@ inline s32 stoi(const std::string &s, s32 min, s32 max)
 	return i;
 }
 
+
+// MSVC2010 includes it's own versions of these
+#if !defined(_MSC_VER) || _MSC_VER < 1600
+
 inline s32 stoi(std::string s)
 {
 	return atoi(s.c_str());
@@ -702,6 +817,13 @@ inline float stof(std::string s)
 	return f;
 }
 
+#endif
+
+inline s32 stoi(std::wstring s)
+{
+	return atoi(wide_to_narrow(s).c_str());
+}
+
 inline std::string itos(s32 i)
 {
 	std::ostringstream o;
@@ -1232,6 +1354,14 @@ class Settings
 		return value;
 	}
 
+	void setBool(std::string name, bool value)
+	{
+		if(value)
+			set(name, "true");
+		else
+			set(name, "false");
+	}
+
 	void setS32(std::string name, s32 value)
 	{
 		set(name, itos(value));
@@ -1312,7 +1442,7 @@ class Settings
 };
 
 /*
-	FIFO queue
+	FIFO queue (well, actually a FILO also)
 */
 template<typename T>
 class Queue
@@ -1326,13 +1456,23 @@ class Queue
 	T pop_front()
 	{
 		if(m_list.size() == 0)
-			throw ItemNotFoundException("MutexedQueue: queue is empty");
+			throw ItemNotFoundException("Queue: queue is empty");
 
 		typename core::list<T>::Iterator begin = m_list.begin();
 		T t = *begin;
 		m_list.erase(begin);
 		return t;
 	}
+	T pop_back()
+	{
+		if(m_list.size() == 0)
+			throw ItemNotFoundException("Queue: queue is empty");
+
+		typename core::list<T>::Iterator last = m_list.getLast();
+		T t = *last;
+		m_list.erase(last);
+		return t;
+	}
 
 	u32 size()
 	{
@@ -1344,7 +1484,7 @@ class Queue
 };
 
 /*
-	Thread-safe FIFO queue
+	Thread-safe FIFO queue (well, actually a FILO also)
 */
 
 template<typename T>
@@ -1357,6 +1497,7 @@ class MutexedQueue
 	}
 	u32 size()
 	{
+		JMutexAutoLock lock(m_mutex);
 		return m_list.size();
 	}
 	void push_back(T t)
@@ -1390,6 +1531,32 @@ class MutexedQueue
 			wait_time_ms += 10;
 		}
 	}
+	T pop_back(u32 wait_time_max_ms=0)
+	{
+		u32 wait_time_ms = 0;
+
+		for(;;)
+		{
+			{
+				JMutexAutoLock lock(m_mutex);
+
+				if(m_list.size() > 0)
+				{
+					typename core::list<T>::Iterator last = m_list.getLast();
+					T t = *last;
+					m_list.erase(last);
+					return t;
+				}
+
+				if(wait_time_ms >= wait_time_max_ms)
+					throw ItemNotFoundException("MutexedQueue: queue is empty");
+			}
+
+			// Wait a while before trying again
+			sleep_ms(10);
+			wait_time_ms += 10;
+		}
+	}
 
 	JMutex & getMutex()
 	{
@@ -1406,6 +1573,10 @@ class MutexedQueue
 	core::list<T> m_list;
 };
 
+/*
+	A single worker thread - multiple client threads queue framework.
+*/
+
 template<typename Caller, typename Data>
 class CallerInfo
 {
@@ -1455,11 +1626,6 @@ class GetRequest
 	core::list<CallerInfo<Caller, CallerData> > callers;
 };
 
-/*
-	Quickhands for typical request-result queues.
-	Used for distributing work between threads.
-*/
-
 template<typename Key, typename T, typename Caller, typename CallerData>
 class RequestQueue
 {
@@ -1768,9 +1934,11 @@ inline v3f intToFloat(v3s16 p, f32 d)
 */
 
 // Creates a string with the length as the first two bytes
-inline std::string serializeString(const std::string plain)
+inline std::string serializeString(const std::string &plain)
 {
-	assert(plain.size() <= 65535);
+	//assert(plain.size() <= 65535);
+	if(plain.size() > 65535)
+		throw SerializationError("String too long for serializeString");
 	char buf[2];
 	writeU16((u8*)&buf[0], plain.size());
 	std::string s;
@@ -1779,22 +1947,28 @@ inline std::string serializeString(const std::string plain)
 	return s;
 }
 
-// Reads a string with the length as the first two bytes
+/*// Reads a string with the length as the first two bytes
 inline std::string deSerializeString(const std::string encoded)
 {
 	u16 s_size = readU16((u8*)&encoded.c_str()[0]);
+	if(s_size > encoded.length() - 2)
+		return "";
 	std::string s;
 	s.reserve(s_size);
 	s.append(&encoded.c_str()[2], s_size);
 	return s;
-}
+}*/
 
 // Reads a string with the length as the first two bytes
 inline std::string deSerializeString(std::istream &is)
 {
 	char buf[2];
 	is.read(buf, 2);
+	if(is.gcount() != 2)
+		throw SerializationError("deSerializeString: size not read");
 	u16 s_size = readU16((u8*)buf);
+	if(s_size == 0)
+		return "";
 	Buffer<char> buf2(s_size);
 	is.read(&buf2[0], s_size);
 	std::string s;
@@ -1804,7 +1978,7 @@ inline std::string deSerializeString(std::istream &is)
 }
 
 // Creates a string with the length as the first four bytes
-inline std::string serializeLongString(const std::string plain)
+inline std::string serializeLongString(const std::string &plain)
 {
 	char buf[4];
 	writeU32((u8*)&buf[0], plain.size());
@@ -1814,22 +1988,28 @@ inline std::string serializeLongString(const std::string plain)
 	return s;
 }
 
-// Reads a string with the length as the first four bytes
+/*// Reads a string with the length as the first four bytes
 inline std::string deSerializeLongString(const std::string encoded)
 {
 	u32 s_size = readU32((u8*)&encoded.c_str()[0]);
+	if(s_size > encoded.length() - 4)
+		return "";
 	std::string s;
 	s.reserve(s_size);
-	s.append(&encoded.c_str()[2], s_size);
+	s.append(&encoded.c_str()[4], s_size);
 	return s;
-}
+}*/
 
 // Reads a string with the length as the first four bytes
 inline std::string deSerializeLongString(std::istream &is)
 {
 	char buf[4];
 	is.read(buf, 4);
+	if(is.gcount() != 4)
+		throw SerializationError("deSerializeLongString: size not read");
 	u32 s_size = readU32((u8*)buf);
+	if(s_size == 0)
+		return "";
 	Buffer<char> buf2(s_size);
 	is.read(&buf2[0], s_size);
 	std::string s;
@@ -1838,5 +2018,63 @@ inline std::string deSerializeLongString(std::istream &is)
 	return s;
 }
 
+//
+
+inline u32 time_to_daynight_ratio(u32 time_of_day)
+{
+	const s32 daylength = 16;
+	const s32 nightlength = 6;
+	const s32 daytimelength = 8;
+	s32 d = daylength;
+	s32 t = (((time_of_day)%24000)/(24000/d));
+	if(t < nightlength/2 || t >= d - nightlength/2)
+		//return 300;
+		return 350;
+	else if(t >= d/2 - daytimelength/2 && t < d/2 + daytimelength/2)
+		return 1000;
+	else
+		return 750;
+}
+
+// Random helper. Usually d=BS
+inline core::aabbox3d<f32> getNodeBox(v3s16 p, float d)
+{
+	return core::aabbox3d<f32>(
+		(float)p.X * d - 0.5*d,
+		(float)p.Y * d - 0.5*d,
+		(float)p.Z * d - 0.5*d,
+		(float)p.X * d + 0.5*d,
+		(float)p.Y * d + 0.5*d,
+		(float)p.Z * d + 0.5*d
+	);
+}
+	
+class IntervalLimiter
+{
+public:
+	IntervalLimiter():
+		m_accumulator(0)
+	{
+	}
+	/*
+		dtime: time from last call to this method
+		wanted_interval: interval wanted
+		return value:
+			true: action should be skipped
+			false: action should be done
+	*/
+	bool step(float dtime, float wanted_interval)
+	{
+		m_accumulator += dtime;
+		if(m_accumulator < wanted_interval)
+			return false;
+		m_accumulator -= wanted_interval;
+		return true;
+	}
+protected:
+	float m_accumulator;
+};
+
+
 #endif