1

/* $Id$ */

     2

     3

/** @file ai_info.cpp Implementation of AIFileInfo */

     4

     5

#include "../stdafx.h"

     6

#include "../core/alloc_func.hpp"

     7

     8

#include <squirrel.h>

     9

#include "../squirrel.hpp"

    10

#include "../squirrel_helper.hpp"

    11

#include "../squirrel_class.hpp"

    12

#include "../squirrel_std.hpp"

    13

#include "ai.h"

    14

#include "ai_info.hpp"

    15

#include "ai_squirrel.hpp"

    16

#include "api/ai_controller.hpp"

    17

    18

AIFileInfo::~AIFileInfo()

    19

{

    20

	this->engine->ReleaseObject(this->SQ_instance);

    21

	free((void *)this->author);

    22

	free((void *)this->name);

    23

	free((void *)this->description);

    24

	free((void *)this->date);

    25

	free((void *)this->instance_name);

    26

	free(this->script_name);

    27

	free(this->dir_name);

    28

	free(this->SQ_instance);

    29

}

    30

    31

const char *AIFileInfo::GetAuthor()

    32

{

    33

	if (this->author == NULL) this->author = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetAuthor");

    34

	return this->author;

    35

}

    36

    37

const char *AIFileInfo::GetName()

    38

{

    39

	if (this->name == NULL) this->name = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetName");

    40

	return this->name;

    41

}

    42

    43

const char *AIFileInfo::GetDescription()

    44

{

    45

	if (this->description == NULL) this->description = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetDescription");

    46

	return this->description;

    47

}

    48

    49

int AIFileInfo::GetVersion()

    50

{

    51

	return this->engine->CallIntegerMethod(*this->SQ_instance, "GetVersion");

    52

}

    53

    54

const char *AIFileInfo::GetDate()

    55

{

    56

	if (this->date == NULL) this->date = this->engine->CallStringMethodStrdup(*this->SQ_instance, "GetDate");

    57

	return this->date;

    58

}

    59

    60

const char *AIFileInfo::GetInstanceName()

    61

{

    62

	if (this->instance_name == NULL) this->instance_name = this->engine->CallStringMethodStrdup(*this->SQ_instance, "CreateInstance");

    63

	return this->instance_name;

    64

}

    65

    66

bool AIFileInfo::AllowStartup()

    67

{

    68

	return true;

    69

}

    70

    71

AIController *AIFileInfo::CreateInstance()

    72

{

    73

	AIController *ai_controller = new AIController(this->script_name, this->GetInstanceName());

    74

	return ai_controller;

    75

}

    76

    77

const char *AIFileInfo::GetDirName()

    78

{

    79

	return this->dir_name;

    80

}

    81

    82

const char *AIFileInfo::GetScriptName()

    83

{

    84

	return this->script_name;

    85

}

    86

    87

void AIFileInfo::CheckMethods(SQInteger *res, const char *name)

    88

{

    89

	if (!this->engine->MethodExists(*this->SQ_instance, name)) {

    90

		char error[1024];

    91

		snprintf(error, sizeof(error), "your AIFileInfo doesn't have the method '%s'", name);

    92

		this->engine->ThrowError(error);

    93

		*res = SQ_ERROR;

    94

	}

    95

}

    96

    97

/* static */ SQInteger AIFileInfo::Constructor(HSQUIRRELVM vm, AIFileInfo *info)

    98

{

    99

	SQInteger res = 0;

   100

   101

	/* Set some basic info from the parent */

   102

	info->SQ_instance = MallocT<SQObject>(sizeof(SQObject));

   103

	Squirrel::GetInstance(vm, info->SQ_instance, 2);

   104

	/* Make sure the instance stays alive over time */

   105

	sq_addref(vm, info->SQ_instance);

   106

	info->base = ((AISquirrel *)Squirrel::GetGlobalPointer(vm));

   107

	info->engine = info->base->GetEngine();

   108

   109

	/* Check if all needed fields are there */

   110

	info->CheckMethods(&res, "GetAuthor");

   111

	info->CheckMethods(&res, "GetName");

   112

	info->CheckMethods(&res, "GetDescription");

   113

	info->CheckMethods(&res, "GetVersion");

   114

	info->CheckMethods(&res, "GetDate");

   115

	info->CheckMethods(&res, "CreateInstance");

   116

   117

	/* Abort if one method was missing */

   118

	if (res != 0) return res;

   119

   120

	info->script_name = strdup(info->base->GetCurrentScript());

   121

	info->dir_name = strdup(info->base->GetCurrentDirName());

   122

   123

	return 0;

   124

}

   125

   126

/* static */ SQInteger AIInfo::Constructor(HSQUIRRELVM vm)

   127

{

   128

	/* Create a new AIFileInfo */

   129

	AIInfo *info = new AIInfo();

   130

   131

	SQInteger res = AIFileInfo::Constructor(vm, info);

   132

	if (res != 0) return res;

   133

   134

	/* Register the AI to the base system */

   135

	info->base->RegisterAI(info);

   136

   137

	return 0;

   138

}

   139

   140

/* static */ SQInteger AILibrary::Constructor(HSQUIRRELVM vm)

   141

{

   142

	/* Create a new AIFileInfo */

   143

	AILibrary *library = new AILibrary();

   144

   145

	SQInteger res = AIFileInfo::Constructor(vm, library);

   146

	if (res != 0) return res;

   147

   148

	/* Register the Library to the base system */

   149

	library->base->RegisterLibrary(library);

   150

   151

	return 0;

   152

}

   153

   154

/* static */ SQInteger AILibrary::Import(HSQUIRRELVM vm)

   155

{

   156

	SQConvert::SQAutoFreePointers ptr;

   157

	const char *library = GetParam(SQConvert::ForceType<const char *>(), vm, 2, &ptr);

   158

	const char *class_name = GetParam(SQConvert::ForceType<const char *>(), vm, 3, &ptr);

   159

	int version = GetParam(SQConvert::ForceType<int>(), vm, 4, &ptr);

   160

   161

	if (!AI_ImportLibrary(library, class_name, version, vm)) return -1;

   163

}