void
userinit(void)
{
Lsym *l;
Node *n;
char *buf, *p;
p = getenv("home");
if(p != 0) {
buf = smprint("%s/lib/acid", p);
silent = 1;
loadmodule(buf);
free(buf);
}
interactive = 0;
if(setjmp(err)) {
unwind();
return;
}
l = look("acidinit");
if(l && l->proc) {
n = an(ONAME, ZN, ZN);
n->sym = l;
n = an(OCALL, n, ZN);
execute(n);
}
}
junk ()
{
if (an (inbyte ()))
while (an (ch ()))
gch ();
else
while (an (ch ())) {
if (ch () == 0)
break;
gch ();
}
blanks ();
}
/* hero is hit by something other than a monster */
int
thitu(int tlev, int dam, struct obj *obj, const char *name)
{ /* if null, then format `obj' */
const char *onm, *killer;
boolean is_acid;
/* TODO: credit the monster that fired the object with the kill */
if (!name) {
if (!obj)
panic("thitu: name & obj both null?");
name = (obj->quan > 1L) ? doname(obj) : mshot_xname(obj);
killer = killer_msg_obj(DIED, obj);
} else {
killer = killer_msg(DIED, an(name));
}
onm = (obj && obj_is_pname(obj)) ? the(name) :
(obj && obj->quan > 1L) ? name : an(name);
is_acid = (obj && obj->otyp == ACID_VENOM);
if (get_player_ac() + tlev <= rnd(20)) {
if (Blind || !flags.verbose)
pline("It misses.");
else
pline("You are almost hit by %s.", onm);
return 0;
} else {
if (Blind || !flags.verbose)
pline("You are hit!");
else
pline("You are hit by %s%s", onm, exclam(dam));
if (obj && objects[obj->otyp].oc_material == SILVER &&
hates_silver(youmonst.data)) {
dam += rnd(20);
pline("The silver sears your flesh!");
exercise(A_CON, FALSE);
}
if (is_acid && Acid_resistance)
pline("It doesn't seem to hurt you.");
else {
if (is_acid)
pline("It burns!");
if (Half_physical_damage)
dam = (dam + 1) / 2;
losehp(dam, killer);
exercise(A_STR, FALSE);
}
return 1;
}
}
DiTexturePtr DiShaderParameter::WriteTextureCUBE( const DiString& name,
const DiString& textureName )
{
DiString texfile = textureName;
#if DEMI_PLATFORM == DEMI_PLATFORM_IOS
if(texfile.CheckFileExtension("dds"))
texfile = texfile.ExtractBaseName() + ".pvr";
#endif
DiAssetManager& assetMgr = DiAssetManager::GetInstance();
DiTexturePtr textureAsset = assetMgr.GetAsset<DiTexture>(texfile);
if (!textureAsset)
{
DI_WARNING("Failed to load the textureCUBE resource : %s",texfile.c_str());
return DiTexturePtr();
}
auto it = mShaderParams[VARIABLE_SAMPLERCUBE].find(name);
if (it != mShaderParams[VARIABLE_SAMPLERCUBE].end())
{
DiTexture* tex = textureAsset.get();
DiAny an(tex);
it->second = an;
}
return textureAsset;
}
int doidtrap(void)
{
struct trap *trap;
int x, y, tt;
schar dx, dy, dz;
if (!getdir(NULL, &dx, &dy, &dz))
return 0;
x = u.ux + dx;
y = u.uy + dy;
for (trap = level->lev_traps; trap; trap = trap->ntrap)
if (trap->tx == x && trap->ty == y) {
if (!trap->tseen) break;
tt = trap->ttyp;
if (dz) {
if (dz < 0 ? (tt == TRAPDOOR || tt == HOLE) :
tt == ROCKTRAP) break;
}
tt = what_trap(tt);
pline("That is %s%s%s.",
an(trapexplain[tt - 1]),
!trap->madeby_u ? "" : (tt == WEB) ? " woven" :
/* trap doors & spiked pits can't be made by
player, and should be considered at least
as much "set" as "dug" anyway */
(tt == HOLE || tt == PIT) ? " dug" : " set",
!trap->madeby_u ? "" : " by you");
return 0;
}
pline("I can't see a trap there.");
return 0;
}
template <class K> inline bool do_intersect(const Rectangle_2<K> &a, const Rectangle_2<K> &b)
{
typedef typename K::Vector_2 Vector_2;
typedef typename K::FT FT;
Vector_2 an(a.normal());
Vector_2 bn(b.normal());
Vector_2 v(a.center()-b.center());
FT det = abs(an.x()*bn.y()-an.y()*bn.x());
FT dot = abs(an*bn);
FT an2 = an.squared_length();
FT br(abs(b.ratio()));
FT ax0 = an*v;
FT dax = dot+br*det+an2;
if(ax0*ax0>=dax*dax) return false;
FT ar(abs(a.ratio()));
FT ay0 = an.x()*v.y()-an.y()*v.x();
FT day = det+br*dot+ar*an2;
if(ay0*ay0>=day*day) return false;
FT bn2 = bn.squared_length();
FT bx0 = bn*v;
FT dbx = dot+ar*det+bn2;
if(bx0*bx0>=dbx*dbx) return false;
FT by0 = v.x()*bn.y()-v.y()*bn.x();
FT dby = det+ar*dot+br*bn2;
return(by0*by0<dby*dby);
}
int main(int argc, char *argv[]){
if(argc!=2)
printf("USAGE: ArmstrongNumbers.o #Digits\n");
else
printf("\nMultiplications = %d\n",an(atoi(argv[1])));
return 0;
}
int doidtrap (void) {
struct trap *trap;
int x, y, tt;
if (!getdir("^")) return 0;
x = u.ux + u.delta.x;
y = u.uy + u.delta.y;
for (trap = ftrap; trap; trap = trap->ntrap)
if (trap->tx == x && trap->ty == y) {
if (!trap->tseen) break;
tt = trap->ttyp;
if (u.delta.z) {
if (u.delta.z < 0 ? (tt == TRAPDOOR || tt == HOLE) :
tt == ROCKTRAP) break;
}
tt = what_trap(tt);
pline("That is %s%s%s.",
an(defsyms[trap_to_defsym(tt)].explanation),
!trap->madeby_u ? "" : (tt == WEB) ? " woven" :
/* trap doors & spiked pits can't be made by
player, and should be considered at least
as much "set" as "dug" anyway */
(tt == HOLE || tt == PIT) ? " dug" : " set",
!trap->madeby_u ? "" : " by you");
return 0;
}
pline("I can't see a trap there.");
return 0;
}
int define_struct (char *sname, int storage, int is_struct)
{
TAG_SYMBOL *symbol;
char *buffer_ptr;
int tti;
// tag_table_index++;
if (tag_table_index >= NUMTAG) {
error("struct table overflow");
return (0);
}
tti = tag_table_index++;
symbol = &tag_table[tti];
buffer_ptr = symbol->name;
while (an(*buffer_ptr++ = *sname++)) ;
symbol->size = 0;
symbol->member_idx = member_table_index;
needbrack("{");
while (!match("}")) {
if (!dodcls(storage, &tag_table[tti], is_struct))
break;
/* We need to keep number_of_members up-to-date to make sure that
find_member() works so we can catch duplicate member names. */
symbol->number_of_members = member_table_index - symbol->member_idx;
}
;
/* XXX: still necessary? */
symbol->number_of_members = member_table_index - symbol->member_idx;
return (tti);
}
STATIC_OVL void
slime_dialogue()
{
register long i = (Slimed & TIMEOUT) / 2L;
if (((Slimed & TIMEOUT) % 2L) && i >= 0L
&& i < SIZE(slime_texts)) {
const char *str = slime_texts[SIZE(slime_texts) - i - 1L];
if (index(str, '%')) {
if (i == 4L) { /* "you are turning green" */
if (!Blind) /* [what if you're already green?] */
pline(str, hcolor(NH_GREEN));
} else
pline(str, an(Hallucination ? rndmonnam() : "green slime"));
} else
pline(str);
}
if (i == 3L) { /* limbs becoming oozy */
HFast = 0L; /* lose intrinsic speed */
stop_occupation();
if (multi > 0) nomul(0, 0);
}
exercise(A_DEX, FALSE);
}
void Test::readNodeRegulatingFromText(QString &str_node)
{
TestNode node(TYPE_NODE_REGULATING);
QStringList str_list = str_node.split("\n");
QString real_answ = "";
QRegExp an("^\\d");
for(int i = 0; i < str_list.count(); i++)
{
if(str_list.at(i).isEmpty())
continue;
QStringList tmp = str_list.at(i).split(":");
if(tmp.count() < 2)
continue;
if(tmp.at(0) == "Q")
node.setTaskTest(tmp.at(1).trimmed());
if(an.exactMatch(tmp.at(0)))
{
node.addAnswer(tmp.at(1).trimmed());
real_answ += tmp.at(0).trimmed();
}
}
node.setReals(real_answ);
nodeList.append(node);
}
void MinimumDistanceClassifier::calculateGranlundCoefficients(vector<Point> contour, int m, int n,
vector<double>& coeffs)
{
double realAm = 0.0, imagAm = 0.0, realAn = 0.0, imagAn = 0.0, realAone = 0.0, imagAone = 0.0;
double realDmn = 0.0, imagDmn = 0.0;
double x, y;
double multiplicationConst;
int N = contour.size();
for (int i = 0; i < N; i++)
{
x = contour[i].x;
y = contour[i].y;
multiplicationConst = 2 * PI * i / N;
realAm += x * cos(multiplicationConst * (m + 1)) + y * sin(multiplicationConst * (m + 1));
imagAm += y * cos(multiplicationConst * (m + 1)) - x * sin(multiplicationConst * (m + 1));
realAn += x * cos(multiplicationConst * (1 - n)) + y * sin(multiplicationConst * (1 - n));
imagAn += y * cos(multiplicationConst * (1 - n)) - x * sin(multiplicationConst * (1 - n));
realAone += x * cos(multiplicationConst) + y * sin(multiplicationConst);
imagAone += y * cos(multiplicationConst) - x * sin(multiplicationConst);
}
complex<double> am(realAm, imagAm);
complex<double> an(realAn, imagAn);
complex<double> aone(realAone, imagAone);
realDmn = real((pow(am, n) * pow(an, m)) / pow(aone, m + n));
imagDmn = imag((pow(am, n) * pow(an, m)) / pow(aone, m + n));
coeffs.push_back(realDmn);
coeffs.push_back(imagDmn);
}
DiTexturePtr DiShaderParameter::WriteTexture2D( const DiString& name,
const DiString& textureName )
{
DiString texfile = textureName;
#if DEMI_PLATFORM == DEMI_PLATFORM_IOS
if(texfile.CheckFileExtension("dds"))
texfile = texfile.ExtractBaseName() + ".pvr";
#endif
//DI_LOG("Writing 2d texture name: %s, %s [%x]", name.c_str(), textureName.c_str(),this);
DiAssetManager& assetMgr = DiAssetManager::GetInstance();
DiTexturePtr textureAsset = assetMgr.GetAsset<DiTexture>(texfile);
if (!textureAsset)
{
textureAsset = DiTexture::GetDefaultTexture();
DI_WARNING("Cannot write the texture(%s), using default texture", texfile.c_str());
}
auto it = mShaderParams[VARIABLE_SAMPLER2D].find(name);
if (it != mShaderParams[VARIABLE_SAMPLER2D].end())
{
DiTexture* tex = textureAsset.get();
DiAny an(tex);
it->second = an;
}
return textureAsset;
}
/* try to force a chest with your weapon */
int
doforce(const struct nh_cmd_arg *arg)
{
struct obj *otmp;
int c;
const char *qbuf;
if (!uwep_can_force())
return 0;
if (u.utracked[tos_lock] && u.uoccupation_progress[tos_lock]) {
if (turnstate.continue_message)
pline(msgc_occstart, "You resume your attempt to force the lock.");
one_occupation_turn(forcelock, "forcing the lock", occ_lock);
return 1;
}
/* A lock is made only for the honest man, the thief will break it. */
u.utracked[tos_lock] = NULL;
u.uoccupation_progress[tos_lock] = 0;
for (otmp = level->objects[youmonst.mx][youmonst.my]; otmp; otmp = otmp->nexthere)
if (Is_box(otmp)) {
if (otmp->obroken || !otmp->olocked) {
pline(msgc_cancelled,
"There is %s here, but its lock is already %s.",
doname(otmp), otmp->obroken ? "broken" : "unlocked");
continue;
}
qbuf = msgprintf(
"There is %s here, force its lock?",
safe_qbuf("", sizeof ("There is here, force its lock?"),
doname(otmp), an(simple_typename(otmp->otyp)),
"a box"));
c = ynq(qbuf);
if (c == 'q')
return 0;
if (c == 'n')
continue;
if (is_blade(uwep))
pline(msgc_occstart,
"You force your %s into a crack and pry.", xname(uwep));
else
pline(msgc_occstart,
"You start bashing it with your %s.", xname(uwep));
u.utracked[tos_lock] = otmp;
break;
}
if (u.utracked[tos_lock]) {
one_occupation_turn(forcelock, "forcing the lock", occ_lock);
return 1;
} else {
pline(msgc_cancelled, "You decide not to force the issue.");
return 0;
}
}
void DiShaderParameter::WriteFloat( const DiString& name,float ve1)
{
auto it = mShaderParams[VARIABLE_FLOAT].find(name);
if (it != mShaderParams[VARIABLE_FLOAT].end())
{
DiAny an(ve1);
it->second = an;
}
}
void DiShaderParameter::WriteFloat2( const DiString& name,DiVec2 ve2 )
{
auto it = mShaderParams[VARIABLE_FLOAT2].find(name);
if (it != mShaderParams[VARIABLE_FLOAT2].end())
{
DiAny an(ve2);
it->second = an;
}
}
void DiShaderParameter::WriteColor( const DiString& name,DiColor vec4 )
{
auto it = mShaderParams[VARIABLE_COLOR].find(name);
if (it != mShaderParams[VARIABLE_COLOR].end())
{
DiAny an(vec4);
it->second = an;
}
}
void DiShaderParameter::WriteMatrix4(const DiString& name, DiMat4 mat4)
{
auto it = mShaderParams[VARIABLE_MAT4].find(name);
if (it != mShaderParams[VARIABLE_MAT4].end())
{
DiAny an(mat4);
it->second = an;
}
}
void SubimagePP::fillComponents()
{
CCAnalysis an(&ccbuilder);
an.analize(true);
mgw = an.getMediumGlyphWidth();
mgh = an.getMediumGlyphHeight();
bars = an.getBars();
components = an.getAllComponents(false);
}
static void
fill_topten_entry(struct toptenentry *newtt, int how)
{
int uid = getuid();
memset(newtt, 0, sizeof (struct toptenentry));
/* deepest_lev_reached() is in terms of depth(), and reporting the deepest
level reached in the dungeon death occurred in doesn't seem right, so we
have to report the death level in depth() terms as well (which also
seems reasonable since that's all the player sees on the screen anyway) */
newtt->ver_major = VERSION_MAJOR;
newtt->ver_minor = VERSION_MINOR;
newtt->patchlevel = PATCHLEVEL;
newtt->points = u.urexp > -1 ? /* u.urexp stores score once invent is
invalid */
u.urexp : calc_score(how, FALSE, money_cnt(invent) + hidden_gold());
newtt->deathdnum = u.uz.dnum;
newtt->deathlev = depth(&u.uz);
newtt->maxlvl = deepest_lev_reached(TRUE);
newtt->hp = u.uhp;
newtt->maxhp = u.uhpmax;
newtt->deaths = u.umortality;
newtt->uid = uid;
newtt->moves = moves;
newtt->how = how;
strncpy(newtt->plrole, urole.filecode, ROLESZ);
newtt->plrole[ROLESZ] = '\0';
strncpy(newtt->plrace, urace.filecode, ROLESZ);
newtt->plrace[ROLESZ] = '\0';
strncpy(newtt->plgend, genders[flags.female].filecode, ROLESZ);
newtt->plgend[ROLESZ] = '\0';
strncpy(newtt->plalign, aligns[1 - u.ualign.type].filecode, ROLESZ);
newtt->plalign[ROLESZ] = '\0';
strncpy(newtt->name, plname, NAMSZ);
newtt->name[NAMSZ] = '\0';
newtt->death[0] = '\0';
switch (killer_format) {
default:
impossible("bad killer format?");
case KILLED_BY_AN:
strcat(newtt->death, killed_by_prefix[how]);
strncat(newtt->death, an(killer), DTHSZ - strlen(newtt->death));
break;
case KILLED_BY:
strcat(newtt->death, killed_by_prefix[how]);
strncat(newtt->death, killer, DTHSZ - strlen(newtt->death));
break;
case NO_KILLER_PREFIX:
strncat(newtt->death, killer, DTHSZ);
break;
}
newtt->birthdate = yyyymmdd(u.ubirthday);
newtt->deathdate = yyyymmdd((time_t) 0L);
time(&deathtime_internal);
}
void DiShaderParameter::WriteFloat4Array( const DiString& name,DiVec4* vec4,uint32 size )
{
auto it = mShaderParams[VARIABLE_FLOAT4_ARRAY].find(name);
if (it != mShaderParams[VARIABLE_FLOAT4_ARRAY].end())
{
DiPair<DiVec4*,uint32> p(vec4,size);
DiAny an(p);
it->second = an;
}
}
Node*
con(vlong v)
{
Node *n;
n = an(OCONST, ZN, ZN);
n->ival = v;
n->fmt = 'W';
n->type = TINT;
return n;
}
Node*
con(int v)
{
Node *n;
n = an(OCONST, ZN, ZN);
n->nstore.u0.sival = v;
n->nstore.fmt = 'X';
n->type = TINT;
return n;
}
main()
{
char s[100000] ;
bool fir=1 ;
while(scanf("%s",s)!=EOF)
{
if(fir) fir=0 ;
else printf("\n") ;
int l=strlen(s) ;
int n=1000*(s[l-4]-'0')+100*(s[l-3]-'0')+10*(s[l-2]-'0')+(s[l-1]-'0') ;
int x=an(n),y=hu(s,l),z=(bu(s,l))&&(an(n)) ;
if((!x) && (!y) && (!z))
printf("This is an ordinary year.\n") ;
else
{
if(x) printf("This is leap year.\n") ;
if(y) printf("This is huluculu festival year.\n") ;
if(z) printf("This is bulukulu festival year.\n") ;
}
}
}
void DiShaderParameter::WriteTextureCUBE( const DiString& name,DiTexturePtr textureAsset )
{
DI_ASSERT(textureAsset);
auto it = mShaderParams[VARIABLE_SAMPLERCUBE].find(name);
if (it != mShaderParams[VARIABLE_SAMPLERCUBE].end())
{
DiTexture* tex = textureAsset.get();
DiAny an(tex);
it->second = an;
}
}
sensitivities price(qm_real strike, qdate expiry, DISCOUNTCURVE yc, DISCOUNTCURVE cy,
qm_real spot, qm_real vol) const {
qm_real ba,bb;
qm_real fwd = forward(spot,expiry,yc,cy,ba,bb);
qm_real T = 1;
BLACKSENSITIVITY an(yc.date(),"Black sensitivity");
black_fwdcall(fwd,strike,T,vol,an);
*an *= ba;
sensitivities s;
//s.add(an);
return s;
}
wb_attribute wb_volume::attribute(wb_name aname)
{
pwr_tStatus sts;
if (!aname)
return wb_attribute();
wb_object o = object(aname.name());
if (!o)
return wb_attribute();
if (!aname.hasAttribute())
return wb_attribute(LDH__SUCCESS, (wb_orep *)o);
wb_cdef cd = cdef(o);
if (!cd)
return wb_attribute();
wb_adrep *adrep = ((wb_cdrep *)cd)->adrep(&sts, aname.attributesAllTrue());
if (ODD(sts)) {
bool shadowed = false;
if (aname.hasSuper()) {
// Check if shadowed
wb_attrname an(aname.attributesAllTrue());
wb_adrep *ad = ((wb_cdrep *)cd)->adrep(&sts, an.name(cdh_mName_attribute));
if (ODD(sts) && ad->offset() != adrep->offset()) {
shadowed = true;
delete ad;
}
}
wb_attribute a;
if (aname.hasAttrIndex(aname.attributes() - 1))
a = wb_attribute(sts, (wb_orep *)o, adrep, aname.attrIndex(aname.attributes() - 1));
else
a = wb_attribute(sts, (wb_orep *)o, adrep);
a.setShadowed(shadowed);
return a;
}
#if 0
// This only work on one level attributes... TODO
wb_adrep *adrep = ((wb_cdrep *)cd)->adrep(&sts, aname.attributesAllTrue());
if (ODD(sts)) {
if (aname.hasAttrIndex())
return wb_attribute(sts, (wb_orep *)o, adrep, aname.attrIndex());
else
return wb_attribute(sts, (wb_orep *)o, adrep);
}
#endif
return wb_attribute();
}
int main_() {
Core::Analyzer an("/home/myzone/Рабочий стол/");
an.addErrorEventListener(new A());
an.analyze(
"import std;\n"
"main -> a;\n"
"a -> \"a\";\n"
"/* hi, bug */"
);
return 0;
}
void you_were(void)
{
char qbuf[QBUFSZ];
if (Unchanging || (u.umonnum == u.ulycn)) return;
if (Polymorph_control) {
/* `+4' => skip "were" prefix to get name of beast */
sprintf(qbuf, "Do you want to change into %s? ",
an(mons[u.ulycn].mname+4));
if (yn(qbuf) == 'n') return;
}
polymon(u.ulycn);
}
void
userinit(void)
{
Lsym *l;
Node *n;
char buf[512], *p;
p = getenv("home");
if(p == 0)
p = getenv("HOME");
if(p != 0) {
snprint(buf, sizeof(buf)-1, "%s/lib/acid", p);
silent = 1;
loadmodule(buf);
}
if(rdebug){
snprint(buf, sizeof(buf)-1, "%s/rdebug", acidlib);
loadmodule(buf);
}
snprint(buf, sizeof(buf)-1, "%s/%s", acidlib, mach->name);
loadmodule(buf);
interactive = 0;
if(setjmp(err)) {
unwind();
return;
}
l = look("acidinit");
if(l && l->proc) {
n = an(ONAME, ZN, ZN);
n->sym = l;
n = an(OCALL, n, ZN);
execute(n);
}
}
