bool CMoveChecker::checkMove(TDataSetRow entityIndex, sint32& x, sint32& y, uint32 tick)
{
// setup a refference to the entity's position record, and bomb if it can't be found
TPositions::iterator positionIt= _Positions.find(entityIndex);
BOMB_IF(positionIt==_Positions.end(),"Ignoring call to 'checkMove' for an entity who doesn't exist in the move checker",return false);
SPosition& thePosition= positionIt->second;
// if the character hasn't moved then just return
if ( (x==thePosition.X) && (y==thePosition.Y) )
{
return true;
}
// nlinfo("Checking player move: %s from (%d,%d) @tick: %d to (%d,%d) @tick: %d",
// entityIndex.toString().c_str(),thePosition.X,thePosition.Y,thePosition.Tick,x,y,tick);
// if the tick value is out of order (for instance, after an advanced tp request) then ignore the move
DROP_IF(sint32(tick-thePosition.Tick)<0,"Ignoring out of order move for character "+entityIndex.toString(),return false);
// *** todo: perform a speed test here
// *** todo: perform collision test here
// *** NOTE: If move not legal then we need to change values of x and y and return false
// record the new position
thePosition.X= x;
thePosition.Y= y;
thePosition.Tick= tick;
// generate a few stats
addStats(entityIndex,x,y,tick);
return true;
}
void WorkerActor::DrawDirect(aui_Surface *surf, sint32 x, sint32 y, double scale)
{
uint16 flags = k_DRAWFLAGS_NORMAL;
Pixel16 color = 0x0000;
m_unitSpriteGroup->DrawDirect(surf, m_curUnitAction, m_frame, sint32(x+(k_ACTOR_CENTER_OFFSET_X*scale)), sint32(y+(k_ACTOR_CENTER_OFFSET_Y*scale)), m_facing,
scale, m_transparency, color, flags, NULL, NULL);
}
void TradeManager::CreateRoute(aui_Control *control, uint32 action, uint32 uidata, void *cookie)
{
if(action != AUI_BUTTON_ACTION_EXECUTE) return;
Assert(s_tradeManager);
if(!s_tradeManager) return;
bool breakInstead = sint32(cookie) != 0;
// ctp2_Static *market = (ctp2_Static *)aui_Ldl::GetObject(s_tradeManagerBlock, "Market");
if(!breakInstead) {
Assert(s_tradeManager->m_createList);
if(!s_tradeManager->m_createList) return;
ctp2_ListItem *item = (ctp2_ListItem *)s_tradeManager->m_createList->GetSelectedItem();
if(!item) return;
CreateListData *data = (CreateListData *)item->GetUserData();
Assert(data);
if(!data) return;
Assert(data->m_source.IsValid());
if(!data->m_source.IsValid()) return;
Assert(data->m_destination.IsValid());
if(!data->m_destination.IsValid()) return;
Assert(g_player[data->m_source.GetOwner()]);
if(!g_player[data->m_source.GetOwner()]) return;
g_gevManager->AddEvent(GEV_INSERT_Tail, GEV_SendGood,
GEA_Int, data->m_resource,
GEA_City, data->m_source,
GEA_City, data->m_destination,
GEA_End);
} else {
Assert(s_tradeManager->m_summaryList);
if(!s_tradeManager->m_summaryList) return;
ctp2_ListItem *item = (ctp2_ListItem *)s_tradeManager->m_summaryList->GetSelectedItem();
if(!item) return;
TradeRoute route((uint32)item->GetUserData());
Assert(route.IsValid());
if(!route.IsValid()) return;
g_gevManager->AddEvent(GEV_INSERT_Tail, GEV_KillTradeRoute,
GEA_TradeRoute, route.m_id,
GEA_Int, CAUSE_KILL_TRADE_ROUTE_SENDER_KILLED,
GEA_End);
if(g_network.IsClient()) {
g_network.SendAction(new NetAction(NET_ACTION_CANCEL_TRADE_ROUTE,
(uint32)route));
}
}
}
sint32 TradeRouteData::GetValue() const
{
if(m_sourceRouteType != ROUTE_TYPE_RESOURCE)
return 0;
double baseValue = g_theWorld->GetGoodValue(m_sourceResource);
double distance = double(m_destinationCity->GetCityData()->GetDistanceToGood(m_sourceResource));
return sint32(baseValue * distance);
}
void Shift(sint8 *map, sint32 sx, sint32 sy,
sint32 width, sint32 height,
bool horiz, sint32 delta, double slope,
sint32 count, sint32 raiselower)
{
sint32 s;
sint32 x = sx, y = sy;
sint32 ax = x, ay = y;
for(s = 0; s < count; s++) {
sint8 old = map[y * width + x];
if(raiselower > 0) {
if(old < 127) {
map[y * width + x]++;
}
} else if(raiselower < 0) {
if(old > -127) {
map[y * width + x]--;
}
}
if(horiz) {
ax += delta;
x += delta;
while(x >= width) x -= width;
while(x < 0) x += width;
y = sint32(sy + (double(ax - sx) * slope));
while(y >= height) y -= height;
while(y < 0) y += height;
} else {
ay += delta;
y += delta;
while(y >= height) y -= height;
while(y < 0) y += height;
x = sint32(sx + (double(ay - sy) * slope));
while(x >= width) x -= width;
while(x < 0) x += width;
}
}
}
void LineGraph::DrawIndicator(void)
{
sint32 xpos;
MBCHAR s[80];
double xnorm = (m_indicatorValue - m_xmin) / (m_xmax - m_xmin);
xpos = sint32(m_graphRect.left + xnorm * (m_graphRect.right-m_graphRect.left));
primitives_DrawLine16(m_surface, xpos, m_graphRect.top + 1,
xpos, m_graphRect.bottom - 1,
g_colorSet->GetColor(COLOR_YELLOW));
sprintf(s, "%#.3f", m_indicatorValue);
sint32 len = textutils_GetWidth(m_surface, s);
primitives_DrawText(m_surface, xpos - (len/2), m_graphRect.top+15, s, g_colorSet->GetColorRef(COLOR_YELLOW), TRUE);
}
Strengths::Strengths(sint32 owner)
{
m_owner = owner;
if (g_turn==NULL)
return;
sint32 const curRound = NewTurnCount::GetCurrentRound();
sint32 c, y;
for(y = 1; y < curRound; y++) {
for(c = 0; c < sint32(STRENGTH_CAT_MAX); c++) {
m_strengthRecords[c].Insert(0);
}
}
}
sint32 Squad_Strength::EffectiveRangedStrength() const
{
sint32 effective_units;
sint32 range_str;
if (0 < m_ranged_unit_count) {
effective_units = int(min(m_unit_count * 0.5, m_ranged_unit_count));
range_str = sint32(effective_units * m_ranged_str/m_ranged_unit_count);
}else {
range_str = 0;
}
return range_str;
}
// ***************************************************************************
void CDBViewDigit::draw ()
{
CViewRenderer &rVR = *CViewRenderer::getInstance();
sint32 wDigit= rVR.getFigurTextureW();
sint32 hDigit= rVR.getFigurTextureH();
// change bitmap ids
sint32 val= _Number.getSInt32();
val= max(val, sint32(0));
if(_Cache!=val)
{
_Cache= val;
// clamp the value to max possible (eg:99)
if(val>(sint32)_DivBase-1)
val=(sint32)_DivBase-1;
// compute each digit id
uint divisor= _DivBase/10;
for(sint i=0;i<_NumDigit;i++)
{
sint digitVal= (val/divisor)%10;
// set the digit text id
_DigitId[i]= rVR.getFigurTextureId(digitVal);
// next divisor
divisor/= 10;
}
}
// Display bitmaps
sint32 x= _XReal;
sint32 y= _YReal;
for(sint i=0;i<_NumDigit;i++)
{
rVR.drawRotFlipBitmap ( _RenderLayer, x, y, wDigit, hDigit, 0, false, _DigitId[i], _Color );
// next digit
x+= wDigit+_WSpace;
}
}
void Squad::Add_Agent
(
AiMain *ai,
Agent * add_me
)
{
#ifdef DBGAILOG
#ifdef LOG_SQUADS
if (ai->AI_VERBOSITY > LOG_DETAILS)
{
AILOG(( wstr, "Squad::Add_Agent:\n\tArmyCount() = %d (before).\n",
m_squad_strength.GetArmyCount()))
AILOG(( wstr, "\tGetUnitCount() = %d (before).\n",
m_squad_strength.GetUnitCount()))
AILOG(( wstr, "\taddme->GetSquadStrength().GetArmyCount() = %d\n",
add_me->GetSquadStrength()->GetArmyCount()))
AILOG(( wstr, "\taddme->GetSquadStrength().GetUnitCount() = %d.\n",
add_me->GetSquadStrength()->GetUnitCount()))
}
#endif
#endif DBGAILOG
add_me->squads_list_cell_ptr = my_agents.Add_Data((data_ptr) add_me);
add_me->the_squad = this;
m_squad_strength.Add(add_me->GetSquadStrength());
#ifdef DBGAILOG
#ifdef LOG_SQUADS
if (ai->AI_VERBOSITY > LOG_DETAILS)
{
AILOG(( wstr, "\tArmyCount() = %d (after).\n",
m_squad_strength.GetArmyCount()))
AILOG(( wstr, "\tGetUnitCount() = %d (after).\n",
m_squad_strength.GetUnitCount()))
}
#endif
#endif DBGAILOG
BOOL will_be_transported = FALSE;
MapPointData target_pos, agent_pos;
double move_point_cost;
double build_time;
ArmyAgent *the_army=NULL;
CityAgent *the_city=NULL;
sint32 dist;
if (my_strategic_goal) {
*(my_strategic_goal->m_current_attacking_strength) = m_squad_strength;
((ArmyGoal*)my_strategic_goal)->GetPos(target_pos);
if (add_me->GetType() == AGENT_TYPE_CITY) {
the_city = (CityAgent*) add_me;
the_city->GetPos(agent_pos);
dist = sint32(ai->m_map->WrappedDistance(agent_pos, target_pos));
} else {
the_army = (ArmyAgent*) add_me;
if (the_army->BidDistance(ai, will_be_transported, target_pos, move_point_cost,
dist, build_time) < 0.0) {
dist = 100;
}
}
if (my_strategic_goal->m_farthest_agent_to_target_dist < dist) {
my_strategic_goal->m_farthest_agent_to_target_dist = (sint16) dist;
}
}
m_moveType = 0x0;
Reclassify_Squad(ai, add_me);
}
void CityAgent::PlacePopMinimumFood(AiMain *ai,
sint32 &idx_slave, sint32 &remaining_slaves, sint32 &idx_pop,
sint32 &remaining_pop, const sint32 total_pop,
TileUtility *open_tile[k_NUM_CITY_TILES], const double foodCoef,
const double productionCoef, const double max_coef, double &accum_production,
double &accum_food, const double percent)
{
sint32 idx_tile;
sint32 idx_max;
double max_food;
sint32 searching = FALSE;
sint32 needed_food=0;
BOOL is_unknown_id;
double f;
sint32 g = ai->m_will_of_the_people->GetCurrentGov();
double ration_coef = ai->m_governmentDB->GetRationsCoef(g);
double ration_unit = ai->m_governmentDB->GetRationsUnit(g);
double ration_base = ai->m_governmentDB->GetRationsBase(g);
double ration_level_expected = ai->m_governmentDB->GetRationsExpectation(g);
double ration_expected = total_pop * (5.0 + 2.5 * (2.0 + ration_level_expected));
sint32 nf;
ai->m_population->GetCityRequiredFood(m_id.GetVal(), &nf, &is_unknown_id);
needed_food = sint32(ceil(percent * double(nf)));
searching = FALSE;
#ifdef _DEBUG
sint32 finite_loop=0;
#endif
while (!searching && (accum_food < needed_food) &&
((0 < remaining_slaves) || (0 < remaining_pop))) {
Assert(++finite_loop < 100000);
max_food = 0.0;
searching = TRUE;
idx_max = -1;
for (idx_tile=0; idx_tile<k_NUM_CITY_TILES; idx_tile++) {
if (open_tile[idx_tile]) {
f = open_tile[idx_tile]->m_food * max_coef +
open_tile[idx_tile]->m_can_be_irrigated +
open_tile[idx_tile]->m_gold +
open_tile[idx_tile]->m_production * 0.25 ;
if (max_food < f) {
max_food = f;
idx_max = idx_tile;
searching = FALSE;
}
}
}
if (!searching) {
accum_food += open_tile[idx_max]->m_food;
accum_production += open_tile[idx_max]->m_production;
PlaceACitizen(ai, idx_max, idx_slave, remaining_slaves, idx_pop,
remaining_pop, total_pop, open_tile);
}
}
}
BOOL CityAgent::PopNeedsChanging(AiMain *ai, const double food_coef,
const double prod_coef, const double gold_coef, sint32 idx_city )
{
BOOL is_unknown_id;
if (((m_pop_prod > prod_coef) || (m_pop_prod < prod_coef)) ||
((m_pop_food > food_coef) || (m_pop_food < food_coef)) ||
((m_pop_gold > gold_coef) || (m_pop_gold < gold_coef))) {
return TRUE;
}
if (ai->m_alloc_WGF->IsReset()) {
return TRUE;
}
if (m_pop_needs_changing) {
return TRUE;
}
if (ai->m_population->HasPopGrown(m_id.GetVal(), &is_unknown_id))
return (TRUE) ;
if (is_unknown_id)
return (FALSE) ;
if (ai->m_population->HasPopStarved(m_id.GetVal(), &is_unknown_id))
return (TRUE) ;
if (is_unknown_id)
return (FALSE) ;
if (ai->m_population->WasPopExpelled(m_id.GetVal(), &is_unknown_id))
return (TRUE) ;
if (is_unknown_id)
return (FALSE) ;
if (ai->m_population->WasImprovementBuilt(m_id.GetVal(), &is_unknown_id))
return (TRUE) ;
if (is_unknown_id)
return (FALSE) ;
if (ai->m_population->WasTerrainImprovementBuilt(m_id.GetVal(), &is_unknown_id))
return (TRUE) ;
if (is_unknown_id)
return (FALSE) ;
if (ai->m_population->WasHappinessAttacked(m_id.GetVal(), &is_unknown_id))
return (TRUE) ;
if (is_unknown_id)
return (FALSE) ;
if (ai->m_population->WasTerrainPolluted())
return (TRUE) ;
if ((sint32(ai->m_round_count->GetRound()) % 5) == (idx_city % 5))
return TRUE;
return (FALSE) ;
}
AUI_ERRCODE aui_TabGroup::FormatTabs( void )
{
sint32 numTabs = m_childList->L();
sint32 maxPaneWidth = 0;
sint32 maxPaneHeight = 0;
ListPos position = m_childList->GetHeadPosition();
sint32 i;
for (i = numTabs; i; i-- )
{
aui_Tab *tab = (aui_Tab *)m_childList->GetNext( position );
if ( tab->GetPane()->Width() > maxPaneWidth )
maxPaneWidth = tab->GetPane()->Width();
if ( tab->GetPane()->Height() > maxPaneHeight )
maxPaneHeight = tab->GetPane()->Height();
}
sint32 maxTabWidth = 0;
sint32 maxTabHeight = 0;
position = m_childList->GetHeadPosition();
for (sint32 j = numTabs; j > 0; --j)
{
aui_Tab *tab = (aui_Tab *)m_childList->GetNext( position );
if ( tab->Width() > maxTabWidth ) maxTabWidth = tab->Width();
if ( tab->Height() > maxTabHeight ) maxTabHeight = tab->Height();
}
switch ( m_alignment )
{
default:
case AUI_TABGROUP_ALIGNMENT_TOP:
{
sint32 newTabWidth = sint32(0.9 * maxPaneWidth / numTabs + 0.5);
sint32 tabOffset = sint32(0.05 * maxPaneWidth + 0.5);
position = m_childList->GetHeadPosition();
for ( sint32 k = numTabs; k; k-- )
{
aui_Tab *tab = (aui_Tab *)m_childList->GetNext( position );
if ( m_autoArrange )
{
tab->Move( tabOffset, 0 );
tab->Resize( newTabWidth, maxTabHeight );
}
else
tabOffset = tab->X();
tab->GetPane()->Move( -tabOffset, maxTabHeight );
tab->GetPane()->Resize( maxPaneWidth, maxPaneHeight );
tab->GetPane()->Offset( m_paneOffsetX, m_paneOffsetY );
tabOffset += newTabWidth;
}
}
break;
case AUI_TABGROUP_ALIGNMENT_BOTTOM:
{
sint32 newTabWidth = sint32(0.9 * maxPaneWidth / numTabs + 0.5);
sint32 tabOffset = sint32(0.05 * maxPaneWidth + 0.5);
position = m_childList->GetHeadPosition();
for ( sint32 i = numTabs; i; i-- )
{
aui_Tab *tab = (aui_Tab *)m_childList->GetNext( position );
if ( m_autoArrange )
{
tab->Move( tabOffset, maxPaneHeight );
tab->Resize( newTabWidth, maxTabHeight );
}
else
tabOffset = tab->X();
tab->GetPane()->Move( -tabOffset, -maxPaneHeight );
tab->GetPane()->Resize( maxPaneWidth, maxPaneHeight );
tab->GetPane()->Offset( m_paneOffsetX, m_paneOffsetY );
tabOffset += newTabWidth;
}
}
break;
case AUI_TABGROUP_ALIGNMENT_LEFT:
{
sint32 newTabHeight = sint32(0.9 * maxPaneHeight / numTabs + 0.5);
sint32 tabOffset = sint32(0.05 * maxPaneHeight + 0.5);
position = m_childList->GetHeadPosition();
for (sint32 i = numTabs; i; i-- )
{
aui_Tab *tab = (aui_Tab *)m_childList->GetNext( position );
if ( m_autoArrange )
{
tab->Move( 0, tabOffset );
tab->Resize( maxTabWidth, newTabHeight );
}
else
tabOffset = tab->Y();
tab->GetPane()->Move( maxTabWidth, -tabOffset );
tab->GetPane()->Resize( maxPaneWidth, maxPaneHeight );
tab->GetPane()->Offset( m_paneOffsetX, m_paneOffsetY );
tabOffset += newTabHeight;
}
}
break;
case AUI_TABGROUP_ALIGNMENT_RIGHT:
{
sint32 newTabHeight = sint32(0.9 * maxPaneHeight / numTabs + 0.5);
sint32 tabOffset = sint32(0.05 * maxPaneHeight + 0.5);
position = m_childList->GetHeadPosition();
for (sint32 i = numTabs; i; i-- )
{
aui_Tab *tab = (aui_Tab *)m_childList->GetNext( position );
if ( m_autoArrange )
{
tab->Move( maxPaneWidth, tabOffset );
tab->Resize( maxTabWidth, newTabHeight );
}
else
tabOffset = tab->Y();
tab->GetPane()->Move( -maxPaneWidth, -tabOffset );
tab->GetPane()->Resize( maxPaneWidth, maxPaneHeight );
tab->GetPane()->Offset( m_paneOffsetX, m_paneOffsetY );
tabOffset += newTabHeight;
}
}
break;
}
return AUI_ERRCODE_OK;
}
//----------------------------------------------------------------------------
//
// Name : DoInstruction
//
// Description: Executes slic intructions that were previously
// "compiled" by slicif_add_op.
//
// Parameters : SOP op
//
// Globals : This function is so big no idea.
//
// Returns : -
//
// Remark(s) : The behaviour depends on the given SOP type
// if you define new operatiors you have of course modify
// or implement the according behaviour of that function.
//
// This function is called at slic run time.
//
//----------------------------------------------------------------------------
BOOL SlicFrame::DoInstruction(SOP op)
{
unsigned char* codePtr = &m_segment->m_code[m_offset];
unsigned char* origCodePtr = &m_segment->m_code[m_offset];
#if defined(SLIC_DOUBLES)
double dval;
#endif
sint32 ival, ival2;
SlicStackValue sval1, sval2, sval3;
SS_TYPE type1, type2, type3;
SlicSymbolData *symval;
BOOL stopped = FALSE;
sint32 sp;
sint32 res;
BOOL calcOffset = TRUE;
//Added by Martin Gühmann for database access
SlicDBInterface *conduit;
char* name;
switch(op) {
case SOP_PUSHI:
sval1.m_int = *(reinterpret_cast<sint32 *>(codePtr));
codePtr += sizeof(sint32);
m_stack->Push(SS_TYPE_INT, sval1);
break;
case SOP_PUSHD:
#if defined(SLIC_DOUBLES)
dval = *((double*)codePtr);
// Probably some handling missing here. Now, we just skip some bytes.
#endif
codePtr += sizeof(sint32);
break;
case SOP_PUSHV:
ival = *((sint32 *)codePtr);
codePtr += sizeof(int);
sval1.m_sym = g_slicEngine->GetSymbol(ival);
if (sval1.m_sym)
{
m_stack->Push(SS_TYPE_SYM, sval1);
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL symbol %d\n", ival));
stopped = TRUE;
}
break;
case SOP_PUSHM:
{
ival = *((sint32*)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL struct symbol %d\n", ival));
stopped = TRUE;
break;
}
if(symval->GetType() != SLIC_SYM_STRUCT) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, %s is not a struct\n", symval->GetName()));
stopped = TRUE;
break;
}
SlicStructInstance *theStruct = symval->GetStruct();
Assert(theStruct);
ival2 = *((sint32*)codePtr);
codePtr += sizeof(sint32);
sval1.m_sym = theStruct->GetMemberSymbol(ival2);
m_stack->Push(SS_TYPE_SYM, sval1);
break;
}
case SOP_PUSHAM:
{
ival = *((sint32*)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL struct symbol %d\n", ival));
stopped = TRUE;
break;
}
if(symval->GetType() != SLIC_SYM_ARRAY) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, %s is not an array\n", symval->GetName()));
stopped = TRUE;
break;
}
sp = m_stack->Pop(type3, sval3);
Assert(sp >= 1);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
if(!symval->ArrayLookup(Eval(type3, sval3), type1, sval1)) {
DPRINTF(k_DBG_SLIC, ("Couldn't perform array lookup in SOP_PUSHAM\n"));
stopped = TRUE;
break;
}
SlicSymbolData * structSym = SlicStack::GetSymbol(type1, sval1);
if (!structSym)
{
DPRINTF(k_DBG_SLIC, ("Couldn't find struct symbol in SOP_PUSHAM\n"));
stopped = TRUE;
break;
}
if(structSym->GetType() != SLIC_SYM_STRUCT) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, array symbol id not a struct in SOP_PUSHAM\n"));
stopped = TRUE;
break;
}
SlicStructInstance *theStruct = structSym->GetStruct();
Assert(theStruct);
ival2 = *((sint32*)codePtr);
codePtr += sizeof(sint32);
sval1.m_sym = theStruct->GetMemberSymbol(ival2);
m_stack->Push(SS_TYPE_SYM, sval1);
break;
}
case SOP_PUSHA:
ival = *((sint32 *)codePtr);
codePtr += sizeof(int);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL symbol %d\n", ival));
stopped = TRUE;
break;
}
sval1.m_sym = symval;
m_stack->Push(SS_TYPE_SYM, sval1);
break;
case SOP_AINDX:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 1);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
res = ArrayLookup(type2, sval2, type1, sval1,
type3, sval3);
if(res)
m_stack->Push(type3, sval3);
else {
sval3.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval3);
}
break;
case SOP_ADD:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) + Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_SUB:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) - Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_MULT:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) * Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_EXP:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = static_cast<int>
(pow(static_cast<double>(Eval(type2, sval2)), Eval(type1, sval1)));
m_stack->Push(SS_TYPE_INT, sval3);
break;
// Bitwise operators:
case SOP_BAND:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) & Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_BOR:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) | Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_BXOR:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) ^ Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_BNOT:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sval3.m_int = ~Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_DIV:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
if(Eval(type1, sval1) == 0) {
//Added by Martin Gühmann
//It is a problem of slic code and not of the ctp2.exe,
//the slicer has to solve the problem.
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "In object %s: Division by 0.", m_segment->GetName());
}
sval3.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval3);
break;
}
sval3.m_int = Eval(type2, sval2) / Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_MOD:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
{
sint32 const divisor = Eval(type1, sval1);
if (0 == divisor)
{
// Handle error as for SOP_DIV.
if (g_theProfileDB && g_theProfileDB->IsDebugSlic())
{
c3errors_ErrorDialog("Slic", "In object %s: modulo 0.",
m_segment->GetName()
);
}
sval3.m_int = 0;
}
else
{
sval3.m_int = Eval(type2, sval2) % divisor;
}
}
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_EQ:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = IsEqual(type2, sval2, type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_GT:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) > Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_LT:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) < Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_GTE:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) >= Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_LTE:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) <= Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_NEQ:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = !IsEqual(type2, sval2, type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_AND:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) && Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_OR:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval3.m_int = Eval(type2, sval2) || Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_NOT:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sval3.m_int = !Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_POP:
Assert(FALSE);
break;
case SOP_TRIG:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sval3.m_int = Eval(type1, sval1);
if(!sval3.m_int)
stopped = TRUE;
break;
case SOP_ARGE:
sp = m_stack->Pop(type1, sval1);
AddArg(type1, sval1);
break;
case SOP_ARGID:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, NULL symbol %d\n", ival));
return FALSE;
}
if(symval->GetType() != SLIC_SYM_ID) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, symbol %s is not of type ID\n",
symval->GetName()));
return FALSE;
}
m_argList->AddArg(symval->GetSegment(), symval);
break;
case SOP_ARGS:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(symval->GetType() != SLIC_SYM_SVAR) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, string arg doesn't have string type\n"));
return FALSE;
}
m_argList->AddArg(SA_TYPE_STRING, sint32(symval->GetStringId()));
break;
case SOP_ARGST:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(symval->GetType() != SLIC_SYM_STRING) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, hard string doesn't have hard string type\n"));
return FALSE;
}
m_argList->AddArg(SA_TYPE_HARD_STRING, symval);
break;
case SOP_CALL:
case SOP_CALLR:
{
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, NULL symbol %d\n", ival));
return FALSE;
}
if(symval->GetType() != SLIC_SYM_FUNC && symval->GetType() != SLIC_SYM_UFUNC) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, symbol %s is not a function\n",
symval->GetName()));
return FALSE;
}
SlicFunc *funcObj = symval->GetFunction();
SFN_ERROR err;
if(!funcObj) {
SlicSegment *segment = g_slicEngine->GetSegment(symval->GetName());
if(!segment || segment->GetType() != SLIC_OBJECT_FUNCTION) {
DPRINTF(k_DBG_SLIC, ("Undefined function %s\n", symval->GetName()));
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "%s is not a known function", symval->GetName());
}
return FALSE;
}
SlicObject * obj = NULL;
err = segment->Call(m_argList, obj);
if (obj)
{
if (op == SOP_CALLR)
{
if (g_slicEngine->AtBreak())
{
Assert(!m_resultObject); // need stack when failing?
if (m_resultObject)
{
m_resultObject->Release();
}
m_resultObject = obj;
}
else
{
sval1.m_int = obj->GetResult();
m_stack->Push(SS_TYPE_INT, sval1);
obj->Release();
}
}
else
{
// SOP_CALL: result not used
obj->Release();
}
}
} else {
err = funcObj->Call(m_argList);
if(op == SOP_CALLR) {
switch(funcObj->GetReturnType()) {
case SFR_INT:
sval1.m_int = funcObj->GetResult().m_int;
m_stack->Push(SS_TYPE_INT, sval1);
break;
default:
sval1.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval1);
Assert(FALSE);
}
}
}
if(err != SFN_ERROR_OK) {
ReportSFError(err, symval);
stopped = TRUE;
}
m_argStackPtr--;
Assert(m_argStackPtr >= -1);
if(m_argStackPtr >= 0) {
m_argList = &m_argListArray[m_argStackPtr];
} else if(m_argStackPtr == -1) {
m_argList = NULL;
}
if(g_slicEngine->AtBreak())
stopped = TRUE;
break;
}
case SOP_EVENT:
{
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
if(g_gevManager->IsProcessing()) {
EVENTLOG((" "));
}
EVENTLOG(("Event:%s(", g_gevManager->GetEventName((GAME_EVENT)ival)));
GameEventArgList *args = m_argList->CreateGameEventArgs((GAME_EVENT)ival);
EVENTLOG((") : Serial %d\n", g_gevManager->GetNextSerial()));
g_gevManager->ArglistAddEvent(GEV_INSERT_Tail,
(GAME_EVENT)ival,
args);
m_argStackPtr--;
Assert(m_argStackPtr >= -1);
if(m_argStackPtr >= 0) {
m_argList = &m_argListArray[m_argStackPtr];
} else if(m_argStackPtr == -1) {
m_argList = NULL;
}
if(g_slicEngine->AtBreak())
stopped = TRUE;
break;
}
case SOP_SBLK:
DPRINTF(k_DBG_SLIC, ("dangling SBLK\n"));
return FALSE;
case SOP_END:
stopped = TRUE;
codePtr += sizeof(sint32);
break;
case SOP_JMP:
m_offset = *(reinterpret_cast<sint32 *>(codePtr));
calcOffset = FALSE;
break;
case SOP_BNT:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
sp = m_stack->Pop(type2, sval2);
if(!Eval(type2, sval2)) {
m_offset = ival;
calcOffset = FALSE;
}
break;
case SOP_BNEV:
codePtr += sizeof(sint32);
break;
case SOP_BUTN:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
ival2 = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival2);
if(symval->GetType() != SLIC_SYM_SVAR) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, button string arg doesn't have string type\n"));
return FALSE;
}
g_slicEngine->GetContext()->AddButton(new SlicButton(
(StringId)symval->GetStringId(), m_segment,
ival, g_slicEngine->GetContext()));
break;
case SOP_OCLS:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
g_slicEngine->GetContext()->AddButton(new SlicButton(
-1, m_segment, ival,
g_slicEngine->GetContext()));
break;
case SOP_STOP:
stopped = TRUE;
break;
case SOP_NEG:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sval3.m_int = 0 - Eval(type1, sval1);
m_stack->Push(SS_TYPE_INT, sval3);
break;
case SOP_ASSN:
ival = *((sint32*)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL symbol %d\n", ival));
stopped = TRUE;
break;
}
sp = m_stack->Pop(type1, sval1);
SetValue(symval, type1, sval1);
break;
case SOP_ASSNA:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL symbol %d in array assignment", ival));
stopped = TRUE;
break;
}
if(symval->GetType() != SLIC_SYM_ARRAY) {
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "Symbol '%s' used in array assignment is not an array", symval->GetName());
}
stopped = TRUE;
break;
}
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 1);
sp = m_stack->Pop(type3, sval3);
Assert(sp >= 0);
SetArrayValue(symval, type2, sval2, type3, sval3);
break;
case SOP_ASSNM:
{
ival = *((sint32*)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if(!symval) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL struct symbol %d\n", ival));
stopped = TRUE;
break;
}
if(symval->GetType() != SLIC_SYM_STRUCT) {
DPRINTF(k_DBG_SLIC, ("Bad mojo, %s is not a struct\n", symval->GetName()));
stopped = TRUE;
break;
}
SlicStructInstance *theStruct = symval->GetStruct();
Assert(theStruct);
ival2 = *((sint32*)codePtr);
codePtr += sizeof(sint32);
symval = theStruct->GetMemberSymbol(ival2);
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
SetValue(symval, type1, sval1);
break;
}
case SOP_ASSNAM:
{
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
SlicSymbolData *arraySym = g_slicEngine->GetSymbol(ival);
ival2 = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
if(!arraySym) {
DPRINTF(k_DBG_SLIC, ("Bad Mojo, symbol %d does not exist", ival));
stopped = TRUE;
break;
}
if(arraySym->GetType() != SLIC_SYM_ARRAY) {
DPRINTF(k_DBG_SLIC, ("%s is not an array", arraySym->GetName()));
stopped = TRUE;
break;
}
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 1);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
if(!arraySym->ArrayLookup(Eval(type2, sval2), type3, sval3)) {
DPRINTF(k_DBG_SLIC, ("Array lookup, %s[%d], failed\n",
arraySym->GetName(), Eval(type2, sval2)));
stopped = TRUE;
break;
}
SlicSymbolData *structSym = SlicStack::GetSymbol(type3, sval3);
if (!structSym)
{
DPRINTF(k_DBG_SLIC, ("Couldn't find symbol for %s[%d]\n",
arraySym->GetName(), Eval(type2, sval2)));
stopped = TRUE;
break;
}
if(structSym->GetType() != SLIC_SYM_STRUCT) {
DPRINTF(k_DBG_SLIC, ("%s[%d] is not a struct\n",
arraySym->GetName(), Eval(type2, sval2)));
stopped = TRUE;
break;
}
SlicStructInstance *theStruct = structSym->GetStruct();
Assert(theStruct);
if(!theStruct) {
stopped = TRUE;
break;
}
SlicSymbolData *assnSym = theStruct->GetMemberSymbol(ival2);
assnSym->SetValueFromStackValue(type1, sval1);
break;
}
case SOP_SARGS:
m_argStackPtr++;
Assert(m_argStackPtr < k_ARGLIST_STACK_SIZE);
if(m_argStackPtr < k_ARGLIST_STACK_SIZE) {
m_argList = &m_argListArray[m_argStackPtr];
m_argList->Clear();
}
break;
case SOP_RET:
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
g_slicEngine->GetContext()->SetResult(Eval(type1, sval1));
stopped = TRUE;
break;
case SOP_LINE:
case SOP_LBRK:
{
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
m_currentLine = ival;
ival2 = *((sint32 *)codePtr);
if(m_segment->GetFilename()) {
if(ival2 < 0) {
*((sint32 *)codePtr) = FindFileOffset(m_segment->GetFilename(), ival);
ival2 = *((sint32 *)codePtr);
}
}
codePtr += sizeof(sint32);
SlicConditional *cond = *((SlicConditional **)codePtr);
codePtr += sizeof(SlicConditional *);
if(op == SOP_LBRK || g_slicEngine->BreakRequested()) {
if(!cond || (cond->Eval() != 0)) {
g_slicEngine->Break(m_segment, codePtr - m_segment->m_code,
g_slicEngine->GetContext(), m_stack,
m_messageData);
stopped = TRUE;
}
}
break;
}
case SOP_ASIZE:
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
Assert(symval);
if(symval) {
sval1.m_int = symval->GetArray()->GetSize();
}
else{
sval1.m_int = 0;
}
m_stack->Push(SS_TYPE_INT, sval1);
break;
//Added by Martin Gühmann for database support
case SOP_DBNAME:
{
conduit = GetDatabase(codePtr);
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if (conduit && symval)
{
sval1.m_sym = symval;
sval3.m_int = Eval(SS_TYPE_SYM, sval1);
if ((sval3.m_int >= 0) && sval3.m_int < conduit->GetNumRecords())
{
// No action: value is OK
}
else
{
sval3.m_int = -1;
}
m_stack->Push(SS_TYPE_INT, sval3);
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL symbol %d\n", ival));
stopped = TRUE;
}
break;
}
case SOP_DBNAMEREF:
{
conduit = GetDatabase(codePtr);
ival = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
symval = g_slicEngine->GetSymbol(ival);
if (conduit && symval)
{
//Get the member:
name = reinterpret_cast<char *>(codePtr);
Assert(name);
for ( ; *codePtr++; )
{
// No action: just skip
}
sval1.m_sym = symval;
sval3.m_int = Eval(SS_TYPE_SYM, sval1);
if(sval3.m_int > -1 && sval3.m_int < conduit->GetNumRecords()){
sval3.m_int = conduit->GetValue(sval3.m_int, name);
m_stack->Push(SS_TYPE_INT, sval3);
}
else{
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "In object %s no entry found with index %i in %s.", m_segment->GetName(), sval3.m_int, conduit->GetName());
}
sval3.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval3);
}
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL symbol %d\n", ival));
stopped = TRUE;
}
break;
}
case SOP_DBNAMEARRAY:
{
conduit = GetDatabase(codePtr);
ival = *((int*)codePtr);
codePtr += sizeof(int);
symval = g_slicEngine->GetSymbol(ival);
if (conduit && symval)
{
//Get the member:
name = reinterpret_cast<char *>(codePtr);
Assert(name);
for ( ; *codePtr++ ; )
{
// No action: just skip
}
sval1.m_sym = symval;
sval3.m_int = Eval(SS_TYPE_SYM, sval1);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval2.m_int = Eval(type2, sval2);
if(sval3.m_int > -1 && sval3.m_int < conduit->GetNumRecords()){
sval3.m_int = conduit->GetValue(sval3.m_int, name, sval2.m_int);
m_stack->Push(SS_TYPE_INT, sval3);
}
else{
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "In object %s no entry found with index %i in %s.", m_segment->GetName(), sval3.m_int, conduit->GetName());
}
sval3.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval3);
}
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, NULL symbol %d\n", ival));
stopped = TRUE;
}
break;
}
case SOP_DBNAMECONSTARRAY:
{
conduit = GetDatabase(codePtr);
if (conduit)
{
sval3.m_int = *((sint32 *)codePtr);
codePtr += sizeof(sint32);
//Get the member:
name = reinterpret_cast<char *>(codePtr);
Assert(name);
for ( ; *codePtr++; )
{
// No action: just skip
}
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval2.m_int = Eval(type2, sval2);
if(sval3.m_int > -1 && sval3.m_int < conduit->GetNumRecords()){
sval3.m_int = conduit->GetValue(sval3.m_int, name, sval2.m_int);
m_stack->Push(SS_TYPE_INT, sval3);
}
else{
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "In object %s no entry found with index %i in %s.", m_segment->GetName(), sval3.m_int, conduit->GetName());
}
sval3.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval3);
}
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, incorrect database symbol\n"));
stopped = TRUE;
}
break;
}
case SOP_DB:
{
conduit = GetDatabase(codePtr);
if (conduit)
{
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sval3.m_int = Eval(type1, sval1);
if(sval3.m_int > -1 && sval3.m_int < conduit->GetNumRecords()){
m_stack->Push(SS_TYPE_INT, sval3);
}
else{
sval3.m_int = -1;
m_stack->Push(SS_TYPE_INT, sval3);
}
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, incorrect database symbol\n"));
stopped = TRUE;
}
break;
}
case SOP_DBREF:
{
conduit = GetDatabase(codePtr);
if (conduit)
{
//Get the member:
name = reinterpret_cast<char *>(codePtr);
Assert(name);
for ( ; *codePtr++ ; )
{
// No action: just skip
}
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sval2.m_int = Eval(type1, sval1);
if(sval2.m_int > -1 && sval2.m_int < conduit->GetNumRecords()){
sval3.m_int = conduit->GetValue(sval2.m_int, name);
m_stack->Push(SS_TYPE_INT, sval3);
}
else{
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "In object %s no entry found with index %i in %s.", m_segment->GetName(), sval2.m_int, conduit->GetName());
}
sval2.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval2);
}
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, incorrect database symbol\n"));
stopped = TRUE;
}
break;
}
case SOP_DBARRAY:
{
conduit = GetDatabase(codePtr);
if (conduit)
{
//Get the member:
name = reinterpret_cast<char *>(codePtr);
Assert(name);
for ( ; *codePtr++; )
{
// Just skip
}
sp = m_stack->Pop(type1, sval1);
Assert(sp >= 0);
sval1.m_int = Eval(type1, sval1);
sp = m_stack->Pop(type2, sval2);
Assert(sp >= 0);
sval2.m_int = Eval(type2, sval2);
if(sval2.m_int > -1 && sval2.m_int < conduit->GetNumRecords()){
sval3.m_int = conduit->GetValue(sval2.m_int, name, sval1.m_int);
m_stack->Push(SS_TYPE_INT, sval3);
}
else{
if(g_theProfileDB && g_theProfileDB->IsDebugSlic()) {
c3errors_ErrorDialog("Slic", "In object %s no entry found with index %i in %s.", m_segment->GetName(), sval2.m_int, conduit->GetName());
}
sval2.m_int = 0;
m_stack->Push(SS_TYPE_INT, sval2);
}
}
else
{
DPRINTF(k_DBG_SLIC, ("Bad mojo, incorrect database symbol\n"));
stopped = TRUE;
}
break;
}
case SOP_DBSIZE:
{
//Added by Martin Gühmann to figure out via
//slic how many records the database contains
//Get the database:
conduit = GetDatabase(codePtr);
Assert(conduit);
if (conduit)
{
sval3.m_int = conduit->GetNumRecords();
}
else
{
sval3.m_int = 0;
}
m_stack->Push(SS_TYPE_INT, sval3);
break;
}
default:
DPRINTF(k_DBG_SLIC, ("???\n"));
break;
}
if(calcOffset)
m_offset += codePtr - origCodePtr;
return !stopped;
}
void gslog_LogPlayerStats(sint32 player)
{
#ifndef _BFR_
if(!g_theProfileDB->GetEnableLogs())
return;
Player *pl = g_player[player];
if (!pl) return;
gslog_print("[Player %d] [Turn %d]\n", player, pl->m_current_round);
sint32 totalFood = 0, totalFoodCrime = 0, totalFoodConsumed = 0;
UnitDynamicArray *cityList = pl->GetAllCitiesList();
sint32 cityIndex;
for (cityIndex = 0; cityIndex < cityList->Num(); cityIndex++)
{
CityData * cityData = (*cityList)[cityIndex].GetData()->GetCityData();
sint32 foodCrime = 0;
cityData->GetFoodCrime(foodCrime);
totalFood += cityData->GetGrossCityFood();
totalFoodCrime += foodCrime;
totalFoodConsumed += static_cast<sint32>(cityData->GetConsumedFood());
}
sint32 percentFoodCrime = totalFood ?
((totalFoodCrime * 100) / totalFood) : 0;
sint32 percentFoodConsumed = totalFood ?
((totalFoodConsumed * 100) / totalFood) : 0;
sint32 percentFoodStored = 100 - (percentFoodCrime + percentFoodConsumed);
gslog_print(" Food Total: %d\n", totalFood);
gslog_print(" Food Crime: %d (%d%%):\n", totalFoodCrime, percentFoodCrime);
gslog_print(" Food Consumed: %d (%d%%)\n", totalFoodConsumed, percentFoodConsumed);
gslog_print(" Food Stored: %d (%d%%)\n", totalFood - (totalFoodConsumed + totalFoodCrime), percentFoodStored);
sint32 totalProduction = 0, totalProductionCrime = 0,
totalProductionUnitUpkeep = 0, totalProductionPublicWorks = 0;
for (cityIndex = 0; cityIndex < cityList->Num(); cityIndex++)
{
CityData *cityData = (*cityList)[cityIndex].GetData()->GetCityData();
totalProduction += cityData->GetGrossCityProduction();
totalProductionCrime += cityData->GetProdCrime();
totalProductionPublicWorks += cityData->ComputeMaterialsPaid(pl->m_materialsTax);
}
totalProductionUnitUpkeep = pl->GetReadinessCost();
sint32 percentProductionCrime = totalProduction ?
((totalProductionCrime * 100) / totalProduction) : 0;
sint32 percentProductionUnitUpkeep = totalProduction ?
((totalProductionUnitUpkeep * 100) / totalProduction) : 0;
sint32 percentProductionPublicWorks = totalProduction ?
((totalProductionPublicWorks * 100) / totalProduction) : 0;
#if 0 // Unused
sint32 percentProductionCityUse = 100 - (percentProductionCrime +
percentProductionUnitUpkeep + totalProductionPublicWorks);
#endif
gslog_print(" Total Production: %d\n", totalProduction);
gslog_print(" Production Crime: %d (%d%%)\n", totalProductionCrime, percentProductionCrime);
gslog_print(" Production Unit Upkeep: %d (%d%%)\n", totalProductionUnitUpkeep, percentProductionUnitUpkeep);
gslog_print(" Production PW: %d (%d%%)\n", totalProductionPublicWorks, percentProductionPublicWorks);
sint32 totalCommerce = 0, totalCommerceCrime = 0,
totalCommerceWages = 0, totalCommerceBuildingUpkeep = 0,
totalCommerceScience = 0, totalTrade = 0;
sint32 wonderReduction = wonderutil_GetDecreaseMaintenance(pl->GetBuiltWonders());
for (cityIndex = 0; cityIndex < cityList->Num(); cityIndex++)
{
CityData *cityData = (*cityList)[cityIndex].GetData()->GetCityData();
sint32 commerceBuildingUpkeep = buildingutil_GetTotalUpkeep
(cityData->GetImprovements(), wonderReduction, cityData->GetOwner()); //EMOD added owner
totalCommerce += cityData->GetGrossCityGold();
totalCommerceCrime += cityData->GetTradeCrime();
totalCommerceWages += cityData->CalcWages();
totalCommerceBuildingUpkeep += commerceBuildingUpkeep;
totalCommerceScience += cityData->GetScience();
totalTrade += cityData->GetNetCityGold();
}
sint32 percentCommerceCrime = totalCommerce ?
((totalCommerceCrime * 100) / totalCommerce) : 0;
sint32 percentCommerceWages = totalCommerce ?
((totalCommerceWages * 100) / totalCommerce) : 0;
sint32 percentCommerceBuildingUpkeep = totalCommerce ?
((totalCommerceBuildingUpkeep * 100) / totalCommerce) : 0;
sint32 percentCommerceScience = totalCommerce ?
((totalCommerceScience * 100) / totalCommerce) : 0;
sint32 percentCommerceSavings = 100 - (percentCommerceCrime +
percentCommerceWages + percentCommerceBuildingUpkeep +
percentCommerceScience);
gslog_print(" Total Commerce: %d\n", totalCommerce);
gslog_print(" Total Commerce After Science: %d\n", totalCommerce - totalCommerceScience);
gslog_print(" Commerce Crime: %d (%d%%)\n", totalCommerceCrime, percentCommerceCrime);
gslog_print(" Commerce Wages: %d (%d%%)\n", totalCommerceWages, percentCommerceWages);
gslog_print(" Commerce Building Upkeep: %d (%d%%)\n", totalCommerceBuildingUpkeep, percentCommerceBuildingUpkeep);
gslog_print(" Commerce Science: %d (%d%%):\n", totalCommerceScience, percentCommerceScience);
gslog_print(" Commerce Savings %%: %d\n", percentCommerceSavings);
gslog_print(" Net Trade: %d\n", totalTrade);
gslog_print(" Total accumulated science: %d\n", pl->m_science->GetLevel());
sint32 riot, content, happy;
sint32 totalCities = g_player[player]->CountCityHappiness(riot, content, happy);
gslog_print(" Total cities: %d\n", totalCities);
gslog_print(" Rioting: %d\n", riot);
gslog_print(" Content: %d\n", content);
gslog_print(" Happy: %d\n", happy);
sint32 pop = 0;
sint32 partialPop = 0;
sint32 i;
for(i = 0; i < g_player[player]->m_all_cities->Num(); i++) {
pop += g_player[player]->m_all_cities->Access(i).PopCount();
partialPop += g_player[player]->m_all_cities->Access(i).CD()->GetPartialPopulation();
}
sint32 totalPartialPop = (pop * k_PEOPLE_PER_POPULATION) + partialPop;
gslog_print(" Total population: %d/%d, +%d\n", pop, totalPartialPop, totalPartialPop - s_populationHack[player]);
s_populationHack[player] = totalPartialPop;
sint32 totalUnits = g_player[player]->m_all_units->Num();
sint32 totalMilUnits = 0;
sint32 totalOffense = 0;
for(i = 0; i < totalUnits; i++) {
const UnitRecord *rec = g_player[player]->m_all_units->Access(i).GetDBRec();
if(rec->GetAttack() > 0.001) {
totalMilUnits++;
totalOffense += (sint32)rec->GetAttack();
}
}
gslog_print(" Total Units: %d\n", totalUnits);
gslog_print(" Total Military Units: %d\n", totalMilUnits);
gslog_print(" Total Attack Strength: %d\n", totalOffense);
double s;
g_player[player]->m_tax_rate->GetScienceTaxRate(s);
gslog_print(" Settings:\n");
gslog_print(" Science Tax: %d\n", AsPercentage(s));
gslog_print(" PW: %d\n", sint32(g_player[player]->m_materialsTax * 100));
gslog_print(" Workday: %d\n", g_player[player]->m_global_happiness->GetUnitlessWorkday());
gslog_print(" Wages: %d\n", g_player[player]->m_global_happiness->GetUnitlessWages());
gslog_print(" Rations: %d\n", g_player[player]->m_global_happiness->GetUnitlessRations());
gslog_print(" Current research: %s\n", g_theAdvanceDB->Get(g_player[player]->m_advances->GetResearching())->GetNameText());
#endif
}
sint32 TradeManager::CompareSummaryItems(ctp2_ListItem *item1, ctp2_ListItem *item2, sint32 column)
{
TradeRoute route1 = TradeRoute(uint32(item1->GetUserData()));
TradeRoute route2 = TradeRoute(uint32(item2->GetUserData()));
Assert(route1.IsValid());
Assert(route2.IsValid());
if(!route1.IsValid() || !route2.IsValid()) {
return 0;
}
ROUTE_TYPE rtype1, rtype2;
sint32 resource1, resource2;
route1.GetSourceResource(rtype1, resource1);
route2.GetSourceResource(rtype2, resource2);
switch(column) {
case k_CITY_COL_SUM_INDEX:
Assert(route1.GetSource().IsValid());
Assert(route2.GetSource().IsValid());
if(route1.GetSource().IsValid() && route2.GetSource().IsValid()) {
return stricmp(route1.GetSource().GetName(), route2.GetSource().GetName());
}
return 0;
case k_PIRACY_COL_SUM_INDEX:
{
sint32 pl1 = -1;
sint32 pl2 = -1;
if(route1->IsBeingPirated()) {
pl1 = route1->GetPiratingArmy().GetOwner();
}
if(route2->IsBeingPirated()) {
pl2 = route2->GetPiratingArmy().GetOwner();
}
return pl1 - pl2;
}
case k_GOOD_COL_SUM_INDEX:
case k_GOODICON_COL_SUM_INDEX:
{
const MBCHAR *str1 = rtype1 == ROUTE_TYPE_RESOURCE ? g_theResourceDB->Get(resource1)->GetNameText() :
g_theStringDB->GetNameStr("ROUTE_TYPE_FOOD");
const MBCHAR *str2 = rtype2 == ROUTE_TYPE_RESOURCE ? g_theResourceDB->Get(resource2)->GetNameText() :
g_theStringDB->GetNameStr("ROUTE_TYPE_FOOD");
return stricmp(str1, str2);
}
case k_TOCITY_COL_SUM_INDEX:
Assert(route1.GetDestination().IsValid());
Assert(route2.GetDestination().IsValid());
if(route1.GetDestination().IsValid() && route2.GetDestination().IsValid()) {
return stricmp(route1.GetDestination().GetName(), route2.GetDestination().GetName());
}
return 0;
case k_PRICE_COL_SUM_INDEX:
return route1->GetValue() - route2->GetValue();
case k_CARAVANS_COL_SUM_INDEX:
return sint32(route1.GetCost() - route2.GetCost());
case k_NATION_COL_SUM_INDEX:
Assert(route1.GetDestination().IsValid());
Assert(route2.GetDestination().IsValid());
if(route1.GetDestination().IsValid() && route2.GetDestination().IsValid()) {
if(route1.GetDestination().GetOwner() == route2.GetDestination().GetOwner()) {
return stricmp(route1.GetDestination().GetName(), route2.GetDestination().GetName());
} else {
return route1.GetDestination().GetOwner() - route2.GetDestination().GetOwner();
}
}
return 0;
default:
Assert(FALSE);
return 0;
}
}
