bool nGame::AddHiScore(unsigned long value)
{
if(!value)
return false;
static const unsigned long maxScores = 20;
for(unsigned long i = 0; i < m_HiScores.size(); i++)
if(m_HiScores[i].score < value)
break;
HiScore hiscore;
static char time[100];
GetTimeFormat(LOCALE_USER_DEFAULT,NULL,NULL,NULL,time,100);
static char date[100];
GetDateFormat(LOCALE_USER_DEFAULT,DATE_LONGDATE,NULL,NULL,date,100);
hiscore.score = value;
hiscore.time = nString(time) + " " + nString(date);
if(i < m_HiScores.size())
m_HiScores.insert(m_HiScores.begin() + i,hiscore);
else
m_HiScores.push_back(hiscore);
while(m_HiScores.size() > maxScores)
m_HiScores.pop_back();
return true;
}
API void Categories_BeginCreate(const char* Name, const char* CppClass, const char* TplTable, const char* InstTable)
{
NewCat = n_new(Data::CParams);
NewCatName = CStrID(Name);
NewCat->Set(CStrID("CppClass"), nString(CppClass));
nString TplTableStr = TplTable;
if (TplTableStr != nString("Tpl") + Name)
NewCat->Set(CStrID("TplTableName"), TplTableStr);
nString InstTableStr = InstTable;
if (InstTableStr != nString("Inst") + Name)
NewCat->Set(CStrID("InstTableName"), InstTableStr);
NewCatProps = n_new(Data::CDataArray);
NewCat->Set(CStrID("Props"), NewCatProps);
}
void nFrameBuffer::setUnmodified() {
bool valid = depthTexture && depthTexture->getSize().mul() > 0;
for(int i = 0; i != nGL::getState()->getHWInt(nGLState::MaxFboAttachements) && !valid; i++) {
if(attachments[i]) {
valid = attachments[i]->getSize().mul() > 0;
}
}
if(valid && glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
int error = glCheckFramebufferStatus(GL_FRAMEBUFFER);
nError("Unable to modify frame-buffer-object, error = " + (error == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT ? nString("MISSING ATTACHMENT") :
(error == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT ? nString("INCOMPLETE ATTACHMENT") :
(error == GL_FRAMEBUFFER_UNSUPPORTED ? nString("UNSUPPORTED") : nString::fromNumber(error)))));
}
modified = false;
}
void CPropTalking::SayPhrase(CStrID PhraseID)
{
PParams P = n_new(CParams);
//!!! Try to find the phrase by it's ID before saying it.
P->Set(CStrID("Text"), nString(PhraseID.CStr()));
P->Set(CStrID("EntityID"), GetEntity()->GetUniqueID());
EventMgr->FireEvent(CStrID("ShowPhrase"), P);
P = n_new(CParams);
P->Set(CStrID("EntityID"), GetEntity()->GetUniqueID());
//!!! TODO: Calculate time
EventMgr->FireEvent(CStrID("HidePhrase"), P, 0, 5.f);
}
CDataServer::CDataServer(): HRDCache(PParams()), Assigns(nString())
{
n_assert(!Singleton);
Singleton = this;
DefaultFS = n_new(CFileSystemWin32);
nString SysFolder;
if (DefaultFS->GetSystemFolderPath(SF_HOME, SysFolder)) SetAssign("home", SysFolder);
if (DefaultFS->GetSystemFolderPath(SF_BIN, SysFolder)) SetAssign("bin", SysFolder);
if (DefaultFS->GetSystemFolderPath(SF_USER, SysFolder)) SetAssign("user", SysFolder);
if (DefaultFS->GetSystemFolderPath(SF_TEMP, SysFolder)) SetAssign("temp", SysFolder);
if (DefaultFS->GetSystemFolderPath(SF_APP_DATA, SysFolder)) SetAssign("appdata", SysFolder);
if (DefaultFS->GetSystemFolderPath(SF_PROGRAMS, SysFolder)) SetAssign("programs", SysFolder);
}
bool CPropAIHints::OnPropsActivated(const CEventBase& Event)
{
//???read OnLoad, OnPropsActivated-Deactivate from initialized array?
//???need to cache?
Data::PParams Desc;
const nString& DescName = GetEntity()->Get<nString>(Attr::AIHintsDesc);
if (DescName.IsValid()) Desc = DataSrv->LoadPRM(nString("aihints:") + DescName + ".prm");
if (Desc.isvalid())
{
const vector3& Pos = GetEntity()->Get<matrix44>(Attr::Transform).pos_component();
Hints.Clear();
Hints.BeginAdd();
for (int i = 0; i < Desc->GetCount(); i++)
{
const CParam& Prm = Desc->Get(i);
PParams PrmVal = Prm.GetValue<PParams>();
CRecord Rec;
Rec.Stimulus = (CStimulus*)CoreFct->Create(StrStimulusPrefix + PrmVal->Get<nString>(CStrID("Type"), NULL));
Rec.Stimulus->SourceEntityID = GetEntity()->GetUniqueID();
Rec.Stimulus->Position = Pos; //!!!offset * tfm!
Rec.Stimulus->Intensity = PrmVal->Get<float>(CStrID("Intensity"), 1.f);
Rec.Stimulus->ExpireTime = PrmVal->Get<float>(CStrID("ExpireTime"), -1.f);
const nString& SizeStr = PrmVal->Get<nString>(CStrID("Size"), NULL);
if (SizeStr.IsEmpty())
{
Rec.Stimulus->Radius = PrmVal->Get<float>(CStrID("Radius"), 0.f);
//!!!Rec.Stimulus->Height = PrmVal->Get<float>(CStrID("Height"), 0.f);
}
else if (SizeStr == "Box" || SizeStr == "GfxBox")
{
CPropGraphics* pPropGfx = GetEntity()->FindProperty<CPropGraphics>();
if (pPropGfx)
{
bbox3 AABB;
pPropGfx->GetAABB(AABB);
vector2 HorizDiag(AABB.vmax.x - AABB.vmin.x, AABB.vmax.z - AABB.vmin.z);
Rec.Stimulus->Radius = HorizDiag.len() * 0.5f;
//!!!Rec.Stimulus->Height = AABB.vmax.y - AABB.vmin.y;
}
}
else if (SizeStr == "PhysBox")
{
CPropPhysics* pPropPhys = GetEntity()->FindProperty<CPropPhysics>();
if (pPropPhys)
{
bbox3 AABB;
pPropPhys->GetAABB(AABB);
vector2 HorizDiag(AABB.vmax.x - AABB.vmin.x, AABB.vmax.z - AABB.vmin.z);
Rec.Stimulus->Radius = HorizDiag.len() * 0.5f;
//!!!Rec.Stimulus->Height = AABB.vmax.y - AABB.vmin.y;
}
}
else if (SizeStr == "Attr")
{
Rec.Stimulus->Radius = GetEntity()->Get<float>(Attr::Radius);
//!!!Rec.Stimulus->Height = GetEntity()->Get<float>(Attr::Height);
}
//???Rec.Stimulus->Init(PrmVal);
Rec.pNode = PrmVal->Get(CStrID("Enabled"), false) ? AISrv->GetLevel()->RegisterStimulus(Rec.Stimulus) : NULL;
Hints.Add(Prm.GetName(), Rec);
}
Hints.EndAdd();
}
OK;
}
// Gather row of Result values from SQLite and add them to the Result CValueTable.
// Note that modification tracking is turned off in the value table, because reading
// from the DB doesn't count as modification.
void CCommand::ReadRow()
{
n_assert(SQLiteStmt);
n_assert(VT.isvalid());
int RowIdx = VT->AddRow();
int ResultColIdx;
const int ColCount = sqlite3_data_count(SQLiteStmt);
for (ResultColIdx = 0; ResultColIdx < ColCount; ResultColIdx++)
{
int ResultColType = sqlite3_column_type(SQLiteStmt, ResultColIdx);
if (SQLITE_NULL == ResultColType) continue;
int ColIdx = ResultIdxMap[ResultColIdx];
if (ColIdx < 0) continue;
const CType* Type = VT->GetColumnValueType(ColIdx);
if (Type == TInt)
{
n_assert(SQLITE_INTEGER == ResultColType);
int Val = sqlite3_column_int(SQLiteStmt, ResultColIdx);
VT->Set<int>(ColIdx, RowIdx, Val);
}
else if (Type == TFloat)
{
n_assert(SQLITE_FLOAT == ResultColType);
float Val = (float)sqlite3_column_double(SQLiteStmt, ResultColIdx);
VT->Set<float>(ColIdx, RowIdx, Val);
}
else if (Type == TBool)
{
n_assert(SQLITE_INTEGER == ResultColType);
int Val = sqlite3_column_int(SQLiteStmt, ResultColIdx);
VT->Set<bool>(ColIdx, RowIdx, (Val == 1));
}
else if (Type == TString)
{
n_assert(SQLITE_TEXT == ResultColType);
nString Val = (LPCSTR)sqlite3_column_text(SQLiteStmt, ResultColIdx);
VT->Set<nString>(ColIdx, RowIdx, Val);
}
else if (Type == TStrID)
{
n_assert(SQLITE_TEXT == ResultColType);
CStrID Val((LPCSTR)sqlite3_column_text(SQLiteStmt, ResultColIdx));
VT->Set<CStrID>(ColIdx, RowIdx, Val);
}
else if (Type == TVector4)
{
n_assert(SQLITE_BLOB == ResultColType);
const void* ptr = sqlite3_column_blob(SQLiteStmt, ResultColIdx);
uint size = sqlite3_column_bytes(SQLiteStmt, ResultColIdx);
const float* fptr = (const float*)ptr;
vector4 value;
if (size < sizeof(vector4))
{
n_assert(size == 12); // vector3
value.set(fptr[0], fptr[1], fptr[2], 0);
}
else
{
n_assert(size == sizeof(vector4));
value.set(fptr[0], fptr[1], fptr[2], fptr[3]);
}
VT->Set<vector4>(ColIdx, RowIdx, value);
}
else if (Type == TMatrix44)
{
n_assert(SQLITE_BLOB == ResultColType);
n_assert(sqlite3_column_bytes(SQLiteStmt, ResultColIdx) == sizeof(matrix44));
matrix44 mtx(*(const matrix44*)sqlite3_column_blob(SQLiteStmt, ResultColIdx));
VT->Set<matrix44>(ColIdx, RowIdx, mtx);
}
else if (Type == TBuffer)
{
n_assert(SQLITE_BLOB == ResultColType);
const void* ptr = sqlite3_column_blob(SQLiteStmt, ResultColIdx);
int size = sqlite3_column_bytes(SQLiteStmt, ResultColIdx);
CBuffer Blob(ptr, size);
VT->Set<CBuffer>(ColIdx, RowIdx, Blob);
}
else if (!Type)
{
// Variable type column, it supports int, float & string. Bool is represented as int.
// If ScriptObject wants to save bool to DB & then restore it, this object should
// implement OnLoad scripted method or smth and convert int values to bool inside.
switch (ResultColType)
{
case SQLITE_INTEGER:
VT->Set<int>(ColIdx, RowIdx, sqlite3_column_int(SQLiteStmt, ResultColIdx));
break;
case SQLITE_FLOAT:
VT->Set<float>(ColIdx, RowIdx, (float)sqlite3_column_double(SQLiteStmt, ResultColIdx));
break;
case SQLITE_TEXT:
VT->Set<nString>(ColIdx, RowIdx, nString((LPCSTR)sqlite3_column_text(SQLiteStmt, ResultColIdx)));
break;
default: n_error("CCommand::ReadResultRow(): invalid attribute type!");
}
}
else n_error("CCommand::ReadResultRow(): invalid attribute type!");
}
}
//!!!???to loaders?!
CComposite* CPhysicsServer::LoadCompositeFromPRM(const nString& Name) const
{
n_assert(Name.IsValid());
PParams Desc = DataSrv->LoadPRM(nString("physics:") + Name + ".prm");
if (!Desc.isvalid()) return NULL;
CComposite* pComposite = (CComposite*)CoreFct->Create(PhysClassPrefix + Desc->Get<nString>(CStrID("Type")));
if (!pComposite) return NULL;
int Idx = Desc->IndexOf(CStrID("Bodies"));
if (Idx != INVALID_INDEX)
{
CDataArray& Bodies = *Desc->Get<PDataArray>(Idx);
pComposite->BeginBodies(Bodies.Size());
for (int i = 0; i < Bodies.Size(); i++)
{
PParams BodyDesc = Bodies[i];
PRigidBody pBody = CRigidBody::Create();
pBody->Name = BodyDesc->Get<nString>(CStrID("Name"));
pBody->CollideConnected = BodyDesc->Get<bool>(CStrID("CollideConnected"), false);
matrix44 InitialTfm(quaternion(
BodyDesc->Get<float>(CStrID("RotX")),
BodyDesc->Get<float>(CStrID("RotY")),
BodyDesc->Get<float>(CStrID("RotZ")),
BodyDesc->Get<float>(CStrID("RotW"))));
InitialTfm.translate(vector3(
BodyDesc->Get<float>(CStrID("PosX")),
BodyDesc->Get<float>(CStrID("PosY")),
BodyDesc->Get<float>(CStrID("PosZ"))));
pBody->SetInitialTransform(InitialTfm);
pBody->SetLinkName(CRigidBody::ModelNode, BodyDesc->Get<nString>(CStrID("Model"), NULL));
pBody->SetLinkName(CRigidBody::ShadowNode, BodyDesc->Get<nString>(CStrID("Shadow"), NULL));
pBody->SetLinkName(CRigidBody::JointNode, BodyDesc->Get<nString>(CStrID("Joint"), NULL));
CDataArray& Shapes = *BodyDesc->Get<PDataArray>(CStrID("Shapes"));
pBody->BeginShapes(Shapes.Size());
for (int j = 0; j < Shapes.Size(); j++)
{
PParams ShapeDesc = Shapes[j];
PShape pShape = (CShape*)CoreFct->Create(PhysClassPrefix + ShapeDesc->Get<nString>(CStrID("Type")));
pShape->Init(ShapeDesc);
pBody->AddShape(pShape);
}
pBody->EndShapes();
pComposite->AddBody(pBody);
}
pComposite->EndBodies();
}
Idx = Desc->IndexOf(CStrID("Joints"));
if (Idx != INVALID_INDEX)
{
CDataArray& Joints = *Desc->Get<PDataArray>(Idx);
pComposite->BeginJoints(Joints.Size());
for (int i = 0; i < Joints.Size(); i++)
{
PParams JointDesc = Joints[i];
PJoint pJoint = (CJoint*)CoreFct->Create(PhysClassPrefix + JointDesc->Get<nString>(CStrID("Type")));
Idx = Desc->IndexOf(CStrID("Body1"));
if (Idx != INVALID_INDEX)
pJoint->SetBody1(pComposite->GetBodyByName(Desc->Get(Idx).GetRawValue()));
Idx = Desc->IndexOf(CStrID("Body2"));
if (Idx != INVALID_INDEX)
pJoint->SetBody2(pComposite->GetBodyByName(Desc->Get(Idx).GetRawValue()));
pJoint->LinkName = Desc->Get<nString>(CStrID("Joint"), NULL);
pJoint->Init(JointDesc);
pComposite->AddJoint(pJoint);
}
pComposite->EndJoints();
}
Idx = Desc->IndexOf(CStrID("Shapes"));
if (Idx != INVALID_INDEX)
{
CDataArray& Shapes = *Desc->Get<PDataArray>(Idx);
pComposite->BeginShapes(Shapes.Size());
for (int i = 0; i < Shapes.Size(); i++)
{
PParams ShapeDesc = Shapes[i];
PShape pShape = (CShape*)CoreFct->Create("Physics::C" + ShapeDesc->Get<nString>(CStrID("Type")));
pShape->Init(ShapeDesc);
pComposite->AddShape(pShape);
}
pComposite->EndShapes();
}
return pComposite;
}
API void Categories_AddProperty(const char* Prop)
{
NewCatProps->Append(nString(Prop));
}
