mirror of
https://github.com/openmoh/openmohaa.git
synced 2025-04-28 13:47:58 +03:00
873 lines
No EOL
20 KiB
C++
873 lines
No EOL
20 KiB
C++
/*
|
|
===========================================================================
|
|
Copyright (C) 2015 the OpenMoHAA team
|
|
|
|
This file is part of OpenMoHAA source code.
|
|
|
|
OpenMoHAA source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
OpenMoHAA source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenMoHAA source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
// class.cpp: General class.
|
|
|
|
#include "class.h"
|
|
#include "listener.h"
|
|
#include "q_shared.h"
|
|
|
|
#if defined(GAME_DLL)
|
|
|
|
# include "../fgame/g_local.h"
|
|
|
|
# define CLASS_Printf gi.Printf
|
|
# define CLASS_DPrintf gi.DPrintf
|
|
# define CLASS_Error gi.Error
|
|
|
|
#elif defined(CGAME_DLL)
|
|
|
|
# include "../cgame/cg_local.h"
|
|
|
|
# define CLASS_Printf cgi.Printf
|
|
# define CLASS_DPrintf cgi.DPrintf
|
|
# define CLASS_Error cgi.Error
|
|
|
|
#else
|
|
|
|
# define CLASS_Printf Com_Printf
|
|
# define CLASS_DPrintf Com_DPrintf
|
|
# define CLASS_Error Com_Error
|
|
|
|
#endif
|
|
|
|
#ifdef WITH_SCRIPT_ENGINE
|
|
|
|
# include "../fgame/scriptmaster.h"
|
|
|
|
#endif
|
|
|
|
ClassDef *ClassDef::classlist;
|
|
int ClassDef::numclasses;
|
|
|
|
int ClassDef::dump_numclasses;
|
|
int ClassDef::dump_numevents;
|
|
Container<int> ClassDef::sortedList;
|
|
Container<ClassDef *> ClassDef::sortedClassList;
|
|
|
|
int ClassDef::compareClasses(const void *arg1, const void *arg2)
|
|
{
|
|
ClassDef *c1 = *(ClassDef **)arg1;
|
|
ClassDef *c2 = *(ClassDef **)arg2;
|
|
|
|
return Q_stricmp(c1->classname, c2->classname);
|
|
}
|
|
|
|
void ClassDef::SortClassList(Container<ClassDef *> *sortedList)
|
|
{
|
|
ClassDef *c;
|
|
|
|
sortedList->Resize(numclasses);
|
|
|
|
for (c = classlist->next; c != classlist; c = c->next) {
|
|
sortedList->AddObject(c);
|
|
}
|
|
|
|
qsort(
|
|
(void *)sortedList->AddressOfObjectAt(1), (size_t)sortedList->NumObjects(), sizeof(ClassDef *), compareClasses
|
|
);
|
|
}
|
|
|
|
ClassDef *getClassForID(const char *name)
|
|
{
|
|
ClassDef *classlist = ClassDef::classlist;
|
|
ClassDef *c;
|
|
|
|
for (c = classlist->next; c != classlist; c = c->next) {
|
|
if (c->classID && !Q_stricmp(c->classID, name)) {
|
|
return c;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
ClassDef *getClass(const char *name)
|
|
{
|
|
if (name == NULL || !*name) {
|
|
return NULL;
|
|
}
|
|
|
|
ClassDef *list = ClassDef::classlist;
|
|
ClassDef *c;
|
|
|
|
for (c = list->next; c != list; c = c->next) {
|
|
if (Q_stricmp(c->classname, name) == 0) {
|
|
return c;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
ClassDef *getClassList(void)
|
|
{
|
|
return ClassDef::classlist;
|
|
}
|
|
|
|
void listAllClasses(void)
|
|
{
|
|
ClassDef *c;
|
|
ClassDef *list = ClassDef::classlist;
|
|
|
|
for (c = list->next; c != list; c = c->next) {
|
|
CLASS_DPrintf("%s\n", c->classname);
|
|
}
|
|
}
|
|
|
|
void listInheritanceOrder(const char *classname)
|
|
{
|
|
ClassDef *cls;
|
|
ClassDef *c;
|
|
|
|
cls = getClass(classname);
|
|
if (!cls) {
|
|
CLASS_DPrintf("Unknown class: %s\n", classname);
|
|
return;
|
|
}
|
|
for (c = cls; c != NULL; c = c->super) {
|
|
CLASS_DPrintf("%s\n", c->classname);
|
|
}
|
|
}
|
|
|
|
qboolean checkInheritance(const ClassDef *superclass, const ClassDef *subclass)
|
|
{
|
|
const ClassDef *c;
|
|
|
|
for (c = subclass; c != NULL; c = c->super) {
|
|
if (c == superclass) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
qboolean checkInheritance(ClassDef *superclass, const char *subclass)
|
|
{
|
|
ClassDef *c;
|
|
|
|
c = getClass(subclass);
|
|
|
|
if (c == NULL) {
|
|
CLASS_DPrintf("Unknown class: %s\n", subclass);
|
|
return false;
|
|
}
|
|
|
|
return checkInheritance(superclass, c);
|
|
}
|
|
|
|
qboolean checkInheritance(const char *superclass, const char *subclass)
|
|
{
|
|
ClassDef *c1;
|
|
ClassDef *c2;
|
|
|
|
c1 = getClass(superclass);
|
|
c2 = getClass(subclass);
|
|
|
|
if (c1 == NULL) {
|
|
CLASS_DPrintf("Unknown class: %s\n", superclass);
|
|
return false;
|
|
}
|
|
|
|
if (c2 == NULL) {
|
|
CLASS_DPrintf("Unknown class: %s\n", subclass);
|
|
return false;
|
|
}
|
|
|
|
return checkInheritance(c1, c2);
|
|
}
|
|
|
|
void CLASS_Print(FILE *class_file, const char *fmt, ...)
|
|
{
|
|
va_list argptr;
|
|
char text[1024];
|
|
|
|
va_start(argptr, fmt);
|
|
vsprintf(text, fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
if (class_file) {
|
|
fprintf(class_file, "%s", text);
|
|
} else {
|
|
CLASS_DPrintf("%s", text);
|
|
}
|
|
}
|
|
|
|
size_t totalmemallocated = 0;
|
|
unsigned int numclassesallocated = 0;
|
|
|
|
bool classInited = false;
|
|
|
|
#ifndef _DEBUG_MEM
|
|
void *Class::operator new(size_t s)
|
|
{
|
|
size_t *p;
|
|
|
|
if (s == 0) {
|
|
static void *empty_memory = nullptr;
|
|
return &empty_memory;
|
|
}
|
|
|
|
s += sizeof(size_t);
|
|
|
|
# ifdef GAME_DLL
|
|
p = (size_t *)gi.Malloc(s);
|
|
# elif defined(CGAME_DLL)
|
|
p = (size_t *)cgi.Malloc(s);
|
|
# else
|
|
p = (size_t *)Z_Malloc(s);
|
|
# endif
|
|
|
|
totalmemallocated += s;
|
|
numclassesallocated++;
|
|
|
|
p++;
|
|
|
|
return p;
|
|
}
|
|
|
|
void Class::operator delete(void *ptr)
|
|
{
|
|
size_t *p = ((size_t *)ptr) - 1;
|
|
|
|
totalmemallocated -= *p;
|
|
numclassesallocated--;
|
|
|
|
# ifdef GAME_DLL
|
|
gi.Free(p);
|
|
# elif defined(CGAME_DLL)
|
|
cgi.Free(p);
|
|
# else
|
|
Z_Free(p);
|
|
# endif
|
|
}
|
|
|
|
#endif
|
|
|
|
Class::Class()
|
|
{
|
|
SafePtrList = NULL;
|
|
}
|
|
|
|
Class::~Class()
|
|
{
|
|
ClearSafePointers();
|
|
}
|
|
|
|
void Class::Archive(Archiver& arc) {}
|
|
|
|
void Class::ClearSafePointers(void)
|
|
{
|
|
while (SafePtrList != NULL) {
|
|
SafePtrList->Clear();
|
|
}
|
|
}
|
|
|
|
void Class::warning(const char *function, const char *format, ...)
|
|
{
|
|
char buffer[MAX_STRING_CHARS];
|
|
const char *classname;
|
|
va_list va;
|
|
|
|
va_start(va, format);
|
|
vsprintf(buffer, format, va);
|
|
|
|
classname = classinfo()->classname;
|
|
|
|
#ifdef GAME_DLL
|
|
gi.DPrintf(
|
|
#elif defined CGAME_DLL
|
|
cgi.DPrintf(
|
|
#else
|
|
Com_DPrintf(
|
|
#endif
|
|
"%s::%s : %s\n", classname, function, buffer
|
|
);
|
|
}
|
|
|
|
void Class::error(const char *function, const char *fmt, ...)
|
|
{
|
|
va_list argptr;
|
|
char text[1024];
|
|
|
|
va_start(argptr, fmt);
|
|
vsprintf(text, fmt, argptr);
|
|
va_end(argptr);
|
|
|
|
if (getClassID()) {
|
|
CLASS_Error(ERR_DROP, "%s::%s : %s\n", getClassID(), function, text);
|
|
} else {
|
|
CLASS_Error(ERR_DROP, "%s::%s : %s\n", getClassname(), function, text);
|
|
}
|
|
}
|
|
|
|
ClassDef::ClassDef()
|
|
{
|
|
this->classname = NULL;
|
|
this->classID = NULL;
|
|
this->superclass = NULL;
|
|
this->responses = NULL;
|
|
this->numEvents = 0;
|
|
this->responseLookup = NULL;
|
|
this->newInstance = NULL;
|
|
this->classSize = 0;
|
|
this->super = NULL;
|
|
this->prev = this;
|
|
this->next = this;
|
|
|
|
#ifdef WITH_SCRIPT_ENGINE
|
|
this->waitTillSet = NULL;
|
|
#endif
|
|
}
|
|
|
|
ClassDef::ClassDef(
|
|
const char *classname,
|
|
const char *classID,
|
|
const char *superclass,
|
|
ResponseDef<Class> *responses,
|
|
void *(*newInstance)(void),
|
|
int classSize
|
|
)
|
|
{
|
|
ClassDef *node;
|
|
|
|
if (classlist == NULL) {
|
|
classlist = new ClassDef;
|
|
}
|
|
|
|
this->classname = classname;
|
|
this->classID = classID;
|
|
this->superclass = superclass;
|
|
this->responses = responses;
|
|
this->numEvents = 0;
|
|
this->responseLookup = NULL;
|
|
this->newInstance = newInstance;
|
|
this->classSize = classSize;
|
|
this->super = getClass(superclass);
|
|
|
|
#ifdef WITH_SCRIPT_ENGINE
|
|
this->waitTillSet = NULL;
|
|
#endif
|
|
|
|
if (!classID) {
|
|
this->classID = "";
|
|
}
|
|
|
|
for (node = classlist->next; node != classlist; node = node->next) {
|
|
if ((node->super == NULL) && (!Q_stricmp(node->superclass, this->classname))
|
|
&& (Q_stricmp(node->classname, "Class"))) {
|
|
node->super = this;
|
|
}
|
|
}
|
|
|
|
// Add to front of list
|
|
LL_AddFirst(classlist, this, prev, next);
|
|
|
|
numclasses++;
|
|
}
|
|
|
|
ClassDef::~ClassDef()
|
|
{
|
|
ClassDef *node;
|
|
|
|
if (classlist != this) {
|
|
LL_Remove(this, prev, next);
|
|
|
|
// Check if any subclasses were initialized before their superclass
|
|
for (node = classlist->next; node != classlist; node = node->next) {
|
|
if (node->super == this) {
|
|
node->super = NULL;
|
|
}
|
|
}
|
|
} else {
|
|
// If the head of the list is deleted before the list is cleared, then we may have problems
|
|
assert(this->next == this->prev);
|
|
}
|
|
|
|
if (responseLookup) {
|
|
delete[] responseLookup;
|
|
responseLookup = NULL;
|
|
}
|
|
}
|
|
|
|
#ifdef WITH_SCRIPT_ENGINE
|
|
|
|
void ClassDef::AddWaitTill(str s)
|
|
{
|
|
return AddWaitTill(Director.AddString(s));
|
|
}
|
|
|
|
void ClassDef::AddWaitTill(const_str s)
|
|
{
|
|
if (!waitTillSet) {
|
|
waitTillSet = new con_set<const_str, const_str>;
|
|
}
|
|
|
|
waitTillSet->addKeyValue(s) = s;
|
|
}
|
|
|
|
void ClassDef::RemoveWaitTill(str s)
|
|
{
|
|
return RemoveWaitTill(Director.AddString(s));
|
|
}
|
|
|
|
void ClassDef::RemoveWaitTill(const_str s)
|
|
{
|
|
if (waitTillSet) {
|
|
waitTillSet->remove(s);
|
|
}
|
|
}
|
|
|
|
bool ClassDef::WaitTillDefined(str s)
|
|
{
|
|
return WaitTillDefined(Director.AddString(s));
|
|
}
|
|
|
|
bool ClassDef::WaitTillDefined(const_str s)
|
|
{
|
|
if (!waitTillSet) {
|
|
return false;
|
|
}
|
|
|
|
return waitTillSet->findKeyValue(s) != NULL;
|
|
}
|
|
|
|
#endif
|
|
|
|
EventDef *ClassDef::GetDef(int eventnum)
|
|
{
|
|
ResponseDef<Class> *r = responseLookup[eventnum];
|
|
|
|
if (r) {
|
|
return r->def;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
int ClassDef::GetFlags(Event *event)
|
|
{
|
|
EventDef *def = GetDef(event->eventnum);
|
|
|
|
if (def) {
|
|
return def->flags;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void ClassDef::BuildResponseList(void)
|
|
{
|
|
ClassDef *c;
|
|
ResponseDef<Class> *r;
|
|
int ev;
|
|
int i;
|
|
qboolean *set;
|
|
int num;
|
|
|
|
if (responseLookup) {
|
|
delete[] responseLookup;
|
|
responseLookup = NULL;
|
|
}
|
|
|
|
num = Event::NumEventCommands(
|
|
); //size will be total event count, because it WAS faster to look for an event via eventnum
|
|
//nowadays there's not much overhead in performance, TODO: change size to appropriate.
|
|
responseLookup = (ResponseDef<Class> **)new char[sizeof(ResponseDef<Class> *) * num];
|
|
memset(responseLookup, 0, sizeof(ResponseDef<Class> *) * num);
|
|
|
|
set = new qboolean[num];
|
|
memset(set, 0, sizeof(qboolean) * num);
|
|
|
|
this->numEvents = num;
|
|
|
|
for (c = this; c != NULL; c = c->super) {
|
|
r = c->responses;
|
|
|
|
if (r) {
|
|
for (i = 0; r[i].event != NULL; i++) {
|
|
ev = (int)r[i].event->eventnum;
|
|
r[i].def = r[i].event->getInfo();
|
|
|
|
if (!set[ev]) {
|
|
set[ev] = true;
|
|
|
|
if (r[i].response) {
|
|
responseLookup[ev] = &r[i];
|
|
} else {
|
|
responseLookup[ev] = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete[] set;
|
|
}
|
|
|
|
void ClassDef::BuildEventResponses(void)
|
|
{
|
|
ClassDef *c;
|
|
int amount;
|
|
int numclasses;
|
|
|
|
amount = 0;
|
|
numclasses = 0;
|
|
|
|
for (c = classlist->next; c != classlist; c = c->next) {
|
|
c->BuildResponseList();
|
|
|
|
amount += c->numEvents * sizeof(Response *);
|
|
numclasses++;
|
|
}
|
|
|
|
CLASS_DPrintf(
|
|
"\n------------------\nEvent system initialized: "
|
|
"%d classes %d events %d total memory in response list\n\n",
|
|
numclasses,
|
|
Event::NumEventCommands(),
|
|
amount
|
|
);
|
|
}
|
|
|
|
const char *Class::getClassID(void) const
|
|
{
|
|
return classinfo()->classID;
|
|
}
|
|
|
|
const char *Class::getClassname(void) const
|
|
{
|
|
return classinfo()->classname;
|
|
}
|
|
|
|
const char *Class::getSuperclass(void) const
|
|
{
|
|
return classinfo()->superclass;
|
|
}
|
|
|
|
#define MAX_INHERITANCE 64
|
|
|
|
void ClassEvents(const char *classname, qboolean print_to_disk)
|
|
{
|
|
ClassDef *c;
|
|
ResponseDef<Class> *r;
|
|
int ev;
|
|
int i, j;
|
|
qboolean *set;
|
|
int num, orderNum;
|
|
Event **events;
|
|
byte *order;
|
|
FILE *class_file;
|
|
str classNames[MAX_INHERITANCE];
|
|
str class_filename;
|
|
|
|
c = getClass(classname);
|
|
if (!c) {
|
|
CLASS_DPrintf("Unknown class: %s\n", classname);
|
|
return;
|
|
}
|
|
|
|
class_file = NULL;
|
|
|
|
if (print_to_disk) {
|
|
class_filename = str(classname) + ".txt";
|
|
class_file = fopen(class_filename.c_str(), "w");
|
|
if (class_file == NULL) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
num = Event::NumEventCommands();
|
|
|
|
set = new qboolean[num];
|
|
memset(set, 0, sizeof(qboolean) * num);
|
|
|
|
events = new Event *[num];
|
|
memset(events, 0, sizeof(Event *) * num);
|
|
|
|
order = new byte[num];
|
|
memset(order, 0, sizeof(byte) * num);
|
|
|
|
orderNum = 0;
|
|
for (; c != NULL; c = c->super) {
|
|
if (orderNum < MAX_INHERITANCE) {
|
|
classNames[orderNum] = c->classname;
|
|
}
|
|
r = c->responses;
|
|
if (r) {
|
|
for (i = 0; r[i].event != NULL; i++) {
|
|
ev = (int)r[i].event->eventnum;
|
|
if (!set[ev]) {
|
|
set[ev] = true;
|
|
|
|
if (r[i].response) {
|
|
events[ev] = r[i].event;
|
|
order[ev] = orderNum;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
orderNum++;
|
|
}
|
|
|
|
CLASS_Print(class_file, "********************************************************\n");
|
|
CLASS_Print(class_file, "********************************************************\n");
|
|
CLASS_Print(class_file, "* All Events For Class: %s\n", classname);
|
|
CLASS_Print(class_file, "********************************************************\n");
|
|
CLASS_Print(class_file, "********************************************************\n\n");
|
|
|
|
for (j = orderNum - 1; j >= 0; j--) {
|
|
CLASS_Print(class_file, "\n********************************************************\n");
|
|
CLASS_Print(class_file, "* Class: %s\n", classNames[j].c_str());
|
|
CLASS_Print(class_file, "********************************************************\n\n");
|
|
for (i = 1; i < num; i++) {
|
|
int index;
|
|
|
|
index = ClassDef::sortedList.ObjectAt(i);
|
|
if (events[index] && (order[index] == j)) {
|
|
Event::eventDefList[events[index]].PrintEventDocumentation(class_file, qfalse);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (class_file != NULL) {
|
|
CLASS_DPrintf("Printed class info to file %s\n", class_filename.c_str());
|
|
fclose(class_file);
|
|
}
|
|
|
|
delete[] events;
|
|
delete[] order;
|
|
delete[] set;
|
|
}
|
|
|
|
void DumpClass(FILE *class_file, const char *className)
|
|
{
|
|
ClassDef *c;
|
|
ResponseDef<Class> *r;
|
|
int ev;
|
|
int i;
|
|
int num, num2;
|
|
Event **events;
|
|
|
|
c = getClass(className);
|
|
if (!c) {
|
|
return;
|
|
}
|
|
|
|
num = Event::commandList.size();
|
|
num2 = Event::NumEventCommands();
|
|
|
|
events = new Event *[num2];
|
|
memset(events, 0, sizeof(Event *) * num2);
|
|
|
|
// gather event responses for this class
|
|
r = c->responses;
|
|
if (r) {
|
|
for (i = 0; r[i].event != NULL; i++) {
|
|
ev = (int)r[i].event->eventnum;
|
|
if (r[i].response) {
|
|
events[ev] = r[i].event;
|
|
}
|
|
}
|
|
}
|
|
|
|
CLASS_Print(class_file, "\n");
|
|
if (c->classID[0]) {
|
|
CLASS_Print(class_file, "<h2> <a name=\"%s\">%s (<i>%s</i>)</a>", c->classname, c->classname, c->classID);
|
|
} else {
|
|
CLASS_Print(class_file, "<h2> <a name=\"%s\">%s</a>", c->classname, c->classname);
|
|
}
|
|
|
|
// print out lineage
|
|
for (c = c->super; c != NULL; c = c->super) {
|
|
CLASS_Print(class_file, " -> <a href=\"#%s\">%s</a>", c->classname, c->classname);
|
|
}
|
|
CLASS_Print(class_file, "</h2>\n");
|
|
|
|
ClassDef::dump_numclasses++;
|
|
|
|
CLASS_Print(class_file, "<BLOCKQUOTE>\n");
|
|
for (i = 1; i < num; i++) {
|
|
int index;
|
|
|
|
index = ClassDef::sortedList.ObjectAt(i);
|
|
if (events[index]) {
|
|
Event::eventDefList[events[index]].PrintEventDocumentation(class_file, qtrue);
|
|
ClassDef::dump_numevents++;
|
|
}
|
|
}
|
|
CLASS_Print(class_file, "</BLOCKQUOTE>\n");
|
|
delete[] events;
|
|
}
|
|
|
|
#define MAX_CLASSES 1024
|
|
|
|
void DumpAllClasses(void)
|
|
{
|
|
int i, num;
|
|
ClassDef *c;
|
|
FILE *class_file;
|
|
str class_filename;
|
|
str class_title;
|
|
str classes[MAX_CLASSES];
|
|
|
|
#if defined(GAME_DLL)
|
|
class_filename = "g_allclasses.html";
|
|
class_title = "Game Module";
|
|
#elif defined(CGAME_DLL)
|
|
class_filename = "cg_allclasses.html";
|
|
class_title = "Client Game Module";
|
|
#else
|
|
class_filename = "cl_allclasses.html";
|
|
class_title = "Client Module";
|
|
#endif
|
|
|
|
class_file = fopen(class_filename.c_str(), "w");
|
|
if (class_file == NULL) {
|
|
return;
|
|
}
|
|
|
|
// construct the HTML header for the document
|
|
CLASS_Print(class_file, "<HTML>\n");
|
|
CLASS_Print(class_file, "<HEAD>\n");
|
|
CLASS_Print(class_file, "<Title>%s Classes</Title>\n", class_title.c_str());
|
|
CLASS_Print(class_file, "</HEAD>\n");
|
|
CLASS_Print(class_file, "<BODY>\n");
|
|
CLASS_Print(class_file, "<H1>\n");
|
|
CLASS_Print(class_file, "<center>%s Classes</center>\n", class_title.c_str());
|
|
CLASS_Print(class_file, "</H1>\n");
|
|
#if defined(GAME_DLL)
|
|
//
|
|
// print out some commonly used classnames
|
|
//
|
|
CLASS_Print(class_file, "<h2>");
|
|
CLASS_Print(class_file, "<a href=\"#Actor\">Actor</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#Animate\">Animate</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#Entity\">Entity</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#ScriptSlave\">ScriptSlave</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#ScriptThread\">ScriptThread</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#Sentient\">Sentient</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#StateMap\">StateMap</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#Trigger\">Trigger</a>, ");
|
|
CLASS_Print(class_file, "<a href=\"#World\">World</a>");
|
|
CLASS_Print(class_file, "</h2>");
|
|
#endif
|
|
|
|
ClassDef::dump_numclasses = 0;
|
|
ClassDef::dump_numevents = 0;
|
|
|
|
ClassDef::sortedList.ClearObjectList();
|
|
ClassDef::sortedClassList.ClearObjectList();
|
|
|
|
Event::SortEventList(&ClassDef::sortedList);
|
|
ClassDef::SortClassList(&ClassDef::sortedClassList);
|
|
|
|
num = ClassDef::sortedClassList.NumObjects();
|
|
|
|
// go through and process each class from smallest to greatest
|
|
for (i = 1; i <= num; i++) {
|
|
c = ClassDef::sortedClassList.ObjectAt(i);
|
|
DumpClass(class_file, c->classname);
|
|
}
|
|
|
|
if (class_file != NULL) {
|
|
CLASS_Print(class_file, "<H2>\n");
|
|
CLASS_Print(
|
|
class_file,
|
|
"%d %s Classes.<BR>%d %s Events.\n",
|
|
ClassDef::dump_numclasses,
|
|
class_title.c_str(),
|
|
ClassDef::dump_numevents,
|
|
class_title.c_str()
|
|
);
|
|
CLASS_Print(class_file, "</H2>\n");
|
|
CLASS_Print(class_file, "</BODY>\n");
|
|
CLASS_Print(class_file, "</HTML>\n");
|
|
CLASS_DPrintf("Dumped all classes to file %s\n", class_filename.c_str());
|
|
fclose(class_file);
|
|
}
|
|
}
|
|
|
|
qboolean Class::inheritsFrom(ClassDef *c) const
|
|
{
|
|
return checkInheritance(c, classinfo());
|
|
}
|
|
|
|
qboolean Class::inheritsFrom(const char *name) const
|
|
{
|
|
ClassDef *c;
|
|
|
|
c = getClass(name);
|
|
|
|
if (c == NULL) {
|
|
CLASS_Printf("Unknown class: %s\n", name);
|
|
return false;
|
|
}
|
|
|
|
return checkInheritance(c, classinfo());
|
|
}
|
|
|
|
qboolean Class::isInheritedBy(const char *name) const
|
|
{
|
|
ClassDef *c;
|
|
|
|
c = getClass(name);
|
|
|
|
if (c == NULL) {
|
|
CLASS_DPrintf("Unknown class: %s\n", name);
|
|
return false;
|
|
}
|
|
|
|
return checkInheritance(classinfo(), c);
|
|
}
|
|
|
|
qboolean Class::isInheritedBy(ClassDef *c) const
|
|
{
|
|
return checkInheritance(classinfo(), c);
|
|
}
|
|
|
|
ClassDefHook::ClassDefHook()
|
|
{
|
|
this->classdef = NULL;
|
|
}
|
|
|
|
ClassDef
|
|
Class::ClassInfo("Class", NULL, NULL, (ResponseDef<Class> *)Class::Responses, Class::_newInstance, sizeof(Class));
|
|
|
|
void *Class::_newInstance(void)
|
|
{
|
|
return new Class();
|
|
}
|
|
|
|
ClassDef *Class::classinfo(void) const
|
|
{
|
|
return &(Class::ClassInfo);
|
|
}
|
|
|
|
ClassDef *Class::classinfostatic(void)
|
|
{
|
|
return &(Class::ClassInfo);
|
|
}
|
|
|
|
ResponseDef<Class> Class::Responses[] = {
|
|
{NULL, NULL}
|
|
}; |