/*
* BPatch_typeCollection::~BPatch_typeCollection
*
* Destructor for BPatch_typeCollection. Deletes all type objects that have
* been inserted into the collection.
*/
BPatch_typeCollection::~BPatch_typeCollection()
{
// We sometimes directly delete (refcount == 1) or go through the
// decRefCount (which will delete when refcount == 0)
assert(refcount == 0 ||
refcount == 1);
// delete all of the types
// This doesn't seem to work - jkh 1/31/00
#if 0
dictionary_hash_iter<pdstring, BPatch_type *> ti(typesByName);
dictionary_hash_iter<int, BPatch_type *> tid(typesByID);
dictionary_hash_iter<pdstring, BPatch_type *> gi(globalVarsByName);
pdstring gname;
pdstring name;
BPatch_type *type;
int id;
while (tid.next(id, type))
delete type;
// Underlying types deleted already just need to get rid of pointers
while (ti.next(name, type))
type = NULL;
// delete globalVarsByName collection
while (gi.next(name, type))
delete type;
for (dictionary_hash_iter<int, BPatch_type *> it = typesByID.begin();
it != typesByID.end();
it ++) {
(*it)->decrRefCount();
}
for (dictionary_hash_iter<pdstring, BPatch_type *> it2 = typesByName.begin();
it2 != typesByName.end();
it2 ++) {
(*it2)->decrRefCount();
}
#endif
}
void InputMapper::ApplyMapping( const Mapping *maps, GameController gc, InputDevice device )
{
for( int k=0; !maps[k].IsEndMarker(); k++ )
{
GameController map_gc = gc;
if( maps[k].SecondController )
{
map_gc = (GameController)(map_gc+1);
/* If that pushed it over, then it's a second controller for a joystick
* that's already a second controller, so we'll just ignore it. (This
* can happen if eg. two primary Pump pads are connected.) */
if( map_gc >= GAME_CONTROLLER_INVALID )
continue;
}
DeviceInput di( device, maps[k].deviceButton );
GameInput gi( map_gc, maps[k].gb );
SetInputMap( di, gi, maps[k].iSlotIndex );
}
}
InputTree*
inputTreeFromAnswerTree(AnswerTree* at, Item* itm)
{
int strt = itm->start();
int fin = itm->finish();
const Term* trm = itm->term();
ECString trmString = trm->name();
ECString wrdString;
ECString ntString;
list<InputTree*> subtrs;
InputTree* ans;
if(trm->terminal_p())
{
wrdString = itm->word()->lexeme();
}
else
{
assert(at);
Edge* e = at->e;
list<AnswerTree*>::iterator ati = at->subtrees.begin();
Item* subi;
LeftRightGotIter gi(e);
for( ; ati != at->subtrees.end() ; ati++)
{
gi.next(subi);
//stop terms will now appear in edges.
if(subi->term() == Term::stopTerm)
{
ati--;
continue;
}
AnswerTree* sab = *ati;
InputTree* sit = inputTreeFromAnswerTree(sab,subi);
subtrs.push_back(sit);
}
}
ans = new InputTree(strt, fin, wrdString, trmString, ntString,
subtrs, NULL, NULL);
return ans;
}
bool FormationItem::SelectedElement(ItemPtr currtarget,int counter/*=0*/,Coords3D* coords/*=&despos*/)
{
if (currtarget->shape==EMPTY) //DAW 16/06/99
return false; //DAW 16/06/99
else
if (currtarget->Status.size>=FORMATIONSIZE)
{
FormationItemPtr curr=*currtarget;
int count=counter;
if (count)
{
if (curr->Leader())
{
count--;
curr=curr->Leader();
}
while (count)
{
if (curr->follower)
curr=curr->Follower();
else
if (curr->Leader())
curr=curr->Leader(); //make it loop....
count--;
}
}
*coords=curr->World;
return (curr->Status.deadtime==0);
}
else
{
GroupItterator gi(currtarget->shape,currtarget->Anim);
for (;counter;gi++,counter--)
{}
*coords=gi.delta;
*coords+=currtarget->World;
return gi.AnimDataMAD().itemstate!=DEAD;
}
}
Image* remap(const Image& src, const FloatImage &px, const FloatImage &py, Image* dst, int interpolation)
{
#ifdef NICE_USELIB_IPP
Image * result = createResultBuffer(src.width(), src.height(), dst);
Image gi(src);
*(gi.getPixelPointerY(0)) = 0;
IppStatus ret = ippiRemap_8u_C1R(gi.getPixelPointer(), makeROIFullImage(src), gi.getStepsize(),
makeRectFullImage(gi), px.getPixelPointer(), px.getStepsize(),
py.getPixelPointer(), py.getStepsize(),
result->getPixelPointer(), result->getStepsize(),
makeROIFullImage(gi), interpolation);
if(ret!=ippStsNoErr)
fthrow(ImageException, ippGetStatusString(ret));
return result;
#else // NICE_USELIB_IPP
fthrow(ImageException,"Not yet supported without IPP.");
#endif // NICE_USELIB_IPP
}
void
LeftRightGotIter::
makelrgi(Edge* ri)
{
GotIter gi(ri);
Item* itm;
bool finishedRight = false;
int spos = ri->start();
/* gotiter return a b head c d in the order d c a b head */
list<Item*>::iterator lri;
list<Item*> lrlist;
while(gi.next(itm))
{
//cerr << "lrgi " << *itm << endl;
if(finishedRight || itm->start() == spos)
{
// if 1st consits is STOP(3, 3) then next can have same start pos.
if(itm->start() == spos && !finishedRight)
{
finishedRight = true;
lri = lrlist.begin();
}
lri = lrlist.insert(lri, itm);
lri++;
}
else lrlist.push_front(itm);
}
lri = lrlist.begin();
int i = 0;
for( ; lri != lrlist.end() ; lri++)
{
assert(i < 400);
lrarray[i] = (*lri);
i++;
}
size_ = i;
pos_ = 0;
}
int
Edge::
ccInd()
{
const Term* trm = lhs();
int tint = trm->toInt();
ECString tNm = trm->name();
bool sawComma = false;
bool sawColen = false;
bool sawCC = false;
int numTrm = 0;
Item* itm;
LeftRightGotIter gi(this);
int pos = 0;
/*Change next line to indicate which non-terminals get specially
marked to indicate that they are conjoined together */
if(tNm != "NP" && tNm != "S" && tNm != "VP") return tint;
while( gi.next(itm) )
{
const Term* subtrm = itm->term();
if(subtrm == Term::stopTerm) continue;
if(subtrm == trm) numTrm++;
const ECString& nm = subtrm->name();
//Change next two lines depending on possible conjunction parts of speech
ECString CCInd[2] = {"CC", "CONJP"};
if(pos != 0 && (nm == CCInd[0] || nm == CCInd[1])) sawCC = true;
if(pos != 0 && (nm == ",")) sawComma = true;
if(pos != 0 && nm == ":") sawColen = true;
//else if(!trm->isPunc()) return tint;
pos++;
}
if(trm->name() == "NP" && numTrm == 2 && !sawCC) return Term::lastNTInt()+1;
if((sawComma || sawColen || sawCC) && numTrm >= 2) return tint+Term::lastNTInt();
//if(trm->name() == "NP" && numTrm == 2 && !sawCC) return 78;
//if((sawComma || sawColen || sawCC) && numTrm >= 2) return tint+80;
return tint;
}
float
MeChart::
meRuleProb(Edge* edge, FullHist* h)
{
if(printDebug() > 30)
{
prDp();
cerr << "In meruleprob " << *h << " " << *edge
<< " " << edge->headPos() <<endl;
}
int i;
int hpos = edge->headPos();
h->hpos = hpos;
LeftRightGotIter gi(edge);
globalGi[thrdid] = &gi;
Item* got;
float ans = 1;
for(i=0 ; ; i++ )
{
if(i >= gi.size()) break;
got = gi.index(i);
h->pos = i;
int cVal = got->term()->toInt();
int whichInt = LCALC;
if(h->pos == hpos) whichInt = MCALC;
else if(h->pos > hpos) whichInt = RCALC;
ans *= meProb(cVal, h, whichInt);
if(ans == 0) break;
}
if(printDebug() > 30)
{
prDp();
cerr << "merp = " << ans << endl;
}
globalGi[thrdid] = NULL;
return ans;
}
Bst&
MeChart::
bestParseGivenHead(int posInt, const Wrd& wd, Item* itm,
FullHist* h, ItmGHeadInfo& ighInfo, Val* cval, Val* gcval)
{
EdgeSet& es = ighInfo.first;
BstMap& atm = ighInfo.second;
curVal = cval;
gcurVal = gcval;
Bst& bst = recordedBPGH(itm, atm, h);
if(bst.explored())
{
if(printDebug() > 19)
{
int subfv[MAXNUMFS];
getHt(h, subfv);
CntxArray ca(subfv);
prDp();
cerr << "bpknown for " << posInt << ", " << wd
<< ", " << *itm << ") : " << bst.prob() << " " << ca <<endl;
}
curVal=gcurVal=NULL;
return bst;
}
bst.explored() = true;
curVal=gcurVal=NULL;
const Term* trm = itm->term();
if(trm->terminal_p())
{
Val* nval = new Val;
nval->prob() = 1;
nval->trm1() = itm->term()->toInt();
nval->wrd1() = itm->word()->toInt();
nval->status = TERMINALVAL;
bst.addnth(nval);
bst.sum() = nval->prob();
return bst;
}
if(printDebug() > 10)
{
prDp();
cerr << "bestParseGivenHead(" << posInt << ", " << wd
<< ", " << *itm << ")" << endl;
}
double bestP = 0;
double sumP = 0;
EdgeSetIter ei = es.begin();
for( ; ei != es.end() ; ei++)
{
Edge* e = *ei;
if(!sufficiently_likely(e))
{
continue;
}
float edgePg = 1;
int finish = e->loc();
int effVal = effEnd(finish);
if(itm->term()->isRoot()) edgePg = 1;
else if(Feature::isLM) edgePg == 1;
else if(effVal == 1)
edgePg = endFactor;
else if(effVal == 0) edgePg = midFactor;
h->e = e;
if(printDebug() > 20)
{
prDp();
cerr << "consid " << *e << endl;
}
gcurVal = gcval;
float prob = meRuleProb(e,h);
gcurVal=NULL;
double nextP = prob * edgePg;
double nextPs = nextP;
Item* sitm;
//LeftRightGotIter gi(e);
MiddleOutGotIter gi(e);
Val* val = new Val(e, nextPs);
val->trm1() = itm->term()->toInt();
val->wrd1() = wd.toInt();
int pos = 0;
depth++;
h = h->extendByEdge(e);
bool zeroProb = false;
while( gi.next(sitm,pos) )
{
//cerr << "Looking at " << *sitm << endl;
if(zeroProb)
{
h = h->extendBySubConstit();
continue;
}
if(sitm->term() == Term::stopTerm)
{
h = h->extendBySubConstit();
continue;
}
if(pos == 0)
{
h->preTerm = posInt;
h->hd = &wd;
ItmGHeadInfo& ighi = sitm->posAndheads()[posInt][wd];
Bst&
bst2 = bestParseGivenHead(posInt,wd,sitm,h,ighi,val,cval);
curVal = gcurVal = NULL;
curDir = -1;
if(bst2.empty())
{
zeroProb = true;
}
val->extendTrees(bst2,pos);
nextPs *= bst2.sum();
}
else
{
Bst& bst2 = bestParse(sitm,h,val,cval,pos);
if(bst2.empty())
{
zeroProb = true;
}
val->extendTrees(bst2,pos);
nextPs *= bst2.sum();
}
if(printDebug() > 39)
{
prDp();
cerr << "FullHist from " << *h;
}
h = h->extendBySubConstit();
if(printDebug() > 39)
cerr << " -> " << *h << endl;
}
if(!zeroProb) bst.push(val);
if(printDebug() > 20)
{
prDp();
cerr << "P(" << *e << " | " << wd << " ) = " ;
cerr << bestP;
cerr << "\n";
}
depth--;
sumP += nextPs;
h->retractByEdge();
if(printDebug() > 20)
{
prDp();
cerr << "Val: " << *val << endl;
}
}
Val* vbest = bst.pop();
if(vbest) bst.addnth(vbest);
bst.sum() = sumP;
if(printDebug() > 10)
{
prDp();
cerr << "Bestpgh for "<<*itm << ", " << wd << " = " << bst.prob()<< endl;
}
return bst;
}
////////////////////////////////////////////////////////////////////////
//
// Function: SelectTarget
// Date: 04/03/99
// Author: JIM
//
// Description:
//
////////////////////////////////////////////////////////////////////////
ItemPtr FormationItem::SelectTarget(ItemPtr currtarget,int* selectedelt,int counter/*=0*/)
{
ItemPtr rv=NULL;
if (currtarget)
if (currtarget->Status.size>=FORMATIONSIZE)
{
FormationItemPtr curr=*currtarget;
while (curr->leader)
curr=curr->Leader();
rv=curr;
if (rv && selectedelt)
*selectedelt=counter;
}
else
{
//count up damage
//count up live tokens
//if (damage-100*livetokens>700)
// pick another target
//DEADCODE DAW 01/07/99 Bool bombableSGT=CheckForWeapon(LT_BOMB); //DAW 01/07/99
UniqueID SGT=currtarget->SGT;
if (SGT==UID_NULL)
SGT=currtarget->uniqueID.count;
//DeadCode DAW 01Jul99 if (!bombableSGT && Persons2::getbandfromUID(SGT)!=AmberAirfieldBAND && Persons2::getbandfromUID(SGT)!=AmberBridgeBAND)
//DeadCode DAW 01Jul99 bombableSGT=TRUE;
int damage=0,livetokens=0;
//DeadCode DAW 01Jul99 if (!bombableSGT && !currtarget->SGT)
//DeadCode DAW 01Jul99 damage=800;
//DeadCode DAW 01Jul99 else
if (currtarget->shape==EMPTY)
damage=1000;
else
for (GroupItterator gi(currtarget->shape,currtarget->Anim);gi;gi++)
if (gi.AnimDataMAD().itemstate)
damage+=gi.DamageWeight()*gi.AnimDataMAD().itemstate;
else
if (gi.IsStoresToken())
livetokens++;
//DEADCODE JIM 22/03/00 if ((duty&DUTYMASK)==DC_WW)
//DEADCODE JIM 22/03/00 {
//DEADCODE JIM 22/03/00 if (selectedelt)
//DEADCODE JIM 22/03/00 *selectedelt=SelectElement(rv,counter);
//DEADCODE JIM 22/03/00 rv=currtarget;
//DEADCODE JIM 22/03/00 }
//DEADCODE JIM 22/03/00 else
if (damage-livetokens*100<700)
rv=currtarget;
else
{
//DeadCode DAW 27Jun99 UniqueID SGT=currtarget->SGT;
//DeadCode DAW 27Jun99 if (SGT==UID_NULL)
//DeadCode DAW 27Jun99 SGT=currtarget->uniqueID.count;
ItemPtr test=*Persons2::ConvertPtrUID(SGT);
int lowestdamage=900;
int scan=-1;
if (test)
do{
damage=0;livetokens=0;
//DeadCode DAW 01Jul99 if (!bombableSGT)
//DeadCode DAW 01Jul99 damage=1000;
//DeadCode DAW 01Jul99 else
if (currtarget->shape==EMPTY)
damage=1000;
else
for (GroupItterator gi(test->shape,test->Anim);gi;gi++)
{
if (gi.AnimDataMAD().itemstate)
damage+=gi.DamageWeight()*gi.AnimDataMAD().itemstate;
else
if (gi.IsStoresToken())
livetokens++;
}
//DeadCode DAW 01Jul99 bombableSGT=TRUE;
if (damage-livetokens*200<lowestdamage)
{
rv=test;
lowestdamage=damage-livetokens*200;
}
while (++scan<IllegalSepID)
{
if (scan<WayPointBAND || scan>=WayPointBANDEND)
if ((test=*Persons2::ConvertPtrUID(UniqueID(scan)))!=NULL)
if (test->SGT==SGT && test->shape!=EMPTY)
break;
}
}while (scan<IllegalSepID);
}
if (rv && selectedelt) //DAW 27Jun99
*selectedelt=SelectElement(rv,counter); //DAW 27Jun99
}
//DeadCode DAW 27Jun99 if (rv && selectedelt)
//DeadCode DAW 27Jun99 if (rv->Status.size>=FORMATIONSIZE)
//DeadCode DAW 27Jun99 {
//DeadCode DAW 27Jun99 selectedelt=0;
//DeadCode DAW 27Jun99 rv=SelectConvoyMember(*rv,counter);
//DeadCode DAW 27Jun99 }
//DeadCode DAW 27Jun99 else
if(!rv)
return currtarget;
return rv;
}
IVector ngi(int n) { IVector r=newIV(n); int i; for(i=0;i<n;i++)r->value[i]=gi(); return r; }
void El_dfg::transitively_reduce_edges()
{
// Compute longest paths on a reduced graph and
// remove edges which are superceded by longer paths
// from it src to its dest.
// 1) Iterate in reverse post-order dfs to traverse
// edges in a forward direction. This guarantees
// that an out edge does not go to an already visited
// node.
// 2) For the n-th node, assume that the previous n-1
// nodes are connected with reduced set of edges. Eliminate
// the redundant incoming edges.
// The following array keeps partially computed longest path
// lengths. MIN_ELCOR_INT implies no path. A row i of this
// Vector is the Vector of longest path lengths to node i from
// predecessor nodes, where entry j is dist(j,i).
//
Vector<int> t(g.node_count,ELCOR_MIN_INT) ; // for initialization only
Vector<Vector<int> > longest_paths(g.node_count,t) ;
Alist_graph_post_dfs gi(g, UP) ;
// mask we will construct
Bitvector edge_mask(g.edge_count) ;
// Start the iterative longest path calculator
// This for the longest path from node_i to cur_node,
// the entry edge_on_path_to_cur_node[node_i] contains
// the name of the inedge to cur_node. The inedges to
// cur_node which survive at the end make it to the edge_mask.
Vector<int> edge_on_path_to_cur_node(g.node_count, -1) ;
List_iterator<int> inedgei ;
for (gi.reset() ; gi != 0 ; gi++) {
int cur_node = *gi ;
// path_length_to_cur_node will contain the new longest
// path lengths to cur_node from its predecessors
Vector<int>& path_length_to_cur_node = longest_paths[cur_node] ;
for (inedgei(g.entry_edge_map[*gi]) ; inedgei!= 0 ; inedgei++) {
int cur_inedge = *inedgei ;
int cur_edge_lat = latency[cur_inedge] ;
int cur_src = g.edge_src_node_map[cur_inedge] ;
if (path_length_to_cur_node[cur_src] < cur_edge_lat) {
// a new path is created from cur_src to cur_dest
path_length_to_cur_node[cur_src] = cur_edge_lat ;
edge_on_path_to_cur_node[cur_src] = cur_inedge ;
Vector<int>& path_length_to_cur_src = longest_paths[cur_src] ;
for (int i = 0 ; i < g.node_count ; i++) {
if(path_length_to_cur_src[i] > ELCOR_MIN_INT) {
// there is a path from i to cur_src, see if cur_edge
// makes a longest path from i to cur_node.
int i_to_cur_node_length = path_length_to_cur_src[i] +
cur_edge_lat ;
if (path_length_to_cur_node[i] < i_to_cur_node_length) {
path_length_to_cur_node[i] = i_to_cur_node_length ;
edge_on_path_to_cur_node[i] = cur_inedge ;
}
}
}
}
}
for (int j = 0 ; j < g.node_count ; j++) {
if (edge_on_path_to_cur_node[j] >= 0 ) {
// There is a path from j to cur_node, set the bit for the
// edge on this path in the edge_mask.
edge_mask.set_bit(edge_on_path_to_cur_node[j]) ;
edge_on_path_to_cur_node[j] = -1 ;
}
}
}
eliminate_edges(edge_mask) ;
}
bool OpenAndLoadGUI(wchar* file)
{
if (!gui.Load(file))
{
msgboxf(_T("Unable to open gui dll (%s)"),MBX_ICONERROR,file);
return false;
}
ndcGetInterfaceFP* gi=(ndcGetInterfaceFP*)gui.GetProcAddress("ndcGetInterface");
if (!gi)
{
msgboxf(_T("Unable to resolve %s:ndcGetInterface"),MBX_ICONERROR,file);
return false;
}
gi(&libgui);
gui_emu_info gpi;
gpi.ConfigExists=cfgExists;
gpi.ConfigLoadInt=cfgLoadInt;
gpi.ConfigLoadStr=cfgLoadStr;
gpi.ConfigSaveInt=cfgSaveInt;
gpi.ConfigSaveStr=cfgSaveStr;
gpi.dbgReadMem=b_dbgReadMem;
gpi.dbgWriteMem=b_dbgWriteMem;
gpi.EmuStarted=b_EmuStarted;
gpi.EmuInit = b_EmuInit ;
gpi.EmuStart = b_EmuStart ;
gpi.EmuStop = b_EmuStop ;
gpi.EmuStep = b_EmuStep ;
gpi.EmuSkip = b_EmuSkip ;
gpi.EmuSetPatch = b_EmuSetPatch ;
gpi.EmuReset = b_EmuReset ;
gpi.EmuResetCaches=b_EmuResetCaches;
gpi.EmuBootHLE = b_EmuBootHLE ;
gpi.EmuLoadBinary = b_EmuLoadBinary ;
gpi.EmuSelectPlugins = b_EmuSelectPlugins ;
gpi.EmuStartProfiler = b_EmuStartProfiler ;
gpi.EmuStopProfiler = b_EmuStopProfiler ;
gpi.DissasembleOpcode = b_DissasembleOpcode ;
gpi.Sh4GetRegister = b_Sh4GetRegister ;
gpi.Sh4SetRegister = b_Sh4SetRegister ;
gpi.GetSymbName = b_GetSymbName ;
gpi.GetSetting=GetEmuSetting;
gpi.SetSetting=SetEmuSetting;
gpi.GetAboutText=GetAboutText;
gpi.GetPluginList=b_GetPluginList;
gpi.GetMapleDeviceList=b_GetMapleDeviceList;
gpi.FreePluginList=b_FreePluginList;
gpi.GetPerformanceInfo=b_GetPerformanceInfo;
gpi.BroardcastEvent=BroadcastEvent;
gpi.EmuThread=hEmuThread;
gpi.nCmdShow = nCmdShow;
if (rv_ok != libgui.Load(&gpi))
return false;
libgui.GetMenuIDs(&MenuIDs);
return true;
}
//LMA: exporting QSD Actions
void CWorldServer::ExportQSDDataA(byte* dataorg,int size,int opcode)
{
char buffero[20];
char buffera[20];
char buffer[100];
UINT itemtype=0;
UINT itemnum=0;
//Update quest
if(opcode==0)
{
STR_REWD_000 * data = (STR_REWD_000 *)dataorg;
//0 remove, 1 start, 2 replace quest keep items, 3 replace quest delete items, 4 select
switch(data->btOp)
{
case 0:
{
sprintf(buffer,"delete");
}
break;
case 1:
{
sprintf(buffer,"start");
}
break;
case 2:
{
sprintf(buffer,"replace (keep items)");
}
break;
case 3:
{
sprintf(buffer,"replace (delete items)");
}
break;
case 4:
{
sprintf(buffer,"select");
}
break;
default:
{
sprintf(buffer,"?%i?",data->btOp);
}
break;
}
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: %s quest %i (%s)",opcode,buffer,data->iQuestSN,GServer->GetSTLQuestByID(data->iQuestSN));
return;
}
//Update quest items
if(opcode==1)
{
STR_REWD_001 * data = (STR_REWD_001 *)dataorg;
//0 remove, 1 start, 2 replace quest keep items, 3 replace quest delete items, 4 select
switch(data->btOp)
{
case 0:
{
sprintf(buffer,"delete");
}
break;
case 1:
{
sprintf(buffer,"add");
}
break;
default:
{
sprintf(buffer,"?%i?",data->btOp);
}
break;
}
itemtype=gi(data->uiItemSN,0);
itemnum=gi(data->uiItemSN,1);
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: current quest: %s %i items %u (%i:%i, %s %s), (partyop %u)",opcode,buffer,data->nDupCNT,data->uiItemSN,itemtype,itemnum,GServer->GetSTLItemPrefix(itemtype,itemnum),GServer->GetSTLObjNameByID(itemtype,itemnum),data->btPartyOpt);
return;
}
//Set quest variable
if(opcode==2)
{
STR_REWD_002 * data = (STR_REWD_002 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: set %i Quest Variables",opcode,data->iDataCnt);
for(dword i = 0; i < data->iDataCnt; i++)
{
dword address = i * sizeof(STR_QUEST_DATA);
address += (dword)dataorg;
address += 4;
STR_QUEST_DATA* curQst = (STR_QUEST_DATA*)address;
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Set Quest Var[0x%04x (%u)][%i] %s %i",curQst->m_wVarTYPE,curQst->m_wVarTYPE,curQst->m_wVarNO,Operators(curQst->btOp,buffero),curQst->nValue);
}
return;
}
//Udapte Stats
if(opcode==3)
{
STR_REWD_003 * data = (STR_REWD_003 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Update %i Stats",opcode,data->iDataCnt);
for(dword i = 0; i < data->iDataCnt; i++)
{
dword address = i * 0x0C;
address += (dword)dataorg;
address += 4;
STR_ABIL_DATA* curAbil = (STR_ABIL_DATA*)address;
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Set Stat %s %s %i",Abilities(curAbil->iType,buffera),Operators(curAbil->btOp,buffero),curAbil->iValue);
}
return;
}
//Set quest variable
if(opcode==4)
{
STR_REWD_004 * data = (STR_REWD_004 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: set %i Quest Variables",opcode,data->iDataCnt);
for(dword i = 0; i < data->iDataCnt; i++)
{
dword address = i * sizeof(STR_QUEST_DATA);
address += (dword)dataorg;
address += 4;
STR_QUEST_DATA* curQst = (STR_QUEST_DATA*)address;
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Set Quest Var[0x%04x (%u)][%i] %s %i",curQst->m_wVarTYPE,curQst->m_wVarTYPE,curQst->m_wVarNO,Operators(curQst->btOp,buffero),curQst->nValue);
}
return;
}
//Give reward
if(opcode==5)
{
STR_REWD_005 * data = (STR_REWD_005 *)dataorg;
switch(data->btTarget)
{
case 0://EXP
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Give %u Exp, (partyop %u, itemopt %u, nPartyOpt %u)",opcode,data->iValue,data->btPartyOpt,data->nItemOpt,data->nPartyOpt);
}
break;
case 1://Zuly
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Give %u Zuly, (partyop %u, itemopt %u, nPartyOpt %u)",opcode,data->iValue,data->btPartyOpt,data->nItemOpt,data->nPartyOpt);
}
break;
case 2://Item
{
CItem nItem;
itemtype=gi(data->iItemSN,0);
itemnum=gi(data->iItemSN,1);
nItem.itemtype = itemtype;
nItem.itemnum = itemnum;
if(nItem.IsStackable())
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Give %i (+formula()) item %u (%i:%i, %s %s), (partyop %u, itemopt %u, nPartyOpt %u)",opcode,data->iValue,data->iItemSN,nItem.itemtype,nItem.itemnum,GServer->GetSTLItemPrefix(itemtype,itemnum),GServer->GetSTLObjNameByID(nItem.itemtype,nItem.itemnum),data->btPartyOpt,data->nItemOpt,data->nPartyOpt);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Give 1 item %u (%i:%i, %s %s), (partyop %u, itemopt %u, nPartyOpt %u)",opcode,data->iItemSN,nItem.itemtype,nItem.itemnum,GServer->GetSTLItemPrefix(itemtype,itemnum),GServer->GetSTLObjNameByID(nItem.itemtype,nItem.itemnum),data->btPartyOpt,data->nItemOpt,data->nPartyOpt);
}
}
break;
default:
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Give Unknown reward %i, item %u, count / value %u, (partyop %u, itemopt %u, nPartyOpt %u)",opcode,data->btTarget,data->iItemSN,data->iValue,data->btPartyOpt,data->nItemOpt,data->nPartyOpt);
}
break;
}
return;
}
//restore HP / MP
if(opcode==6)
{
STR_REWD_006 * data = (STR_REWD_006 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Restore %i%% HP, %i%% MP (partyop %u)",opcode,data->iPercentOfHP, data->iPercentOfMP,data->btPartyOpt);
return;
}
//teleport
if(opcode==7)
{
STR_REWD_007 * data = (STR_REWD_007 *)dataorg;
if(data->btPartyOpt!=0)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Teleport to map %i (%s) at (%.2f,%.2f), with party members. (partyop %u)",opcode,data->iZoneSN,GServer->GetSTLZoneNameByID(data->iZoneSN),(float)(data->iX/100),(float)(data->iY/100),data->btPartyOpt);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Teleport to map %i (%s) at (%.2f,%.2f), (partyop %u)",opcode,data->iZoneSN,GServer->GetSTLZoneNameByID(data->iZoneSN),(float)(data->iX/100),(float)(data->iY/100),data->btPartyOpt);
}
return;
}
//Spawn monster
if(opcode==8)
{
STR_REWD_008 * data = (STR_REWD_008 *)dataorg;
if(data->iX==0||data->iY==0||data->iZoneSN==0)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn %i monsters %i (%s) near me (team %i), (btwho)",opcode,data->iHowMany,data->iMonsterSN,GServer->GetSTLMonsterNameByID(data->iMonsterSN),data->iTeamNo,data->btWho);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn %i monsters %i (%s) to map %i (%s) at (%.2f,%.2f) (team %i), (btwho %u)",opcode,data->iHowMany,data->iMonsterSN,GServer->GetSTLMonsterNameByID(data->iMonsterSN),data->iZoneSN,GServer->GetSTLZoneNameByID(data->iZoneSN),(float)(data->iX/100),(float)(data->iY/100),data->iTeamNo,data->btWho);
}
return;
}
//Execute Quest Trigger
if(opcode==9)
{
STR_REWD_009 * data = (STR_REWD_009 *)dataorg;
char* tempName = reinterpret_cast<char*>(&data->szNextTriggerSN) - 2;
dword hash = MakeStrHash(tempName);
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Execute Quest Trigger %s (%u)",opcode,tempName,hash);
return;
}
//Reset Stats.
if(opcode==10)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Reset Stats to default values",opcode);
return;
}
//Update Object Var..
if(opcode==11)
{
STR_REWD_011 * data = (STR_REWD_011 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Update variable",opcode);
if(data->btWho==0)
{
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Update ObjVar[%i] %s %i, who=%i (NPC)",data->nVarNo,Operators(data->btOp,buffero),data->iValue,data->btWho);
}
else if (data->btWho==1)
{
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Update ObjVar[%i] %s %i, who=%i (Event Object)",data->nVarNo,Operators(data->btOp,buffero),data->iValue,data->btWho);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Update ObjVar[%i] %s %i, who=?(%i)?",data->nVarNo,Operators(data->btOp,buffero),data->iValue,data->btWho);
}
return;
}
//NPC Speak...
if(opcode==12)
{
//Log(MSG_INFO, "NPC trying to speak");
STR_REWD_012 * data = (STR_REWD_012 *)dataorg;
//Log(MSG_INFO,"\t\t\t\t\t ACT %.3i: NPC Speak (NOT CODED for Client) (CODED for Monsters / NPC)",opcode);
if(data->btMsgType == 1)
{
//Log(MSG_INFO,"\t\t\t\t\t\t |-> NPC Shouts LTB string %i, %s",data->iStrID,GServer->LtbstringQSD[data->iStrID]->LTBstring);
}
else if(data->btMsgType == 2)
{
//Log(MSG_INFO,"\t\t\t\t\t\t |-> NPC Announces LTB string %i, %s",data->iStrID,GServer->LtbstringQSD[data->iStrID]->LTBstring);
}
else
{
//Log(MSG_INFO,"\t\t\t\t\t\t |-> NPC ?(%i)? LTB string %i, %s",data->btMsgType,data->iStrID,GServer->LtbstringQSD[data->iStrID]->LTBstring);
}
return;
}
//Unknown (execute quest trigger?)
if(opcode==13)
{
STR_REWD_013 * data = (STR_REWD_013 *)dataorg;
char* tempName = reinterpret_cast<char*>(&data->szTriggerName) - 2;
dword hash = MakeStrHash(tempName);
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Execute Quest Trigger %s (%u) (who %u, isec %u, nexttrigger %u)",opcode,tempName,hash,data->btWho,data->iSec,data->m_HashNextTrigger);
return;
}
//Learn Skill
if(opcode==14)
{
STR_REWD_014 * data = (STR_REWD_014 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Learn Skill %i (%s), (op %u)",opcode,data->iSkillNo,GServer->GetSTLSkillByID(data->iSkillNo),data->btOp);
return;
}
//Set Quest Flag
if(opcode==15)
{
STR_REWD_015 * data = (STR_REWD_015 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set Quest Flag[%u]=%i",opcode,data->nSN,data->btOp);
return;
}
//Unknown...
if(opcode==16)
{
STR_REWD_016 * data = (STR_REWD_016 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown (NOT CODED), (op %u)",opcode,data->nGroupSN);
return;
}
//reset all quest flags...
if(opcode==17)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Reset All Quest Flags",opcode);
return;
}
//Send Announcment...
if(opcode==18)
{
STR_REWD_018 * data = (STR_REWD_018 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Send Announcment (NOT CODED), (strid %u, ncnt %u)",opcode,data->iStrID,data->nCnt);
return;
}
//Execute Quest Trigger in Other Map...
if(opcode==19)
{
STR_REWD_019 * data = (STR_REWD_019 *)dataorg;
char* tempName = reinterpret_cast<char*>(&data->TriggerName) - 2;
dword hash = MakeStrHash(tempName);
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Execute Quest %s (hash %u) in Other Map %i (%s) for team %i (NOT CODED for Client) (CODED for Monsters / NPC), (triggerlength %u)",opcode,tempName,hash,data->nZoneNo,GServer->GetSTLZoneNameByID(data->nZoneNo),data->nTeamNo,data->nTriggerLength);
return;
}
//PvP Status...
if(opcode==20)
{
STR_REWD_020 * data = (STR_REWD_020 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: PvP Status set to %i (for maps mainly) (CODED FOR PLAYERS)",opcode,data->btNoType);
return;
}
//Set Respawn Position...
if(opcode==21)
{
STR_REWD_021 * data = (STR_REWD_021 *)dataorg;
float X=(float)(data->iX)/((float)100);
float Y=(float)(data->iY)/((float)100);
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set Respawn Position to current map [%.2f;%.2f].",opcode,X,Y);
return;
}
//Unknown...
if(opcode==22)
{
STR_REWD_022 * data = (STR_REWD_022 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown (NOT CODED), (op %u)",opcode,data->btOp);
return;
}
//Raise Clan Grade
if(opcode==23)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Raise clan grade (+1) (NOT FULLY CODED) ",opcode);
return;
}
//Clan Money...
if(opcode==24)
{
STR_REWD_024 * data = (STR_REWD_024 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Clan Money btop=%i, money %i (NOT CODED)",opcode,data->btOP,data->iMONEY);
return;
}
//Clan Points...
if(opcode==25)
{
STR_REWD_025 * data = (STR_REWD_025 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Clan Points %s %i",opcode,Operators(data->btOP,buffero),data->nPOINT);
return;
}
//Clan Skill...
if(opcode==26)
{
STR_REWD_026 * data = (STR_REWD_026 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Clan Skill (NOT CODED), (skill %u,op %u)",opcode,data->nSkillNo,data->btOP);
return;
}
//Clan Contribution...
if(opcode==27)
{
STR_REWD_027 * data = (STR_REWD_027 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Clan Contribution (NOT CODED), (cont %u,op %u)",opcode,data->nCONT,data->btOP);
return;
}
//Clan teleport
if(opcode==28)
{
STR_REWD_028 * data = (STR_REWD_028 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Teleport all me and my clan members to map %i at (%.2f,%.2f) random range %i ",opcode,data->nZoneNo,(float)(data->iX/100),(float)(data->iY/100),data->iRange);
return;
}
//LMA: Lua?
if(opcode==29)
{
STR_REWD_029 * data = (STR_REWD_029 *)dataorg;
char* tempName = reinterpret_cast<char*>(&data->luaName)-2;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: execute Lua %s (luaLen=%u) (NOT CODED, CLIENT SIDE ONLY?)",opcode,tempName,data->luaLen);
return;
}
//Unspawn a NPC
if(opcode==34)
{
STR_REWD_034 * data = (STR_REWD_034 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Removing previously selected NPC. (op %u)",opcode,data->btOP);
return;
}
//Really unknown :)
LogSp(MSG_WARNING,"\t\t\t\t\t ACT %.3i: Impossible to export QSD opcode, size %u",opcode,size-8);
return;
}
bool VcfMaterializer::_materializeNext(seqan::Dna5String & seq,
MethylationLevels * levels,
std::vector<SmallVarInfo> & varInfos,
std::vector<std::pair<int, int> > & breakpoints,
int & rID,
int & haplotype)
{
if (levels)
SEQAN_CHECK(!empty(methFastaFileName), "Must initialize with methylation FASTA file for levels");
if (empty(vcfFileName))
{
if (currRID >= (int)(numSeqs(faiIndex) - 1))
return false;
currRID += 1;
rID = currRID;
readSequence(seq, faiIndex, currRID);
if (levels && !empty(methFastaFileName))
{
_loadLevels(currRID);
swap(*levels, currentLevels);
}
// Build identity PositionMap.
TJournalEntries journal;
reinit(journal, length(seq));
posMap.reinit(journal);
GenomicInterval gi(0, length(seq), 0, length(seq));
seqan::String<PositionMap::TInterval> intervals;
appendValue(intervals, PositionMap::TInterval(gi.svBeginPos, gi.svEndPos, gi));
createIntervalTree(posMap.svIntervalTree, intervals);
createIntervalTree(posMap.svIntervalTreeSTL, intervals);
return true;
}
// Number of sequences.
int numSeqs = length(contigNames(context(vcfFileIn)));
// Stop if there are no more haplotypes to materialize.
if (currRID >= (numSeqs - 1) && nextHaplotype == numHaplotypes)
return false;
// Load variants for next contig if necessary.
if (currRID == -1 || nextHaplotype == numHaplotypes)
{
currRID += 1;
nextHaplotype = 0;
_loadVariantsForContig(contigVariants, currRID);
readSequence(contigSeq, faiIndex, currRID);
if (levels && !empty(methFastaFileName))
_loadLevels(currRID);
}
// Materialize variants for the current haplotype.
VariantMaterializer varMat(rng, contigVariants, *methOptions);
if (levels)
varMat.run(seq, posMap, *levels, varInfos, breakpoints, contigSeq, currentLevels, nextHaplotype);
else
varMat.run(seq, posMap, varInfos, breakpoints, contigSeq, nextHaplotype);
// Write out rID and haploty
rID = currRID;
haplotype = nextHaplotype++;
return true;
}
void CG_GGVar::add(CallableData* p,const String& s,int f)
{
CG_GGVar& gi(CG_GGVar::current());
arr_1t<String> ap = string_split(s, ".");
size_t n = ap.size();
if(n==0)
{
return;
}
if(n==1)
{
gi[s].kptr(p);
return;
}
if(f!=0)
{
gi[ap[n-1]].kptr(p);
}
VariantTable *pt=&gi;
for(size_t i=0;i<n;i++)
{
if(i+1==n)
{
if (i == 1 && _bInited)
{
gi[s].kptr(p);
}
(*pt)[ap[i]].kptr(p);
break;
}
intptr_t d=pt->find1(ap[i]);
if(d>=0)
{
pt=pt->get(d).second.ptr<VariantTable>();
if (!pt)
{
return;
}
}
else
{
String libname=string_join(ap.begin(),ap.begin()+i+1,".");
DataPtrT<CallableModule> tb = new CallableModule(libname);
(*pt)[ap[i]].kptr(tb);pt=&tb->value;
if (i == 1 && _bInited)
{
gi[ap[0]+"."+ap[1]].kptr(tb);
}
}
}
}
//LMA: We export AIP Actions here
void CWorldServer::ExportAipDataA(byte* dataorg,int size,int opcode)
{
UINT itemtype=0;
UINT itemnum=0;
//Unknown
if(opcode==0)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown",opcode);
return;
}
//Action
if(opcode==1)
{
STR_AI_ACT_001 * data = (STR_AI_ACT_001 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Action, (0x781) %i",opcode,data->cAction);
return;
}
//Say LTB string.
if(opcode==2)
{
STR_AI_ACT_002 * data = (STR_AI_ACT_002 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Say LTB String %i (%s) (NOT CODED but OK since client Side)",opcode,data->iStrID,GServer->Ltbstring[data->iStrID]->LTBstring);
return;
}
//Move
if(opcode==3)
{
STR_AI_ACT_003 * data = (STR_AI_ACT_003 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Move from current position, distance %i at stance %i",opcode,data->iDistance,data->cSpeed);
return;
}
//Move 2
if(opcode==4)
{
STR_AI_ACT_004 * data = (STR_AI_ACT_004 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Move from spawn position, distance %i at stance %i",opcode,data->iDistance,data->cSpeed);
return;
}
//Move 3
if(opcode==5)
{
STR_AI_ACT_005 * data = (STR_AI_ACT_005 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Move from a char's position, distance 2 at stance %i",opcode,data->cSpeed);
return;
}
//attack a player if ok with some stuff...
if(opcode==6)
{
STR_AI_ACT_006 * data = (STR_AI_ACT_006 *)dataorg;
char buffer[20];
char buffer1[20];
if(data->cMoreLess == 0)
{
sprintf(buffer,"biggest");
}
else
{
sprintf(buffer,"lowest");
}
switch(data->cAbType)
{
case 0: //level
sprintf(buffer1,"level");
break;
case 1: //Attack power
sprintf(buffer1,"attack power");
break;
case 2: //defense
sprintf(buffer1,"defense");
break;
case 3: //Magic Def
sprintf(buffer1,"MDEF");
break;
case 4: // HP
sprintf(buffer1,"HP");
break;
case 5: // Charm
sprintf(buffer1,"charm");
break;
}
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Attacks a player within distance %i if player has %s %s",opcode,data->iDistance,buffer, buffer1);
return;
}
//Unknown
if(opcode==7)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown",opcode);
return;
}
//Move 4
if(opcode==8)
{
STR_AI_ACT_008 * data = (STR_AI_ACT_008 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Monster moves to %i %% between source and current position at stance %i ",opcode,data->iDistance,data->cSpeed);
return;
}
//Convert to another monster.
if(opcode==9)
{
STR_AI_ACT_009 * data = (STR_AI_ACT_009 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Converts to monster %i (%s)",opcode,data->wMonster,GServer->GetSTLMonsterNameByID(data->wMonster));
return;
}
//Spawn monsters.
if(opcode==10)
{
STR_AI_ACT_010 * data = (STR_AI_ACT_010 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn 1 monster %i near me",opcode,data->wMonster,GServer->GetSTLMonsterNameByID(data->wMonster));
return;
}
//Call for backup..
if(opcode==11)
{
STR_AI_ACT_011 * data = (STR_AI_ACT_011 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Call for backup, range %i max %i monsters",opcode,data->iDistance,data->iNumOfMonster);
return;
}
//Attack.
if(opcode==12)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Attacks NearChar",opcode);
return;
}
//Attack.
if(opcode==13)
{
STR_AI_ACT_013 * data = (STR_AI_ACT_013 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Attacks FindChar",opcode);
return;
}
//Unknown
if(opcode==14)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown",opcode);
return;
}
//retaliates.
if(opcode==15)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Retaliates against the last player who hit me",opcode);
return;
}
//run away.
if(opcode==16)
{
STR_AI_ACT_016 * data = (STR_AI_ACT_016 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Runs away, distance %i",opcode,data->iDistance);
return;
}
//drop item.
if(opcode==17)
{
STR_AI_ACT_017 * data17 = (STR_AI_ACT_017 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Drops 1 item amongst:",opcode);
for(int k=0;k<6;k++)
{
int nItem = data17->items[k];
if (nItem==0)
continue;
if(k==5&&nItem==0xCDCD)
continue;
itemtype=gi(nItem,0);
itemnum=gi(nItem,1);
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Item %u : (%i:%i), %s %s",nItem,itemtype,itemnum,GServer->GetSTLItemPrefix(itemtype,itemnum),GServer->GetSTLObjNameByID(itemtype,itemnum));
}
return;
}
//Unknown
if(opcode==18)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown",opcode);
return;
}
//Attack (same as 12)
if(opcode==19)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Attacks NearChar",opcode);
return;
}
//Spawn monster
if(opcode==20)
{
STR_AI_ACT_020 * data = (STR_AI_ACT_020 *)dataorg;
if(data->btPos == 0)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn monster %i (%s) distance %i ",opcode,data->cMonster,GServer->GetSTLMonsterNameByID(data->cMonster),data->iDistance);
}
else if(data->btPos == 1)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn monster %i (%s) distance %i ",opcode,data->cMonster,GServer->GetSTLMonsterNameByID(data->cMonster),data->iDistance);
}
else if(data->btPos == 2)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn monster %i (%s) distance %i near target",opcode,data->cMonster,GServer->GetSTLMonsterNameByID(data->cMonster),data->iDistance);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn monster %i (%s) distance %i near ??? (%i)",opcode,data->cMonster,GServer->GetSTLMonsterNameByID(data->cMonster),data->iDistance,data->btPos);
}
return;
}
//Unknown
if(opcode==21)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown",opcode);
return;
}
//Unknown
if(opcode==22)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Unknown",opcode);
return;
}
//ghostseeds and ghosts and player summons commit suicide
if(opcode==23)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Time to suicide",opcode);
return;
}
//Do Skill
if(opcode==24)
{
STR_AI_ACT_024 * data = (STR_AI_ACT_024 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Monster does skill %i (%s) ",opcode,data->nSkill,GServer->GetSTLSkillByID(data->nSkill));
return;
}
//Set Variable.
if(opcode==25)
{
STR_AI_ACT_025 * data = (STR_AI_ACT_025 *)dataorg;
char buffer[3];
switch(data->btOp)
{
case 5:
sprintf(buffer,"=");
break;
case 6:
sprintf(buffer,"+=");
break;
case 7:
sprintf(buffer,"-=");
break;
case 9:
sprintf(buffer,"++");
break;
default:
sprintf(buffer,"??");
break;
}
if(data->btVarIDX==0)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set ObjVar[%i] (eventID) %s %i ",opcode,data->btVarIDX,buffer,data->iValue);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set ObjVar[%i] %s %i ",opcode,data->btVarIDX,buffer,data->iValue);
}
return;
}
//set variable 2 (world?)
if(opcode==26)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set variable (world?) (NOT CODED)",opcode);
return;
}
//set variable 2 (economy?)
if(opcode==27)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set variable (economy?) (NOT CODED)",opcode);
return;
}
//shouts / announces LTB String.
if(opcode==28)
{
STR_AI_ACT_028 * data = (STR_AI_ACT_028 *)dataorg;
switch(data->btMsgType)
{
case 0: //whisper to client
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Whisper LTB string %i: %s",opcode,data->iStrID,GServer->Ltbstring[data->iStrID]->LTBstring);
break;
case 1: //shout to map
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Shouts LTB string %i: %s",opcode,data->iStrID,GServer->Ltbstring[data->iStrID]->LTBstring);
}
break;
case 2: //announce to server.
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Announces LTB string %i: %s",opcode,data->iStrID,GServer->Ltbstring[data->iStrID]->LTBstring);
}
break;
default:
{
//?
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Tells(%i)? LTB string %i: %s (NOT CODED)",opcode,data->btMsgType,data->iStrID,GServer->Ltbstring[data->iStrID]->LTBstring);
}
break;
}
return;
}
//moves to my owner location..
if(opcode==29)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Moves to owner's location",opcode);
return;
}
//Do Quest Trigger.
if(opcode==30)
{
STR_AI_ACT_030 * data = (STR_AI_ACT_030 *)dataorg;
char* tempName = reinterpret_cast<char*>(&data->szTrigger) - 2;
dword hash = MakeStrHash(tempName);
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Do quest trigger %s, %u",opcode,tempName,hash);
return;
}
//monster attacks owner's target..
if(opcode==31)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Monster attacks owner's target",opcode);
return;
}
//Set Zone ?
if(opcode==32)
{
STR_AI_ACT_032 * data = (STR_AI_ACT_032 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set Pvp to %i in Zone %i",opcode,data->btOnOff,data->nZoneNo);
return;
}
//Set Zone ?
if(opcode==33)
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set Zone ? (NOT CODED)",opcode);
return;
}
//Gives Item to caller.
if(opcode==34)
{
STR_AI_ACT_034 * data = (STR_AI_ACT_034 *)dataorg;
char itemtypes[15] = {4,0,0,0,0,0,0,0,0,0,1,2,2,4,3};
//LMA: exact way.
itemtype = GServer->gi(data->nItemNum,0);
itemnum = GServer->gi(data->nItemNum,1);
int count = data->nCount;
int durability=100;
if( itemtypes[itemtype] == 0 )
{
durability = GServer->STB_ITEM[itemtype-1].rows[itemnum][29];
}
if (durability==0)
{
durability=100;
}
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Gives %i item %i::%i (%s %s), durability %i to master",opcode,count,itemtype,itemnum,GServer->GetSTLItemPrefix(itemtype,itemnum),GServer->GetSTLObjNameByID(itemtype,itemnum),durability);
return;
}
//Set Variable.
if(opcode==35)
{
STR_AI_ACT_035 * data = (STR_AI_ACT_035 *)dataorg;
char buffer[3];
switch(data->btOp)
{
case 5:
sprintf(buffer,"=");
break;
case 6:
sprintf(buffer,"+=");
break;
case 7:
sprintf(buffer,"-=");
break;
case 9:
sprintf(buffer,"++");
break;
default:
sprintf(buffer,"?(%i)?",data->btOp);
break;
}
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Set monster var[%i] %s %i ",opcode,data->nVarIDX,buffer,data->iValue);
return;
}
//spawn monster with a master?
if(opcode==36)
{
STR_AI_ACT_036 * data = (STR_AI_ACT_036 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: Spawn monster %i (%s) with master %i near me",opcode,data->nMonster,GServer->GetSTLMonsterNameByID(data->nMonster),data->btMaster);
return;
}
//spawn monster with btmaster?
if(opcode==37)
{
STR_AI_ACT_037 * data = (STR_AI_ACT_037 *)dataorg;
if(data->nPos == 0) //spawn monster in a circle with radius iDistance around my current position
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: spawn monster %i (%s) with master %i near me",opcode,data->nMonster,GServer->GetSTLMonsterNameByID(data->nMonster),data->btMaster);
}
else if(data->nPos == 1) //spawn monster in a circle with radius iDistance around my destiny position
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: spawn monster %i (%s) with master %i near master",opcode,data->nMonster,GServer->GetSTLMonsterNameByID(data->nMonster),data->btMaster);
}
else if(data->nPos == 2) //spawn monster in a circle with radius iDistance around my target's current position
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: spawn monster %i (%s) with master %i near target",opcode,data->nMonster,GServer->GetSTLMonsterNameByID(data->nMonster),data->btMaster);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t ACT %.3i: spawn monster %i (%s) with master %i near ?(%i)?",opcode,data->nMonster,GServer->GetSTLMonsterNameByID(data->nMonster),data->btMaster,data->nPos);
}
return;
}
//Really unknown :)
LogSp(MSG_WARNING,"\t\t\t\t\t ACT %.3i: Impossible to export AIP opcode, size %i",opcode,size-8);
return;
}
virtual QRectF bounding_rect() const { return gi()->boundingRect() ; }
GroupInfo FloatingGroup::groupInfo()
{
GroupInfo gi("floating", i18n("Floating Group"));
return gi;
}
void dgCollisionDeformableSolidMesh::ResolvePositionsConstraints (dgFloat32 timestep)
{
dgAssert (m_myBody);
dgInt32 strideInBytes = sizeof (dgVector) * m_clustersCount + sizeof (dgMatrix) * m_clustersCount + sizeof (dgMatrix) * m_particles.m_count;
m_world->m_solverMatrixMemory.ExpandCapacityIfNeessesary (1, strideInBytes);
dgVector* const regionCom = (dgVector*)&m_world->m_solverMatrixMemory[0];
dgMatrix* const sumQiPi = (dgMatrix*) ®ionCom[m_clustersCount];
dgMatrix* const covarianceMatrix = (dgMatrix*) &sumQiPi[m_clustersCount];
const dgFloat32* const masses = m_particles.m_unitMass;
dgVector zero (dgFloat32 (0.0f));
for (dgInt32 i = 0; i < m_clustersCount; i ++) {
regionCom[i] = zero;
}
for (dgInt32 i = 0; i < m_particles.m_count; i ++) {
dgVector mass (masses[i]);
const dgVector& r = m_posit[i];
const dgVector& r0 = m_shapePosit[i];
dgVector mr (r.Scale4(masses[i]));
covarianceMatrix[i] = dgMatrix (r0, mr);
const dgInt32 start = m_clusterPositStart[i];
const dgInt32 count = m_clusterPositStart[i + 1] - start;
for (dgInt32 j = 0; j < count; j ++) {
dgInt32 index = m_clusterPosit[start + j];
regionCom[index] += mr;
}
}
for (dgInt32 i = 0; i < m_clustersCount; i ++) {
dgVector mcr (regionCom[i]);
regionCom[i] = mcr.Scale4 (dgFloat32 (1.0f) / m_clusterMass[i]);
const dgVector& cr0 = m_clusterCom0[i];
sumQiPi[i] = dgMatrix (cr0, mcr.CompProduct4(dgVector::m_negOne));
}
for (dgInt32 i = 0; i < m_particles.m_count; i ++) {
const dgInt32 start = m_clusterPositStart[i];
const dgInt32 count = m_clusterPositStart[i + 1] - start;
const dgMatrix& covariance = covarianceMatrix[i];
for (dgInt32 j = 0; j < count; j ++) {
dgInt32 index = m_clusterPosit[start + j];
dgMatrix& QiPi = sumQiPi[index];
QiPi.m_front += covariance.m_front;
QiPi.m_up += covariance.m_up;
QiPi.m_right += covariance.m_right;
}
}
dgVector beta0 (dgFloat32 (0.93f));
//dgVector beta0 (dgFloat32 (0.0f));
dgVector beta1 (dgVector::m_one - beta0);
dgFloat32 stiffness = dgFloat32 (0.3f);
for (dgInt32 i = 0; i < m_clustersCount; i ++) {
dgMatrix& QiPi = sumQiPi[i];
dgMatrix S (QiPi * QiPi.Transpose4X4());
dgVector eigenValues;
S.EigenVectors (eigenValues, m_clusterRotationInitialGuess[i]);
m_clusterRotationInitialGuess[i] = S;
#ifdef _DEBUG_____
dgMatrix P0 (QiPi * QiPi.Transpose4X4());
dgMatrix D (dgGetIdentityMatrix());
D[0][0] = eigenValues[0];
D[1][1] = eigenValues[1];
D[2][2] = eigenValues[2];
dgMatrix P1 (S.Transpose4X4() * D * S);
dgAssert (P0.TestSymetric3x3());
dgAssert (P1.TestSymetric3x3());
dgMatrix xx (P1 * P0.Symetric3by3Inverse());
dgAssert (dgAbsf (xx[0][0] - dgFloat32 (1.0f)) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[1][1] - dgFloat32 (1.0f)) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[2][2] - dgFloat32 (1.0f)) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[0][1]) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[0][2]) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[1][0]) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[1][2]) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[2][0]) < dgFloat32 (1.0e-3f));
dgAssert (dgAbsf (xx[2][1]) < dgFloat32 (1.0e-3f));
#endif
eigenValues = eigenValues.InvSqrt();
dgMatrix m;
m.m_front = S.m_front.CompProduct4(eigenValues.BroadcastX());
m.m_up = S.m_up.CompProduct4(eigenValues.BroadcastY());
m.m_right = S.m_right.CompProduct4(eigenValues.BroadcastZ());
m.m_posit = dgVector::m_wOne;
dgMatrix invS (S.Transpose4X4() * m);
dgMatrix R (invS * QiPi);
dgMatrix A (m_clusterAqqInv[i] * QiPi);
QiPi.m_front = A.m_front.CompProduct4(beta0) + R.m_front.CompProduct4(beta1);
QiPi.m_up = A.m_up.CompProduct4(beta0) + R.m_up.CompProduct4(beta1);
QiPi.m_right = A.m_right.CompProduct4(beta0) + R.m_right.CompProduct4(beta1);
}
dgVector invTimeScale (stiffness / timestep);
dgVector* const veloc = m_particles.m_veloc;
for (dgInt32 i = 0; i < m_particles.m_count; i ++) {
const dgInt32 start = m_clusterPositStart[i];
const dgInt32 count = m_clusterPositStart[i + 1] - start;
dgVector v (dgFloat32 (0.0f));
const dgVector& p = m_posit[i];
const dgVector& p0 = m_shapePosit[i];
for (dgInt32 j = 0; j < count; j ++) {
dgInt32 index = m_clusterPosit[start + j];
const dgMatrix& matrix = sumQiPi[index];
dgVector gi (matrix.RotateVector(p0 - m_clusterCom0[index]) + regionCom[index]);
v += ((gi - p).CompProduct4(invTimeScale).Scale4 (m_clusterWeight[index]));
}
veloc[i] += v;
}
// resolve collisions here
//for now just a hack a collision plane until I get the engine up an running
for (dgInt32 i = 0; i < m_particles.m_count; i ++) {
dgVector p (m_basePosit + m_posit[i].m_y);
if (p.m_y < dgFloat32 (0.0f)) {
m_posit[i].m_y = -m_basePosit.m_y;
veloc[i].m_y = dgFloat32 (0.0f);
}
}
dgVector time (timestep);
dgVector minBase(dgFloat32 (1.0e10f));
dgVector minBox (dgFloat32 (1.0e10f));
dgVector maxBox (dgFloat32 (-1.0e10f));
dgMatrix matrix (m_myBody->GetCollision()->GetGlobalMatrix().Inverse());
for (dgInt32 i = 0; i < m_particles.m_count; i ++) {
m_posit[i] += veloc[i].CompProduct4 (time);
m_particles.m_posit[i] = matrix.TransformVector(m_posit[i] + m_basePosit);
minBase = minBase.GetMin (m_posit[i]);
minBox = minBox.GetMin(m_particles.m_posit[i]);
maxBox = maxBox.GetMax(m_particles.m_posit[i]);
}
minBase = minBase.Floor();
dgVector mask ((minBase < dgVector (dgFloat32 (0.0f))) | (minBase >= dgVector (dgFloat32 (DG_SOFTBODY_BASE_SIZE))));
dgInt32 test = mask.GetSignMask();
if (test & 0x07) {
dgVector offset (((minBase < dgVector (dgFloat32 (0.0f))) & dgVector (dgFloat32 (DG_SOFTBODY_BASE_SIZE/2))) +
((minBase >= dgVector (dgFloat32 (DG_SOFTBODY_BASE_SIZE))) & dgVector (dgFloat32 (-DG_SOFTBODY_BASE_SIZE/2))));
m_basePosit -= offset;
for (dgInt32 i = 0; i < m_particles.m_count; i ++) {
m_posit[i] += offset;
}
}
// integrate each particle by the deformation velocity, also calculate the new com
// calculate the new body average velocity
// if (m_myBody->m_matrixUpdate) {
// myBody->m_matrixUpdate (*myBody, myBody->m_matrix, threadIndex);
// }
// the collision changed shape, need to update spatial structure
// UpdateCollision ();
// SetCollisionBBox (m_rootNode->m_minBox, m_rootNode->m_maxBox);
SetCollisionBBox (minBox, maxBox);
}
/////////////////////////////////////////////////////
////
////
//// OTHER damage related stuff.
////
////
/////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//
// Function: EnoughDamage3D
// Date: 08/06/99
// Author: DAW
//
//Description:
//
//////////////////////////////////////////////////////////////////////
bool FormationItem::EnoughDamage3D(ItemPtr currtarget)
{
//DEADCODE JIM 22/03/00 if ((duty&DUTYMASK)==DC_WW)
//DEADCODE JIM 22/03/00 return (currtarget->Status.deadtime!=0);
//DEADCODE JIM 22/03/00 else
if (!currtarget)
return true;
else
if (currtarget->Status.size>=FORMATIONSIZE)
{
FormationItemPtr curr=*currtarget;
if (curr->Status.deadtime && !curr->leader)
return false;
else
return true;
}
else
{
UniqueID SGT=currtarget->SGT;
if (SGT==UID_NULL)
SGT=currtarget->uniqueID.count;
ItemPtr test=*Persons2::ConvertPtrUID(SGT);
//DeadCode JIM 20Oct00 int lowestdamage=900;
int scan=-1;
int totaltokens=0,deadtokens=0;
int totalpoints=0,deadpoints=0;
if (!test)
return false;
else
{
do{
totalpoints+=500; //MS 06/05/99
for (GroupItterator gi(test->shape,test->Anim);gi;gi++)
{
if (gi.AnimDataMAD().itemstate)
{
deadpoints+=gi.DamageWeight()*gi.AnimDataMAD().itemstate;
if (gi.IsStoresToken())
deadtokens++;
}
if (gi.IsStoresToken())
totaltokens++;
}
while (++scan<IllegalSepID)
{
if (scan<WayPointBAND || scan>=WayPointBANDEND)
if ((test=*Persons2::ConvertPtrUID(UniqueID(scan)))!=NULL)
if (test->SGT==SGT && test->shape!=EMPTY)
if (Persons2::getbandfromUID(UniqueID(scan))!=BritAAASiteBAND)
break;
}
}while (scan<IllegalSepID);
if (totaltokens)
if (totaltokens*2<deadtokens*3)
return true;
else
return false;
else
if (totalpoints<deadpoints)
return true;
else
return false;
}
}
}
A getSigv(void){R gi(sigvFlag);}
void CG_GGVar::_init()
{
CG_GGVar& gi(*this);
gi.reserve(4*1024);
gi.add(new CallableWrapT<String>("1.0 beta"), "sys.VERSION");
gi.add_inner<CallableFunctionCaptureLocal>();
gi.add_inner<CallableFunctionSame>();
gi.add_inner<CallableTableProxyGlobal>();
gi.add_inner<CallableCommandNoop>();
gi.add_inner<CallableFunctionImport>();
gi.add_inner<CallableFunctionClone>();
gi.add_inner<CallableFunctionTypeId>();
gi.add_inner<CallableFunctionIsNil>();
gi.add_inner<CallableFunctionIsTable>();
gi.add_inner<CallableFunctionIsString>();
gi.add_inner<CallableFunctionIsArray>();
gi.add_inner<CallableFunctionIsNumber>();
gi.add_inner<CallableFunctionIsBoolean>();
gi.add_inner<CallableCommandClear>();
gi.add_inner<CallableCommandClc>();
gi.add_inner<CallableCommandExec>();
gi.add_inner<CallableCommandEval>();
gi.add_inner<CallableCommandLoadEwsl>();
gi.add_inner<CallableFunctionAssert>();
gi.add_inner<CallableFunctionHelp>();
gi.add_inner<CallableFunctionTranslate>();
gi.add_inner<CallableFunctionTranslateKT>();
gi.add_inner<CallableFunctionTranslateHT>();
gi.add_inner<CallableFunctionTranslateZT>();
init_module_number();
init_module_string();
init_module_table();
init_module_array();
init_module_io();
init_module_os();
init_module_math();
init_module_logger();
init_module_coroutine();
init_module_regex();
gi.add(NULL,"pcall");
gi.add(NULL,"map");
gi.add(NULL,"map_k");
gi.add(NULL,"reduce");
gi.add(NULL,"reduce_k");
gi.add(NULL,"select");
gi.add(NULL,"join");
gi.add(NULL,"array_concat");
gi.add(NULL, "#internal_end");
_bInited=true;
for (size_t i = 0; i < gi.size(); i++)
{
if (gi.get(i).first == "#internal_end") break;
gi.sm_vmap[gi.get(i).first] = new CG_Variable(VAR_SYSTEM, gi.get(i).first);
}
size_t n = gi.size();
for (size_t i = 0; i < n; i++)
{
CallableTableEx* p = dynamic_cast<CallableTableEx*>(gi.get(i).second.kptr());
if (!p) continue;
String lib = gi.get(i).first;
for (VariantTable::const_iterator it=p->value.begin();it!=p->value.end();++it)
{
gi[lib + "." + (*it).first] = (*it).second;
}
}
Executor ewsl;
ewsl.execute(
"\n"
"function pcall(fn,...)\n"
"{\n"
" try \n"
" return true,fn(...);\n"
" catch(...) \n"
" return false,...;\n"
"};\n"
"\n"
"function map(x,f)\n"
"{\n"
" local r=[];\n"
" for_each(v in x)\n"
" {\n"
" r.push(f(v));\n"
" }\n"
" return r;\n"
"};\n"
"function map_k(x,f)\n"
"{\n"
" local r=[];\n"
" local k=0;\n"
" for_each(v in x)\n"
" {\n"
" r.push(f(v,k++));\n"
" }\n"
" return r;\n"
"};\n"
"\n"
"function select(x,f)\n"
"{\n"
" local r=[];\n"
" for_each(v in x)\n"
" {\n"
" if(f(v)) r.push(v);\n"
" }\n"
" return r;\n"
"};\n"
"\n"
"function join(s,r)\n"
"{\n"
" local z=r;\n"
" return reduce_k(s,def(x,y,k)\n"
" {\n"
" return k==0?y#x..z..y;\n"
" });\n"
"};\n"
"function reduce(x,f,n)\n"
"{\n"
" for_each(v in x)\n"
" {\n"
" n=f(n,v); \n"
" }\n"
" return n;\n"
"};\n"
"function reduce_k(x,f,n)\n"
"{\n"
" local k=0;\n"
" for_each(v in x)\n"
" {\n"
" n=f(n,v,k++); \n"
" }\n"
" return n;\n"
"};\n"
"def array_concat(...)\n"
"{\n"
" local fn=[];\n"
" for_each(v in [...])\n"
" {\n"
" local n=length(v);\n"
" if(n>0) fn[end+1:end+n]=v[:];\n"
" }\n"
" return fn;\n"
"};\n"
"\n"
"def metatable_call2(v1,v2,fn)\n"
"{\n"
" local m1=getmetatable(v1);\n"
" if(m1!=nil)\n"
" {\n"
" local k1=m1[fn];\n"
" if(k1!=nil)\n"
" {\n"
" ...=k1(v1,v2);\n"
" if([...].length()==1) return ...;\n"
" }\n"
" }\n"
" local m2=getmetatable(v2);\n"
" if(m2!=nil)\n"
" {\n"
" local k2=m2[fn];\n"
" if(k2!=nil)\n"
" {\n"
" ...=k2(v1,v2);\n"
" if([...].length()==1) return ...;\n"
" }\n"
" }\n"
" throw 'bad argument to '..fn,v1,v2;\n"
"};\n"
"\n"
"def metatable_call1(v1,fn)\n"
"{\n"
" local m1=getmetatable(v1);\n"
" if(m1!=nil)\n"
" {\n"
" local k1=m1[fn];\n"
" if(k1!=nil)\n"
" {\n"
" ...=k1(v1);\n"
" if([...].length()==1) return ...;\n"
" }\n"
" }\n"
" throw 'bad argument to '..fn,v1;\n"
"};\n"
);
for(size_t i=0;i<ewsl.tb1.size();i++)
{
gi[ewsl.tb1.get(i).first]=ewsl.tb1.get(i).second;
}
}
A getSigb(void){R gi(sigbFlag);}
Z H1(siz){ND1 R(I)gi(a->r?*a->d:1);}
nlopt_result ccsa_quadratic_minimize(
unsigned n, nlopt_func f, void *f_data,
unsigned m, nlopt_constraint *fc,
nlopt_precond pre,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
nlopt_stopping *stop,
nlopt_opt dual_opt)
{
nlopt_result ret = NLOPT_SUCCESS;
double *xcur, rho, *sigma, *dfdx, *dfdx_cur, *xprev, *xprevprev, fcur;
double *dfcdx, *dfcdx_cur;
double *fcval, *fcval_cur, *rhoc, *gcval, *y, *dual_lb, *dual_ub;
double *pre_lb, *pre_ub;
unsigned i, ifc, j, k = 0;
dual_data dd;
int feasible;
double infeasibility;
unsigned mfc;
unsigned no_precond;
nlopt_opt pre_opt = NULL;
m = nlopt_count_constraints(mfc = m, fc);
if (nlopt_get_dimension(dual_opt) != m) return NLOPT_INVALID_ARGS;
sigma = (double *) malloc(sizeof(double) * (6*n + 2*m*n + m*7));
if (!sigma) return NLOPT_OUT_OF_MEMORY;
dfdx = sigma + n;
dfdx_cur = dfdx + n;
xcur = dfdx_cur + n;
xprev = xcur + n;
xprevprev = xprev + n;
fcval = xprevprev + n;
fcval_cur = fcval + m;
rhoc = fcval_cur + m;
gcval = rhoc + m;
dual_lb = gcval + m;
dual_ub = dual_lb + m;
y = dual_ub + m;
dfcdx = y + m;
dfcdx_cur = dfcdx + m*n;
dd.n = n;
dd.x = x;
dd.lb = lb;
dd.ub = ub;
dd.sigma = sigma;
dd.dfdx = dfdx;
dd.dfcdx = dfcdx;
dd.fcval = fcval;
dd.rhoc = rhoc;
dd.xcur = xcur;
dd.gcval = gcval;
dd.pre = pre; dd.pre_data = f_data;
dd.prec = NULL; dd.prec_data = NULL;
dd.scratch = NULL;
if (m) {
dd.prec = (nlopt_precond *) malloc(sizeof(nlopt_precond) * m);
dd.prec_data = (void **) malloc(sizeof(void *) * m);
if (!dd.prec || !dd.prec_data) {
ret = NLOPT_OUT_OF_MEMORY;
goto done;
}
for (i = ifc = 0; ifc < mfc; ++ifc) {
unsigned inext = i + fc[ifc].m;
for (; i < inext; ++i) {
dd.prec[i] = fc[ifc].pre;
dd.prec_data[i] = fc[ifc].f_data;
}
}
}
no_precond = pre == NULL;
if (dd.prec)
for (i = 0; i < m; ++i)
no_precond = no_precond && dd.prec[i] == NULL;
if (!no_precond) {
dd.scratch = (double*) malloc(sizeof(double) * (4*n));
if (!dd.scratch) {
free(sigma);
return NLOPT_OUT_OF_MEMORY;
}
pre_lb = dd.scratch + 2*n;
pre_ub = pre_lb + n;
pre_opt = nlopt_create(nlopt_get_algorithm(dual_opt), n);
if (!pre_opt) { ret = NLOPT_FAILURE; goto done; }
ret = nlopt_set_min_objective(pre_opt, g0, &dd);
if (ret < 0) goto done;
ret = nlopt_add_inequality_mconstraint(pre_opt, m, gi, &dd, NULL);
if (ret < 0) goto done;
ret = nlopt_set_ftol_rel(pre_opt, nlopt_get_ftol_rel(dual_opt));
if (ret < 0) goto done;
ret = nlopt_set_ftol_abs(pre_opt, nlopt_get_ftol_abs(dual_opt));
if (ret < 0) goto done;
ret = nlopt_set_maxeval(pre_opt, nlopt_get_maxeval(dual_opt));
if (ret < 0) goto done;
}
for (j = 0; j < n; ++j) {
if (nlopt_isinf(ub[j]) || nlopt_isinf(lb[j]))
sigma[j] = 1.0; /* arbitrary default */
else
sigma[j] = 0.5 * (ub[j] - lb[j]);
}
rho = 1.0;
for (i = 0; i < m; ++i) {
rhoc[i] = 1.0;
dual_lb[i] = y[i] = 0.0;
dual_ub[i] = HUGE_VAL;
}
dd.fval = fcur = *minf = f(n, x, dfdx, f_data);
stop->nevals++;
memcpy(xcur, x, sizeof(double) * n);
if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
feasible = 1; infeasibility = 0;
for (i = ifc = 0; ifc < mfc; ++ifc) {
nlopt_eval_constraint(fcval + i, dfcdx + i*n,
fc + ifc, n, x);
i += fc[ifc].m;
if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
}
for (i = 0; i < m; ++i) {
feasible = feasible && fcval[i] <= 0;
if (fcval[i] > infeasibility) infeasibility = fcval[i];
}
/* For non-feasible initial points, set a finite (large)
upper-bound on the dual variables. What this means is that,
if no feasible solution is found from the dual problem, it
will minimize the dual objective with the unfeasible
constraint weighted by 1e40 -- basically, minimizing the
unfeasible constraint until it becomes feasible or until we at
least obtain a step towards a feasible point.
Svanberg suggested a different approach in his 1987 paper, basically
introducing additional penalty variables for unfeasible constraints,
but this is easier to implement and at least as efficient. */
if (!feasible)
for (i = 0; i < m; ++i) dual_ub[i] = 1e40;
nlopt_set_min_objective(dual_opt, dual_func, &dd);
nlopt_set_lower_bounds(dual_opt, dual_lb);
nlopt_set_upper_bounds(dual_opt, dual_ub);
nlopt_set_stopval(dual_opt, -HUGE_VAL);
nlopt_remove_inequality_constraints(dual_opt);
nlopt_remove_equality_constraints(dual_opt);
while (1) { /* outer iterations */
double fprev = fcur;
if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
else if (feasible && *minf < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
if (++k > 1) memcpy(xprevprev, xprev, sizeof(double) * n);
memcpy(xprev, xcur, sizeof(double) * n);
while (1) { /* inner iterations */
double min_dual, infeasibility_cur;
int feasible_cur, inner_done;
unsigned save_verbose;
nlopt_result reti;
if (no_precond) {
/* solve dual problem */
dd.rho = rho; dd.count = 0;
save_verbose = ccsa_verbose;
ccsa_verbose = 0; /* no recursive verbosity */
reti = nlopt_optimize_limited(dual_opt, y, &min_dual,
0,
stop->maxtime
- (nlopt_seconds()
- stop->start));
ccsa_verbose = save_verbose;
if (reti < 0 || reti == NLOPT_MAXTIME_REACHED) {
ret = reti;
goto done;
}
dual_func(m, y, NULL, &dd); /* evaluate final xcur etc. */
}
else {
double pre_min;
for (j = 0; j < n; ++j) {
pre_lb[j] = MAX(lb[j], x[j] - sigma[j]);
pre_ub[j] = MIN(ub[j], x[j] + sigma[j]);
xcur[j] = x[j];
}
nlopt_set_lower_bounds(pre_opt, pre_lb);
nlopt_set_upper_bounds(pre_opt, pre_ub);
dd.rho = rho; dd.count = 0;
save_verbose = ccsa_verbose;
ccsa_verbose = 0; /* no recursive verbosity */
reti = nlopt_optimize_limited(pre_opt, xcur, &pre_min,
0, stop->maxtime
- (nlopt_seconds()
- stop->start));
ccsa_verbose = save_verbose;
if (reti < 0 || reti == NLOPT_MAXTIME_REACHED) {
ret = reti;
goto done;
}
/* evaluate final xcur etc */
dd.gval = g0(n, xcur, NULL, &dd);
gi(m, dd.gcval, n, xcur, NULL, &dd);
}
if (ccsa_verbose) {
printf("CCSA dual converged in %d iters to g=%g:\n",
dd.count, dd.gval);
for (i = 0; i < MIN(ccsa_verbose, m); ++i)
printf(" CCSA y[%d]=%g, gc[%d]=%g\n",
i, y[i], i, dd.gcval[i]);
}
fcur = f(n, xcur, dfdx_cur, f_data);
stop->nevals++;
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
feasible_cur = 1; infeasibility_cur = 0;
inner_done = dd.gval >= fcur;
for (i = ifc = 0; ifc < mfc; ++ifc) {
nlopt_eval_constraint(fcval_cur + i, dfcdx_cur + i*n,
fc + ifc, n, xcur);
i += fc[ifc].m;
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
}
for (i = ifc = 0; ifc < mfc; ++ifc) {
unsigned i0 = i, inext = i + fc[ifc].m;
for (; i < inext; ++i) {
feasible_cur = feasible_cur
&& fcval_cur[i] <= fc[ifc].tol[i-i0];
inner_done = inner_done &&
(dd.gcval[i] >= fcval_cur[i]);
if (fcval_cur[i] > infeasibility_cur)
infeasibility_cur = fcval_cur[i];
}
}
if ((fcur < *minf && (inner_done || feasible_cur || !feasible))
|| (!feasible && infeasibility_cur < infeasibility)) {
if (ccsa_verbose && !feasible_cur)
printf("CCSA - using infeasible point?\n");
dd.fval = *minf = fcur;
infeasibility = infeasibility_cur;
memcpy(fcval, fcval_cur, sizeof(double)*m);
memcpy(x, xcur, sizeof(double)*n);
memcpy(dfdx, dfdx_cur, sizeof(double)*n);
memcpy(dfcdx, dfcdx_cur, sizeof(double)*n*m);
/* once we have reached a feasible solution, the
algorithm should never make the solution infeasible
again (if inner_done), although the constraints may
be violated slightly by rounding errors etc. so we
must be a little careful about checking feasibility */
if (infeasibility_cur == 0) {
if (!feasible) { /* reset upper bounds to infin. */
for (i = 0; i < m; ++i) dual_ub[i] = HUGE_VAL;
nlopt_set_upper_bounds(dual_opt, dual_ub);
}
feasible = 1;
}
}
if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
else if (feasible && *minf < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
if (inner_done) break;
if (fcur > dd.gval)
rho = MIN(10*rho, 1.1 * (rho + (fcur-dd.gval) / dd.wval));
for (i = 0; i < m; ++i)
if (fcval_cur[i] > dd.gcval[i])
rhoc[i] =
MIN(10*rhoc[i],
1.1 * (rhoc[i] + (fcval_cur[i]-dd.gcval[i])
/ dd.wval));
if (ccsa_verbose)
printf("CCSA inner iteration: rho -> %g\n", rho);
for (i = 0; i < MIN(ccsa_verbose, m); ++i)
printf(" CCSA rhoc[%d] -> %g\n", i,rhoc[i]);
}
if (nlopt_stop_ftol(stop, fcur, fprev))
ret = NLOPT_FTOL_REACHED;
if (nlopt_stop_x(stop, xcur, xprev))
ret = NLOPT_XTOL_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
/* update rho and sigma for iteration k+1 */
rho = MAX(0.1 * rho, CCSA_RHOMIN);
if (ccsa_verbose)
printf("CCSA outer iteration: rho -> %g\n", rho);
for (i = 0; i < m; ++i)
rhoc[i] = MAX(0.1 * rhoc[i], CCSA_RHOMIN);
for (i = 0; i < MIN(ccsa_verbose, m); ++i)
printf(" CCSA rhoc[%d] -> %g\n", i, rhoc[i]);
if (k > 1) {
for (j = 0; j < n; ++j) {
double dx2 = (xcur[j]-xprev[j]) * (xprev[j]-xprevprev[j]);
double gam = dx2 < 0 ? 0.7 : (dx2 > 0 ? 1.2 : 1);
sigma[j] *= gam;
if (!nlopt_isinf(ub[j]) && !nlopt_isinf(lb[j])) {
sigma[j] = MIN(sigma[j], 10*(ub[j]-lb[j]));
/* use a smaller lower bound than Svanberg's
0.01*(ub-lb), which seems unnecessarily large */
sigma[j] = MAX(sigma[j], 1e-8*(ub[j]-lb[j]));
}
}
for (j = 0; j < MIN(ccsa_verbose, n); ++j)
printf(" CCSA sigma[%d] -> %g\n",
j, sigma[j]);
}
}
done:
nlopt_destroy(pre_opt);
if (dd.scratch) free(dd.scratch);
if (m) {
free(dd.prec_data);
free(dd.prec);
}
free(sigma);
return ret;
}
int main()
{
gi(n);
for
return 0;
}
le_int32 MarkToBasePositioningSubtable::process(const LETableReference &base, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode &success) const
{
LEGlyphID markGlyph = glyphIterator->getCurrGlyphID();
le_int32 markCoverage = getGlyphCoverage(base, (LEGlyphID) markGlyph, success);
if (markCoverage < 0) {
// markGlyph isn't a covered mark glyph
return 0;
}
LEPoint markAnchor;
const MarkArray *markArray = (const MarkArray *) ((char *) this + SWAPW(markArrayOffset));
le_int32 markClass = markArray->getMarkClass(markGlyph, markCoverage, fontInstance, markAnchor);
le_uint16 mcCount = SWAPW(classCount);
if (markClass < 0 || markClass >= mcCount) {
// markGlyph isn't in the mark array or its
// mark class is too big. The table is mal-formed!
return 0;
}
// FIXME: We probably don't want to find a base glyph before a previous ligature...
GlyphIterator baseIterator(*glyphIterator, (le_uint16) (lfIgnoreMarks /*| lfIgnoreLigatures*/));
LEGlyphID baseGlyph = findBaseGlyph(&baseIterator);
le_int32 baseCoverage = getBaseCoverage(base, (LEGlyphID) baseGlyph, success);
const BaseArray *baseArray = (const BaseArray *) ((char *) this + SWAPW(baseArrayOffset));
le_uint16 baseCount = SWAPW(baseArray->baseRecordCount);
if (baseCoverage < 0 || baseCoverage >= baseCount) {
// The base glyph isn't covered, or the coverage
// index is too big. The latter means that the
// table is mal-formed...
return 0;
}
const BaseRecord *baseRecord = &baseArray->baseRecordArray[baseCoverage * mcCount];
Offset anchorTableOffset = SWAPW(baseRecord->baseAnchorTableOffsetArray[markClass]);
const AnchorTable *anchorTable = (const AnchorTable *) ((char *) baseArray + anchorTableOffset);
LEPoint baseAnchor, markAdvance, pixels;
if (anchorTableOffset == 0) {
// this means the table is mal-formed...
glyphIterator->setCurrGlyphBaseOffset(baseIterator.getCurrStreamPosition());
return 0;
}
anchorTable->getAnchor(baseGlyph, fontInstance, baseAnchor);
fontInstance->getGlyphAdvance(markGlyph, pixels);
fontInstance->pixelsToUnits(pixels, markAdvance);
float anchorDiffX = baseAnchor.fX - markAnchor.fX;
float anchorDiffY = baseAnchor.fY - markAnchor.fY;
glyphIterator->setCurrGlyphBaseOffset(baseIterator.getCurrStreamPosition());
if (glyphIterator->isRightToLeft()) {
// FIXME: need similar patch to below; also in MarkToLigature and MarkToMark
// (is there a better way to approach this for all the cases?)
glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX, anchorDiffY, -markAdvance.fX, -markAdvance.fY);
} else {
LEPoint baseAdvance;
fontInstance->getGlyphAdvance(baseGlyph, pixels);
//JK: adjustment needs to account for non-zero advance of any marks between base glyph and current mark
GlyphIterator gi(baseIterator, (le_uint16)0); // copy of baseIterator that won't ignore marks
gi.next(); // point beyond the base glyph
while (gi.getCurrStreamPosition() < glyphIterator->getCurrStreamPosition()) { // for all intervening glyphs (marks)...
LEGlyphID otherMark = gi.getCurrGlyphID();
LEPoint px;
fontInstance->getGlyphAdvance(otherMark, px); // get advance, in case it's non-zero
pixels.fX += px.fX; // and add that to the base glyph's advance
pixels.fY += px.fY;
gi.next();
}
// end of JK patch
fontInstance->pixelsToUnits(pixels, baseAdvance);
glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - baseAdvance.fX, anchorDiffY - baseAdvance.fY, -markAdvance.fX, -markAdvance.fY);
}
return 1;
}
//LMA: We export QSD Conditions here
//void CWorldServer::ExportQSDData(byte* dataorg,int opcode,int size,CQuestTrigger::SQuestDatum* dataraw)
void CWorldServer::ExportQSDData(byte* dataorg,int size,int opcode)
{
char buffero[20];
char buffera[20];
UINT itemtype=0;
UINT itemnum=0;
//check Quest.
if(opcode==0)
{
STR_COND_000 * data = (STR_COND_000 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if Quest %i (%s) exists",opcode,data->iQuestSN,GServer->GetSTLQuestByID(data->iQuestSN));
return;
}
//check Quest Variable.
if(opcode==1)
{
STR_COND_001 * data = (STR_COND_001 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check %i Player's quest vars",opcode,data->iDataCnt);
for (int i=0;i<data->iDataCnt;i++)
{
dword address = i * sizeof(STR_QUEST_DATA);
address += (dword)dataorg;
address += 4;
STR_QUEST_DATA* curQst = (STR_QUEST_DATA*)address;
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Var[0x%04x (%u)][%i] %s %i",curQst->m_wVarTYPE,curQst->m_wVarTYPE,curQst->m_wVarNO,Operators(curQst->btOp,buffero),curQst->nValue);
}
return;
}
//check Quest Variable (same as opcode 1)
if(opcode==2)
{
STR_COND_002 * data = (STR_COND_002 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check %i Player's quest vars",opcode,data->iDataCnt);
for (int i=0;i<data->iDataCnt;i++)
{
dword address = i * sizeof(STR_QUEST_DATA);
address += (dword)dataorg;
address += 4;
STR_QUEST_DATA* curQst = (STR_QUEST_DATA*)address;
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Var[0x%04x (%u)][%i] %s %i",curQst->m_wVarTYPE,curQst->m_wVarTYPE,curQst->m_wVarNO,Operators(curQst->btOp,buffero),curQst->nValue);
}
return;
}
//check Stats
if(opcode==3)
{
STR_COND_003 * data = (STR_COND_003 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check %i Player's stats",opcode,data->iDataCnt);
for(int i = 0; i < data->iDataCnt; i++)
{
dword address = i * 0x0C;
address += (dword)dataorg;
address += 4;
STR_ABIL_DATA* curAbil = (STR_ABIL_DATA*)address;
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Check Stat %s %s %i",Abilities(curAbil->iType,buffera),Operators(curAbil->btOp,buffero),curAbil->iValue);
}
return;
}
//check items.
if(opcode==4)
{
STR_COND_004 * data = (STR_COND_004 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check %i Player's items",opcode,data->iDataCnt);
for(int i = 0; i < data->iDataCnt; i++)
{
dword address = i * 0x10;
address += (dword)dataorg;
address += 4;
STR_ITEM_DATA* curItem = (STR_ITEM_DATA*)address;
itemtype=gi(curItem->uiItemSN,0);
itemnum=gi(curItem->uiItemSN,1);
//where not reliable...
//if(curItem->iWhere!=13)
if(itemtype!=13)
{
if (curItem->uiItemSN==0)
{
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Check if equipped item in slot %i is %s (0:0)",curItem->iWhere,Operators(curItem->btOp,buffero),curItem->iRequestCnt);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Check Item %i (%i:%i, %s %s) %s %i, where %i",curItem->uiItemSN,itemtype,itemnum,GServer->GetSTLItemPrefix(itemtype,itemnum),GServer->GetSTLObjNameByID(itemtype,itemnum),Operators(curItem->btOp,buffero),curItem->iRequestCnt,curItem->iWhere);
}
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Check Quest Item %i (%i:%i, %s %s) %s %i, where %i",curItem->uiItemSN,itemtype,itemnum,GServer->GetSTLItemPrefix(itemtype,itemnum),GServer->GetSTLObjNameByID(itemtype,itemnum),Operators(curItem->btOp,buffero),curItem->iRequestCnt,curItem->iWhere);
}
}
return;
}
//check party
if(opcode==5)
{
STR_COND_005 * data = (STR_COND_005 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check Party btIsLeader %i, iLevel %i, btReversed %i (NOT CODED)",opcode,data->btIsLeader,data->iLevel,data->btReversed);
return;
}
//Near point
if(opcode==6)
{
STR_COND_006 * data = (STR_COND_006 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Player near point (%.2f,%.2f), map %i (%s), distance < %i",opcode,(float)(data->iX / 100),(float)(data->iY / 100),data->iZoneSN,GServer->GetSTLZoneNameByID(data->iZoneSN),data->iRadius);
return;
}
//world time
if(opcode==7)
{
STR_COND_007 * data = (STR_COND_007 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: World time (NOT CODED, begintime %u, endtime %u)",opcode,data->ulTime,data->ulEndTime);
return;
}
//Quest Time
if(opcode==8)
{
STR_COND_008 * data = (STR_COND_008 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check Player's quest time %s %u",opcode,Operators(data->btOp,buffero),data->ulTime);
return;
}
//Check Skill
if(opcode==9)
{
STR_COND_009 * data = (STR_COND_009 *)dataorg;
if(data->btOp)
{
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if skill %i (%s) DOES exist (sn2: %u)",opcode,data->iSkillSN1,GServer->GetSTLSkillByID(data->iSkillSN1),data->iSkillSN2);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if skill %i (%s) does NOT exist (sn2: %u)",opcode,data->iSkillSN1,GServer->GetSTLSkillByID(data->iSkillSN1),data->iSkillSN2);
}
return;
}
//Unknow
if(opcode==10)
{
STR_COND_010 * data = (STR_COND_010 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Unknown (NOT CODED) lowpc %u, highpc %u",opcode,data->btLowPcnt,data->btHighPcnt);
return;
}
//Object variable
if(opcode==11)
{
STR_COND_011 * data = (STR_COND_011 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Object variable",opcode);
LogSp(MSG_INFO,"\t\t\t\t\t\t |-> Check ObjVar[%i] %s %i (btwho %u)",data->nVarNo,Operators(data->btOp,buffero),data->iValue,data->btWho);
return;
}
//Select Object in zone.
if(opcode==12)
{
STR_COND_012 * data = (STR_COND_012 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Select Object %i in map %i (%s), IFO %i_%i.IFO (CODED FOR MONSTERS/NPC)",opcode,data->iEventID,data->iZone,GServer->GetSTLZoneNameByID(data->iZone),data->iX,data->iY);
return;
}
//Select NPC
if(opcode==13)
{
STR_COND_013 * data = (STR_COND_013 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Select NPC %i (%s)",opcode,data->iNpcNo,GServer->GetSTLMonsterNameByID(data->iNpcNo));
return;
}
//Check Quest Flag
if(opcode==14)
{
STR_COND_014 * data = (STR_COND_014 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check Quest Flag[%i] == %i",opcode,data->nSN,data->btOp);
return;
}
//Unknow
if(opcode==15)
{
STR_COND_015 * data = (STR_COND_015 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Unknown %u, %u (size %i) (NOT CODED)",opcode,data->nNumber1,data->nNumber2,size);
return;
}
//Zone Time
if(opcode==16)
{
STR_COND_016 * data = (STR_COND_016 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Zone Time (NOT CODED) (who %u, ultime %u, ulendtime %u)",opcode,data->btWho,data->ulTime,data->ulEndTime);
return;
}
//Compare two NPC & Obj Variables.
if(opcode==17)
{
STR_COND_017 * data = (STR_COND_017 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Does NPC %i (%s) ObjVar[%i] %s NPC %i %(%s) ObjVar[%i], junk1 %i, junk2 %i",
opcode,data->NpcVar1.iNpcNo,GServer->GetSTLMonsterNameByID(data->NpcVar1.iNpcNo),data->NpcVar1.nVarNo,
Operators(data->btOp,buffero),
data->NpcVar2.iNpcNo,GServer->GetSTLMonsterNameByID(data->NpcVar2.iNpcNo),
data->NpcVar2.nVarNo,data->NpcVar1.unused,data->NpcVar2.unused);
return;
}
//Time on Date
if(opcode==18)
{
STR_COND_018 * data = (STR_COND_018 *)dataorg;
if(data->btDate!=0)
{
LogSp(MSG_INFO,"\t\t\t\t\t CDT 0%i: Check day == %i and %.2i:%.2i:00<=time<=%.2i:%.2i:00",opcode,data->btDate,data->btHour1,data->btMin1,data->btHour2,data->btMin2);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t CDT 0%i: Check %.2i:%.2i:00<=time<=%.2i:%.2i:00",opcode,data->btHour1,data->btMin1,data->btHour2,data->btMin2);
}
return;
}
//Time on Day
if(opcode==19)
{
STR_COND_019 * data = (STR_COND_019 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Time on Day (NOT CODED) (weekday %u, hour1 %u, min1 %u, hour2 %u, min2 %u)",opcode,data->btWeekDay,data->btHour1,data->btMin1,data->btHour2,data->btMin2);
return;
}
//Unknow
if(opcode==20)
{
STR_COND_020 * data = (STR_COND_020 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Unknown (NOT CODED) (no1 %u, no2 %u)",opcode,data->iNo1,data->iNo2);
return;
}
//Near Selected NPC
if(opcode==21)
{
STR_COND_021 * data = (STR_COND_021 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Near Selected NPC, range %u (CODED FOR PLAYERS), (type, %u)",opcode,data->iRadius,data->btSelObjType);
return;
}
//Check Server/Channel
if(opcode==22)
{
STR_COND_022 * data = (STR_COND_022 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check Server/Channel %u, %u (NOT CODED)",opcode,data->nX,data->nY);
return;
}
//In Clan
if(opcode==23)
{
STR_COND_023 * data = (STR_COND_023 *)dataorg;
if(data->btReg == 1)
{
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if in Clan",opcode);
}
else if (data->btReg == 0)
{
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if NOT in Clan",opcode);
}
else
{
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: ?%i? Clan",opcode,data->btReg);
}
return;
}
//Clan Position
if(opcode==24)
{
STR_COND_024 * data = (STR_COND_024 *)dataorg;
char buffer[20];
switch(data->btOP)
{
case 0:
sprintf(buffer,"==");
break;
case 1:
sprintf(buffer,">");
break;
case 2:
sprintf(buffer,">=");
break;
case 3:
sprintf(buffer,"<");
break;
case 4:
sprintf(buffer,"<=");
break;
case 10:
sprintf(buffer,"!=");
break;
default:
sprintf(buffer,"?%i?",data->btOP);
break;
}
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if Clan Position is %s %i",opcode,buffer,data->nPOS);
return;
}
//Clan Contribution
if(opcode==25)
{
STR_COND_025 * data = (STR_COND_025 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Clan Contribution (NOT CODED) (ncont %u, op %u)",opcode,data->nCONT,data->btOP);
return;
}
//Clan Grade
if(opcode==26)
{
STR_COND_026 * data = (STR_COND_026 *)dataorg;
char buffer[20];
switch(data->btOP)
{
case 0:
sprintf(buffer,"==");
break;
case 1:
sprintf(buffer,">");
break;
case 2:
sprintf(buffer,">=");
break;
case 3:
sprintf(buffer,"<");
break;
case 4:
sprintf(buffer,"<=");
break;
case 10:
sprintf(buffer,"!=");
break;
default:
sprintf(buffer,"?%i?",data->btOP);
break;
}
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if Clan Grade is %s %i",opcode,buffer,data->nGRD);
return;
}
//Check Clan Points amount.
if(opcode==27)
{
STR_COND_027 * data = (STR_COND_027 *)dataorg;
char buffer[20];
switch(data->btOP)
{
case 0:
sprintf(buffer,"==");
break;
case 1:
sprintf(buffer,">");
break;
case 2:
sprintf(buffer,">=");
break;
case 3:
sprintf(buffer,"<");
break;
case 4:
sprintf(buffer,"<=");
break;
case 10:
sprintf(buffer,"!=");
break;
default:
sprintf(buffer,"?%i?",data->btOP);
break;
}
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Check if Clan Points is %s %i",opcode,buffer,data->nPOINT);
return;
}
//Clan Grade
if(opcode==28)
{
STR_COND_028 * data = (STR_COND_028 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Clan Grade (NOT CODED) (money %u, op %u)",opcode,data->iMONEY,data->btOP);
return;
}
//Clan Members
if(opcode==29)
{
STR_COND_029 * data = (STR_COND_029 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Clan Members (NOT CODED) (membercnt %u, op %u)",opcode,data->nMemberCNT,data->btOP);
return;
}
//Clan Skills
if(opcode==30)
{
STR_COND_030 * data = (STR_COND_030 *)dataorg;
LogSp(MSG_INFO,"\t\t\t\t\t CDT %.3i: Clan Skills (NOT CODED) (skiil1 %u, skill2 %u, op %u)",opcode,data->nSkill1,data->nSkill2,data->btOP);
return;
}
//Really unknown :)
LogSp(MSG_WARNING,"\t\t\t\t\t CDT %.3i: Impossible to export QSD opcode, size %u",opcode,size-8);
return;
}
I dj(I j) { I d; K a = gi(j), r = _jd(a); cd(a); d = Ki(r); cd(r); R d; }
