bool Player::setIntByHash(uint16_t propHash, LevelObjValue value, const Level* level) noexcept
{
switch (propHash)
{
case str2int16("strength"):
strength = std::clamp(value, 0, Class()->MaxStrength());
break;
case str2int16("magic"):
magic = std::clamp(value, 0, Class()->MaxMagic());
break;
case str2int16("dexterity"):
dexterity = std::clamp(value, 0, Class()->MaxDexterity());
break;
case str2int16("vitality"):
vitality = std::clamp(value, 0, Class()->MaxVitality());
break;
case str2int16("lifeDamage"):
lifeDamage = std::max(value, 0);
break;
case str2int16("manaDamage"):
manaDamage = std::max(value, 0);
break;
default:
return false;
}
updateNameAndDescr = true;
return true;
}
Variable environment_variable_get(Scope* scope, Variable variable){
for(unsigned int v = 0; v < scope->variables.size(); v++){
if( (scope->variables[v].name == variable.name or variable.name==IGNORE)
and (scope->variables[v].type.name == variable.type.name or variable.type.name==IGNORE)){
return scope->variables[v];
}
}
if(scope->parent == NULL){
#ifdef DEV_ERRORS
fail(DEV_BLANK_TYPE);
#endif // DEV_ERRORS
return Variable("", Class(), false, false);
}
if(environment_variable_exists(scope->parent, variable)){
return environment_variable_get(scope->parent, variable);
}
#ifdef DEV_ERRORS
fail(DEV_BLANK_TYPE);
#endif // DEV_ERRORS
return Variable("", Class(), false, false);
}
void connectPrereqsToTargets(const std::string & s, Graph & g) {
auto it = s.begin();
std::set<Class>::iterator targetIt;
while (it != s.end()) {
if (*it == ':') {
std::string target(s.begin(), it);
targetIt = g.classes.find(Class(target));
assert(targetIt != g.classes.end());
++it;
break;
}
++it;
}
while (it != s.end()) {
++it;
auto endit = it;
while (endit != s.end() && *endit != ' ') { ++endit; }
std::string prereq(std::string(it, endit));
std::set<Class>::iterator prereqIt =
g.classes.find(Class(prereq));
assert(prereqIt != g.classes.end());
g.connect(targetIt, prereqIt);
it = endit;
}
}
static at *call_method(at *obj, struct hashelem *hx, at *args)
{
at *fun = hx->function;
assert(FUNCTIONP(fun));
if (Class(fun) == de_class) {
// DE
at *p = eval_arglist(args);
return with_object(obj, fun, p, hx->sofar);
} else if (Class(fun) == df_class) {
// DF
return with_object(obj, fun, args, hx->sofar);
} else if (Class(fun) == dm_class) {
// DM
at *p = new_cons(new_cons(fun, args), NIL);
at *q = with_object(obj, at_mexpand, p, hx->sofar);
return eval(q);
} else {
// DX, DY, DH
at *p = new_cons(fun, new_cons(obj, args));
return Class(fun)->listeval(fun, p);
}
}
void lush_delete(at *p)
{
if (!p || ZOMBIEP(p))
return;
class_t *cl = classof(p);
if (cl->dontdelete)
error(NIL, "cannot delete this object", p);
run_notifiers(p);
if (cl->has_compiled_part) {
assert(isa(p, object_class));
/* OO objects may have two parts */
/* lush_delete has to delete both of them */
object_t *obj = Mptr(p);
struct CClass_object *cobj = obj->cptr;
oostruct_dispose(obj);
cobj->Vtbl->Cdestroy(cobj);
} else {
if (Class(p)->dispose)
Mptr(p) = Class(p)->dispose(Mptr(p));
else
Mptr(p) = NULL;
}
zombify(p);
}
bool Player::hasMaxStats() const noexcept
{
return (strength >= Class()->MaxStrength() &&
magic >= Class()->MaxMagic() &&
dexterity >= Class()->MaxDexterity() &&
vitality >= Class()->MaxVitality());
}
Header* Header_new(ProcessList* pl) {
Header* this = calloc(1, sizeof(Header));
this->leftMeters = Vector_new(Class(Meter), true, DEFAULT_SIZE);
this->rightMeters = Vector_new(Class(Meter), true, DEFAULT_SIZE);
this->margin = true;
this->pl = pl;
return this;
}
/* interface calling into the fortran routine */
static int lbfgs(index_t *x0, at *f, at *g, double gtol, htable_t *p, at *vargs)
{
/* argument checking and setup */
extern void lbfgs_(int *n, int *m, double *x, double *fval, double *gval, \
int *diagco, double *diag, int iprint[2], double *gtol, \
double *xtol, double *w, int *iflag);
ifn (IND_STTYPE(x0) == ST_DOUBLE)
error(NIL, "not an array of doubles", x0->backptr);
ifn (Class(f)->listeval)
error(NIL, "not a function", f);
ifn (Class(f)->listeval)
error(NIL, "not a function", g);
ifn (gtol > 0)
error(NIL, "threshold value not positive", NEW_NUMBER(gtol));
at *gx = copy_array(x0)->backptr;
at *(*listeval_f)(at *, at *) = Class(f)->listeval;
at *(*listeval_g)(at *, at *) = Class(g)->listeval;
at *callf = new_cons(f, new_cons(x0->backptr, vargs));
at *callg = new_cons(g, new_cons(gx, new_cons(x0->backptr, vargs)));
htable_t *params = lbfgs_params();
if (p) htable_update(params, p);
int iprint[2];
iprint[0] = (int)Number(htable_get(params, NEW_SYMBOL("iprint-1")));
iprint[1] = (int)Number(htable_get(params, NEW_SYMBOL("iprint-2")));
lb3_.gtol = Number(htable_get(params, NEW_SYMBOL("ls-gtol")));
lb3_.stpmin = Number(htable_get(params, NEW_SYMBOL("ls-stpmin")));
lb3_.stpmax = Number(htable_get(params, NEW_SYMBOL("ls-stpmax")));
int m = (int)Number(htable_get(params, NEW_SYMBOL("lbfgs-m")));
int n = index_nelems(x0);
double *x = IND_ST(x0)->data;
double fval;
double *gval = IND_ST(Mptr(gx))->data;
int diagco = false;
double *diag = mm_blob(n*sizeof(double));
double *w = mm_blob((n*(m+m+1)+m+m)*sizeof(double));
double xtol = eps(1); /* machine precision */
int iflag = 0;
ifn (n>0)
error(NIL, "empty array", x0->backptr);
ifn (m>0)
error(NIL, "m-parameter must be positive", NEW_NUMBER(m));
/* reverse communication loop */
do {
fval = Number(listeval_f(Car(callf), callf));
listeval_g(Car(callg), callg);
lbfgs_(&n, &m, x, &fval, gval, &diagco, diag, iprint, >ol, &xtol, w, &iflag);
assert(iflag<2);
} while (iflag > 0);
return iflag;
}
static const char *generic_name(at *p)
{
if (Class(p)->classname)
sprintf(string_buffer, "::%s:%p", NAMEOF(Class(p)->classname),Mptr(p));
else
sprintf(string_buffer, "::%p:%p", Class(p), Mptr(p));
return mm_strdup(string_buffer);
}
bool environment_generic_method_exists(TokenContext context, Scope* scope, Method method, Class actual_class, Class generic_class){
for(size_t i = 0; i < scope->methods.size(); i++){
if( (scope->methods[i].name == method.name or method.name==IGNORE)
and (scope->methods[i].parent == method.parent or method.parent==NULL)
and (context_class_compare(context, Class(scope->methods[i].return_type), Class(method.return_type)) or method.return_type == IGNORE_CLASS)
and (generic_arguments_equal(context, scope->methods[i].arguments, method.arguments, actual_class, generic_class))){
return true;
}
}
return false;
}
/* linux driver says the release id is not always right */
static int
heuristicid(uint32_t csp, uint32_t maxpkt)
{
if(Class(csp) == 0x02)
return TypeH;
else if(maxpkt == 0x40)
return TypeHX;
else if(Class(csp) == 0x00 || Class(csp) == 0xFF)
return TypeH;
else{
fprint(2, "serial: chip unknown, setting to HX version\n");
return TypeHX;
}
}
void Component::classes(void){
class_(Component::StencilType, Class(
"Stencil",
Stencil::page,
Stencil::request,
Stencil::call
));
class_(Component::ThemeType, Class(
"Theme",
Theme::page,
nullptr,
Theme::call
));
}
Method environment_method_get(TokenContext context, Scope* scope, Method method){
for(size_t i = 0; i < scope->methods.size(); i++){
if( (scope->methods[i].name == method.name or method.name==IGNORE)
and (scope->methods[i].parent == method.parent or method.parent==NULL)
and (context_class_compare(context, Class(scope->methods[i].return_type), Class(method.return_type)) or method.return_type == IGNORE_CLASS)
and (arguments_equal(context, scope->methods[i].arguments, method.arguments))){
return scope->methods[i];
}
}
#ifdef DEV_ERRORS
fail(DEV_BLANK_TYPE);
#endif // DEV_ERRORS
return Method{"", NULL, IGNORE_ARGS, IGNORE_CLASS};
}
Variable::Variable(){
name = "";
type = Class("");
is_final = false;
is_static = false;
is_private = false;
}
void CCameraIO::FilterSet( short Slot )
{
// Determine how far we have to move
int Pos = Slot - m_FilterPosition;
if (Pos < 0) Pos += NUM_POSITIONS;
HANDLE hProcess(0);
DWORD Class(0);
if ( m_HighPriority )
{ // Store current process class and priority
hProcess = GetCurrentProcess();
Class = GetPriorityClass ( hProcess );
SetPriorityClass ( hProcess, REALTIME_PRIORITY_CLASS );
}
for (int I = 0; I < Pos; I++)
{
// Advance one position
for (int J = 0; J < NUM_STEPS_PER_FILTER; J++)
{
m_FilterStepPos += 1;
if (m_FilterStepPos >= NUM_STEPS) m_FilterStepPos = 0;
unsigned char Step = Steps[ m_FilterStepPos ];
AuxOutput( Step );
Sleep ( STEP_DELAY );
}
}
if ( m_HighPriority ) SetPriorityClass ( hProcess, Class );
m_FilterPosition = Slot;
}
aConfItem *make_conf(void)
{
Reg aConfItem *aconf;
aconf = (struct ConfItem *)MyMalloc(sizeof(aConfItem));
#ifdef DEBUGMODE
aconfs.inuse++;
#endif
istat.is_conf++;
istat.is_confmem += sizeof(aConfItem);
bzero((char *)&aconf->ipnum, sizeof(struct IN_ADDR));
aconf->clients = aconf->port = 0;
aconf->next = NULL;
aconf->host = aconf->passwd = aconf->name = aconf->name2 = NULL;
#ifdef XLINE
aconf->name3 = NULL;
#endif
aconf->ping = NULL;
aconf->status = CONF_ILLEGAL;
aconf->pref = -1;
aconf->hold = time(NULL);
aconf->source_ip = NULL;
aconf->flags = 0L;
Class(aconf) = NULL;
return (aconf);
}
/* similar to lush_delete, but don't raise error with permanent objects */
void lush_delete_maybe(at *p)
{
if (p) {
if (!Class(p)->dontdelete)
lush_delete(p);
}
}
JSBool
pango::JSContext::Constructor(::JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {
DOC_BEGIN("");
DOC_END;
if (JSA_GetClass(cx,obj) != Class()) {
JS_ReportError(cx,"Constructor for %s bad object; did you forget a 'new'?",ClassName());
return JS_FALSE;
}
pango::JSContext * myNewObject = 0;
NATIVE * newNative = 0;
if (argc == 0) {
PangoContext * myContext = pango_context_new();
newNative = new NATIVE(myContext, false);
} else {
JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected none () %d",ClassName(), argc);
return JS_FALSE;
}
myNewObject = new pango::JSContext(OWNERPTR(newNative), newNative);
if (myNewObject) {
JS_SetPrivate(cx,obj,myNewObject);
return JS_TRUE;
}
JS_ReportError(cx,"pango::JSContext::Constructor: bad parameters");
return JS_FALSE;
}
void Player::updateNameAndDescriptions() const
{
if (updateNameAndDescr == true)
{
updateNameAndDescr = false;
if (Class()->getFullName(*this, name) == false &&
name.empty() == true)
{
name = SimpleName();
}
for (size_t i = 0; i < descriptions.size(); i++)
{
Class()->getDescription(i, *this, descriptions[i]);
}
}
}
bool Player::setItem(size_t invIdx, size_t itemIdx, std::unique_ptr<Item>& item,
std::unique_ptr<Item>& oldItem)
{
if (invIdx >= inventories.size())
{
return false;
}
auto itemPtr = item.get();
auto& inventory = inventories[invIdx];
auto ret = inventory.set(itemIdx, item, oldItem);
if (ret == true)
{
if (itemPtr != nullptr)
{
updateItemQuantityCache(itemPtr->Class()->IdHash16());
itemPtr->clearMapPosition();
itemPtr->updateOwner(this);
}
else if (oldItem != nullptr)
{
updateItemQuantityCache(oldItem->Class()->IdHash16());
oldItem->updateOwner(nullptr);
}
if (bodyInventoryIdx == invIdx)
{
updateProperties();
}
}
return ret;
}
void UnsupportedProcess_delete(Object* cast) {
Process* this = (Process*) cast;
Object_setClass(this, Class(Process));
Process_done((Process*)cast);
// free platform-specific fields here
free(this);
}
JSBool
JSColorSelectionDialog::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {
DOC_BEGIN("");
DOC_END;
ensureParamCount(argc,1,5);
if (JSA_GetClass(cx,obj) != Class()) {
JS_ReportError(cx,"Constructor for %s bad object; did you forget a 'new'?",ClassName());
return JS_FALSE;
}
NATIVE * newNative = 0;
JSColorSelectionDialog * myNewObject = 0;
if ( argc == 1) {
string myTitle;
convertFrom(cx, argv[0], myTitle);
newNative = new NATIVE(myTitle);
} else {
newNative = new NATIVE();
}
myNewObject = new JSColorSelectionDialog(OWNERPTR(newNative), newNative);
if (myNewObject) {
JS_SetPrivate(cx,obj,myNewObject);
return JS_TRUE;
}
JS_ReportError(cx,"JSColorSelectionDialog::Constructor: failed");
return JS_FALSE;
}
void CBaseObject::Allocate(CObjects* pcObjects)
{
mpcObjectsThisIn = pcObjects;
SetFlag(OBJECT_FLAGS_CALLED_ALLOCATE, TRUE);
Class();
SetDistToStack(UNKNOWN_DIST_TO_STACK);
}
JSBool
JSCheckButton::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {
DOC_BEGIN("");
DOC_END;
if (JSA_GetClass(cx,obj) != Class()) {
JS_ReportError(cx,"Constructor for %s bad object; did you forget a 'new'?",ClassName());
return JS_FALSE;
}
NATIVE * newNative = 0;
JSCheckButton * myNewObject = 0;
if (argc == 0) {
newNative = new Gtk::CheckButton();
} else if (argc == 1) {
Glib::ustring myLabel;
convertFrom(cx, argv[0], myLabel);
newNative = new Gtk::CheckButton(myLabel);
} else {
JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected none () %d",ClassName(), argc);
return JS_FALSE;
}
myNewObject = new JSCheckButton(OWNERPTR(newNative), newNative);
if (myNewObject) {
JS_SetPrivate(cx,obj,myNewObject);
return JS_TRUE;
}
JS_ReportError(cx,"JSCheckButton::Constructor: bad parameters");
return JS_FALSE;
}
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList, uid_t userId) {
int mib[] = { CTL_HW, HW_NCPU };
int fmib[] = { CTL_KERN, KERN_FSCALE };
int i, e;
OpenBSDProcessList* opl = calloc(1, sizeof(OpenBSDProcessList));
ProcessList* pl = (ProcessList*) opl;
size_t size = sizeof(pl->cpuCount);
ProcessList_init(pl, Class(OpenBSDProcess), usersTable, pidWhiteList, userId);
e = sysctl(mib, 2, &pl->cpuCount, &size, NULL, 0);
if (e == -1 || pl->cpuCount < 1) {
pl->cpuCount = 1;
}
opl->cpus = realloc(opl->cpus, pl->cpuCount * sizeof(CPUData));
size = sizeof(fscale);
if (sysctl(fmib, 2, &fscale, &size, NULL, 0) < 0)
err(1, "fscale sysctl call failed");
for (i = 0; i < pl->cpuCount; i++) {
opl->cpus[i].totalTime = 1;
opl->cpus[i].totalPeriod = 1;
}
pageSizeKb = PAGE_SIZE_KB;
// XXX: last arg should eventually be an errbuf
opl->kd = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, NULL);
assert(opl->kd);
return pl;
}
JSBool
JSMisc::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {
DOC_BEGIN("");
DOC_END;
if (JSA_GetClass(cx,obj) != Class()) {
JS_ReportError(cx,"Constructor for %s bad object; did you forget a 'new'?",ClassName());
return JS_FALSE;
}
NATIVE * newNative = 0;
JSMisc * myNewObject = 0;
if (argc == 0) {
newNative = 0; // Abstract
myNewObject = new JSMisc(OWNERPTR(newNative), newNative);
} else {
JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected none () %d",ClassName(), argc);
return JS_FALSE;
}
if (myNewObject) {
JS_SetPrivate(cx,obj,myNewObject);
return JS_TRUE;
}
JS_ReportError(cx,"JSMisc::Constructor: bad parameters");
return JS_FALSE;
}
Panel* Panel_new(int x, int y, int w, int h, bool owner, ObjectClass* type, FunctionBar* fuBar) {
Panel* this;
this = xMalloc(sizeof(Panel));
Object_setClass(this, Class(Panel));
Panel_init(this, x, y, w, h, type, owner, fuBar);
return this;
}
AvailableMetersPanel* AvailableMetersPanel_new(Settings* settings, Panel* leftMeters, Panel* rightMeters, ScreenManager* scr) {
AvailableMetersPanel* this = AllocThis(AvailableMetersPanel);
Panel* super = (Panel*) this;
Panel_init(super, 1, 1, 1, 1, Class(ListItem), true);
this->settings = settings;
this->leftPanel = leftMeters;
this->rightPanel = rightMeters;
this->scr = scr;
Panel_setHeader(super, "Available meters");
for (int i = 1; Platform_meterTypes[i]; i++) {
MeterClass* type = Platform_meterTypes[i];
if (type != &CPUMeter_class) {
Panel_add(super, (Object*) ListItem_new(type->uiName, i << 16));
}
}
MeterClass* type = &CPUMeter_class;
int cpus = settings->pl->cpuCount;
if (cpus > 1) {
Panel_add(super, (Object*) ListItem_new("CPU average", 0));
for (int i = 1; i <= cpus; i++) {
char buffer[50];
sprintf(buffer, "%s %d", type->uiName, i);
Panel_add(super, (Object*) ListItem_new(buffer, i));
}
} else {
Panel_add(super, (Object*) ListItem_new("CPU", 1));
}
return this;
}
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* pidWhiteList, uid_t userId) {
FreeBSDProcessList* fpl = calloc(1, sizeof(FreeBSDProcessList));
ProcessList* pl = (ProcessList*) fpl;
ProcessList_init(pl, Class(FreeBSDProcess), usersTable, pidWhiteList, userId);
int cpus = 1;
size_t sizeof_cpus = sizeof(cpus);
int err = sysctlbyname("hw.ncpu", &cpus, &sizeof_cpus, NULL, 0);
if (err) cpus = 1;
pl->cpuCount = MAX(cpus, 1);
CPUData* tmp_cpus = (CPUData*) realloc(fpl->cpus, cpus * sizeof(CPUData));
assert(tmp_cpus != NULL);
fpl->cpus = tmp_cpus;
for (int i = 0; i < cpus; i++) {
fpl->cpus[i].totalTime = 1;
fpl->cpus[i].totalPeriod = 1;
}
size_t len;
len = 4; sysctlnametomib("vm.stats.vm.v_wire_count", MIB_vm_stats_vm_v_wire_count, &len);
len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", MIB_vm_stats_vm_v_cache_count, &len);
len = 2; sysctlnametomib("hw.physmem", MIB_hw_physmem, &len);
pageSizeKb = PAGE_SIZE_KB;
fpl->kd = kvm_open(NULL, "/dev/null", NULL, 0, NULL);
assert(fpl->kd);
return pl;
}
void Player::setDefaultSpeed(const AnimationSpeed& speed_)
{
defaultSpeed = speed_;
speed = Class()->getSpeed(playerAnimation);
animation.elapsedTime.timeout = speed.animation;
updateSpeed();
}