);
}
+inline s16 rangelim(s16 i, s16 min, s16 max)
+{
+ if(i < min)
+ return min;
+ if(i > max)
+ return max;
+ return i;
+}
+
+inline s16 rangelim(s16 i, s16 max)
+{
+ if(i < 0)
+ return 0;
+ if(i > max)
+ return max;
+ return i;
+}
+
+inline v3s16 arealim(v3s16 p, s16 d)
+{
+ if(p.X < 0)
+ p.X = 0;
+ if(p.Y < 0)
+ p.Y = 0;
+ if(p.Z < 0)
+ p.Z = 0;
+ if(p.X > d-1)
+ p.X = d-1;
+ if(p.Y > d-1)
+ p.Y = d-1;
+ if(p.Z > d-1)
+ p.Z = d-1;
+ return p;
+}
+
inline std::wstring narrow_to_wide(const std::string& mbs)
{
size_t wcl = mbs.size();
return atoi(s.c_str());
}
+inline std::string itos(s32 i)
+{
+ std::ostringstream o;
+ o<<i;
+ return o.str();
+}
+
+inline std::string ftos(float f)
+{
+ std::ostringstream o;
+ o<<f;
+ return o.str();
+}
+
/*
A base class for simple background thread implementation
*/
return stoi(get(name));
}
+ void clear()
+ {
+ m_settings.clear();
+ m_defaults.clear();
+ }
+
+ Settings & operator+=(Settings &other)
+ {
+ if(&other == this)
+ return *this;
+
+ for(core::map<std::string, std::string>::Iterator
+ i = other.m_settings.getIterator();
+ i.atEnd() == false; i++)
+ {
+ m_settings.insert(i.getNode()->getKey(),
+ i.getNode()->getValue());
+ }
+
+ for(core::map<std::string, std::string>::Iterator
+ i = other.m_defaults.getIterator();
+ i.atEnd() == false; i++)
+ {
+ m_defaults.insert(i.getNode()->getKey(),
+ i.getNode()->getValue());
+ }
+
+ }
+
+ Settings & operator=(Settings &other)
+ {
+ if(&other == this)
+ return *this;
+
+ clear();
+ (*this) += other;
+
+ return *this;
+ }
+
private:
core::map<std::string, std::string> m_settings;
core::map<std::string, std::string> m_defaults;
MutexedQueue< GetRequest<Key, T, Caller, CallerData> > m_queue;
};
+/*
+ Pseudo-random (VC++ rand() sucks)
+*/
+int myrand(void);
+void mysrand(unsigned seed);
+#define MYRAND_MAX 32767
+
+/*
+ Some kind of a thing that stores attributes related to
+ coordinate points
+*/
+
+struct Attribute
+{
+ Attribute()
+ {
+ }
+
+ Attribute(const std::string &value):
+ m_value(value)
+ {
+ }
+
+ Attribute(float value)
+ {
+ m_value = ftos(value);
+ }
+
+ void set(const std::string &value)
+ {
+ m_value = value;
+ }
+
+ std::string get()
+ {
+ return m_value;
+ }
+
+ bool getBool()
+ {
+ return is_yes(get());
+ }
+
+ float getFloat()
+ {
+ float f;
+ std::istringstream vis(get());
+ vis>>f;
+ return f;
+ }
+
+ u16 getU16()
+ {
+ return stoi(get(), 0, 65535);
+ }
+
+ s16 getS16()
+ {
+ return stoi(get(), -32768, 32767);
+ }
+
+ s32 getS32()
+ {
+ return stoi(get());
+ }
+
+ std::string m_value;
+};
+
+class PointAttributeList
+{
+ struct PointWithAttr
+ {
+ v3s16 p;
+ Attribute attr;
+ };
+
+public:
+ ~PointAttributeList()
+ {
+ /*for(core::list<PointWithAttr>::Iterator
+ i = m_points.begin();
+ i != m_points.end(); i++)
+ {
+ PointWithAttr &pwa = *i;
+ //delete pwa.attr;
+ }*/
+ }
+
+ Attribute getNearAttr(v3s16 p)
+ {
+ core::list<PointWithAttr>::Iterator
+ nearest_i = m_points.end();
+ s16 nearest_d = 32767;
+ for(core::list<PointWithAttr>::Iterator
+ i = m_points.begin();
+ i != m_points.end(); i++)
+ {
+ PointWithAttr &pwa = *i;
+ s16 d = pwa.p.getDistanceFrom(p);
+ if(d < nearest_d)
+ {
+ nearest_i = i;
+ nearest_d = d;
+ }
+ }
+
+ if(nearest_i == m_points.end())
+ Attribute();
+
+ return nearest_i->attr;
+ }
+
+ Attribute getNearAttr(v2s16 p)
+ {
+ return getNearAttr(v3s16(p.X, 0, p.Y));
+ }
+
+ bool empty()
+ {
+ return (m_points.size() == 0);
+ }
+
+ /*
+ Take all points in range, or at least the nearest point,
+ and interpolate the values as floats
+ */
+ float getInterpolatedFloat(v3s16 p);
+
+ float getInterpolatedFloat(v2s16 p)
+ {
+ return getInterpolatedFloat(v3s16(p.X, 0, p.Y));
+ }
+
+ //float getInterpolatedFloat(v3s16 p, s32 range);
+ /*float getInterpolatedFloat(v2s16 p, s32 range)
+ {
+ return getInterpolatedFloat(v3s16(p.X, 0, p.Y), range);
+ }*/
+
+ void addPoint(v3s16 p, const Attribute &attr)
+ {
+ PointWithAttr pattr;
+ pattr.p = p;
+ pattr.attr = attr;
+ m_points.push_back(pattr);
+ }
+
+ void addPoint(v2s16 p, const Attribute &attr)
+ {
+ addPoint(v3s16(p.X, 0, p.Y), attr);
+ }
+
+private:
+ core::list<PointWithAttr> m_points;
+};
+
+/*
+ Basically just a wrapper to core::map<PointAttributeList*>
+*/
+
+class PointAttributeDatabase
+{
+public:
+ ~PointAttributeDatabase()
+ {
+ for(core::map<std::string, PointAttributeList*>::Iterator
+ i = m_lists.getIterator();
+ i.atEnd() == false; i++)
+ {
+ delete i.getNode()->getValue();
+ }
+ }
+
+ PointAttributeList *getList(const std::string &name)
+ {
+ PointAttributeList *list = NULL;
+
+ core::map<std::string, PointAttributeList*>::Node *n;
+ n = m_lists.find(name);
+
+ if(n == NULL)
+ {
+ list = new PointAttributeList();
+ m_lists.insert(name, list);
+ }
+ else
+ {
+ list = n->getValue();
+ }
+
+ return list;
+ }
+private:
+ core::map<std::string, PointAttributeList*> m_lists;
+};
+
#endif