#include <fstream>
#include <string>
#include <sstream>
+#include <vector>
#include <jthread.h>
#include <jmutex.h>
#include <jmutexautolock.h>
#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);
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);
return (data[0]<<0);
}
-// Signed variants of the above
-
inline void writeS32(u8 *data, s32 i){
writeU32(data, (u32)i);
}
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);
}
writeS32(&data[4], p.Y);
writeS32(&data[8], p.Z);
}
-
inline v3s32 readV3S32(u8 *data)
{
v3s32 p;
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);
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
*/
TimeTaker
*/
-class IrrlichtWrapper;
-
class TimeTaker
{
public:
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
return atoi(s.c_str());
}
+inline s32 stoi(std::wstring s)
+{
+ return atoi(wide_to_narrow(s).c_str());
+}
+
inline float stof(std::string s)
{
float f;
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));
}
u32 size()
{
+ JMutexAutoLock lock(m_mutex);
return m_list.size();
}
void push_back(T t)
core::list<T> m_list;
};
+/*
+ A single worker thread - multiple client threads queue framework.
+*/
+
template<typename Caller, typename Data>
class CallerInfo
{
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
{
*/
// 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;
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;
}
// 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());
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;
s32 d = daylength;
s32 t = (((time_of_day)%24000)/(24000/d));
if(t < nightlength/2 || t >= d - nightlength/2)
- return 300;
+ //return 300;
+ return 350;
else if(t >= d/2 - daytimelength/2 && t < d/2 + daytimelength/2)
return 1000;
else
);
}
+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
projects / dragonfireclient.git / blobdiff