BaseForm::DialogResult BaseForm::ShowModal(BaseForm * owner)
{
MSG msg;
dlgOwner = owner;
dlgOwner->SetEnabled(false);
dlgResult = BaseForm::Cancel;
if (firstShown)
{
int l = (owner->GetWidth()-GetWidth())/2;
int t = (owner->GetHeight()-GetHeight())/2;
SetLeft(l+owner->GetLeft());
SetTop(t+owner->GetTop());
firstShown = false;
}
Show();
while (GetMessage(&msg, NULL, 0,0)>0)
{
HWND hwnd = GetActiveWindow();
if (!accelTable || !TranslateAccelerator(hwnd,
accelTable->GetHandle(), &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (closed)
break;
}
dlgOwner->SetEnabled(true);
//SetActiveWindow(dlgOwner->GetHandle());
dlgOwner = NULL;
return dlgResult;
}
Gui::~Gui()
{
if (Widget::widgetExists(mTop))
{
SetTop(WidgetPtr());
}
}
void wxRect2DDouble::Union( const wxPoint2DDouble &pt )
{
wxDouble x = pt.m_x;
wxDouble y = pt.m_y;
if ( x < m_x )
{
SetLeft( x );
}
else if ( x < m_x + m_width )
{
// contained
}
else
{
SetRight( x );
}
if ( y < m_y )
{
SetTop( y );
}
else if ( y < m_y + m_height )
{
// contained
}
else
{
SetBottom( y );
}
}
//LoadScript
//>>>Resets the stack<<<
//and runs a lua script of the name given in filename
//--------------------------------------------------------------------------------
bool LuaInterpreter::LoadScript(std::string filename)
{
SetTop();
std::string file = "Assets/Scripts/" + filename + ".lua";
const char * ccfile = file.c_str();
return (luaL_dofile(LuaState, ccfile) == 0);
}
CTextFileLoader::CTextFileLoader()
: m_dwcurLineIndex(0), mc_pData(NULL)
{
SetTop();
m_globalNode.strGroupName = "global";
m_globalNode.pParentNode = NULL;
}
KIWAY::KIWAY( PGM_BASE* aProgram, int aCtlBits, wxFrame* aTop ):
m_program( aProgram ),
m_ctl( aCtlBits ),
m_top( 0 )
{
SetTop( aTop ); // hook player_destroy_handler() into aTop.
memset( m_player, 0, sizeof( m_player ) );
}
void wxRect2DInt::ConstrainTo( const wxRect2DInt &rect )
{
if ( GetLeft() < rect.GetLeft() )
SetLeft( rect.GetLeft() );
if ( GetRight() > rect.GetRight() )
SetRight( rect.GetRight() );
if ( GetBottom() > rect.GetBottom() )
SetBottom( rect.GetBottom() );
if ( GetTop() < rect.GetTop() )
SetTop( rect.GetTop() );
}
//--------------------------------------------------------------------
void CButton::Create( IGUIControl* p_pParent, int p_nLeft, int p_nTop,
CBitmap& p_Bitmap,const std::wstring& p_szCaption )
{
IGUIControl::Create();
SetParent( p_pParent );
SetLeft( p_nLeft );
SetTop( p_nTop );
SetGlygh( p_Bitmap );
SetCaption( p_szCaption );
if( m_pColor == NULL )
{
SetFontColor( *(new CColor( CColor::WHITE )) );
}
}
//--------------------------------------------------------------------
void CForm::Create( IGUIControl* p_pParent, int p_nLeft, int p_nTop,
int p_nWidth, int p_nHeight )
{
IGUIControl::Create();
SetParent( p_pParent );
SetLeft( p_nLeft );
SetTop( p_nTop );
SetWidth( p_nWidth );
SetHeight( p_nHeight );
if( m_pColor == NULL )
{
SetFontColor( *(new CColor( CColor::WHITE )) );
}
}
//--------------------------------------------------------------------
void CForm::MouseMove( POINT p_Point )
{
if( !m_bMoveable )
{
return;
}
if( m_bHolding )
{
SetLeft( p_Point.x - m_OffsetPT.x );
SetTop( p_Point.y - m_OffsetPT.y );
}
IGUIControl::MouseMove( p_Point );
}
//--------------------------------------------------------------------
void CForm::Create( IGUIControl* p_pParent, int p_nLeft, int p_nTop,
CBitmap& p_Bitmap )
{
IGUIControl::Create();
SetParent( p_pParent );
SetLeft( p_nLeft );
SetTop( p_nTop );
SetBG( p_Bitmap );
SetWidth( p_Bitmap.Width() );
SetHeight( p_Bitmap.Height() );
if( m_pColor == NULL )
{
SetFontColor( *(new CColor( CColor::WHITE )) );
}
}
void Scrollbar::Thumb::Arrange()
{
if (auto sb = _scrollbar.lock())
{
auto scrollDelegate = sb->GetScrollDelegate();
auto p = GetParent();
SetLeft(p->GetLeft());
SetRight(p->GetRight());
auto trackHeight = p->GetHeight();
auto height = scrollDelegate->GetThumbSizePercent() * trackHeight;
auto top = p->GetTop() + (scrollDelegate->GetCurrentOffsetPercent() * trackHeight);
SetTop(std::round(top));
SetBottom(std::round(top + height));
}
}
//--------------------------------------------------------------------
void CScrollBar::Create( IGUIControl* p_pParent, int p_nLeft, int p_nTop,
ENUM_ScrollBarType p_eType, CBitmap& p_Bitmap, int p_nLength )
{
IGUIControl::Create();
SetParent( p_pParent );
SetLeft( p_nLeft );
SetTop( p_nTop );
SetType( p_eType );
SetLength( p_nLength );
SetSlider( p_Bitmap );
if( m_pColor == NULL )
{
SetFontColor( *(new CColor( CColor::WHITE )) );
}
}
KIWAY::KIWAY( PGM_BASE* aProgram, int aCtlBits, wxFrame* aTop ):
m_program( aProgram ),
m_ctl( aCtlBits ),
m_top( 0 )
{
SetTop( aTop ); // hook player_destroy_handler() into aTop.
// Prepare the room to store the frame names, once they will be created
// with FRAME_T type as index in this table.
// (note this is a list of frame names, but a non empty entry
// does not mean the frame still exists. It means only the frame was created
// at least once. It can be destroyed after. These entries are not cleared.
// the purpose is just to allow a call to wxWindow::FindWindowByName(), from
// a FRAME_T frame type
m_playerFrameName.Add( wxEmptyString, KIWAY_PLAYER_COUNT );
}
void Background::init(float a, int w, int h){
SetTop(root);
for(int y = -h; y < h; y++){
int par = (y>0?y:-y)%2;
float xoffset = par*1.5*a;
for(int x = -w/2; x <= w/2 - par; x++){
auto tile = std::make_shared<BackgroundDrawableTile>();
tile->SetScale(a);
tile->SetPosRelative(glm::vec2(3*a*x + xoffset, a*y*SQRT3*0.5));
root->LinkChild(tile);
auto tile_l = std::make_shared<BackgroundDrawableLines>();
tile_l->SetScale(a);
tile_l->SetPosRelative(glm::vec2(3*a*x + xoffset, a*y*SQRT3*0.5));
root->LinkChild(tile_l);
drawables_l.push_back(tile_l);
}
}
}
void CDiagramEntity::SetRect( double left, double top, double right, double bottom )
/* ============================================================
Function : CDiagramEntity::SetRect
Description : Sets the object rect.
Return : void
Parameters : double left - Left edge
double top - Top edge
double right - Right edge
double bottom - Bottom edge
Usage : Call to place the object.
============================================================*/
{
SetLeft( left );
SetTop( top );
SetRight( right );
SetBottom( bottom );
if( GetMinimumSize().cx != -1 )
if( GetRect().Width() < GetMinimumSize().cx )
SetRight( GetLeft() + GetMinimumSize().cx );
if( GetMinimumSize().cy != -1 )
if( GetRect().Height() < GetMinimumSize().cy )
SetBottom( GetTop() + GetMinimumSize().cy );
if( GetMaximumSize().cx != -1 )
if( GetRect().Width() > GetMaximumSize().cx )
SetRight( GetLeft() + GetMaximumSize().cx );
if( GetMaximumSize().cy != -1 )
if( GetRect().Height() > GetMaximumSize().cy )
SetBottom( GetTop() + GetMaximumSize().cy );
if( GetPropertySheet() )
GetPropertySheet()->SetValues();
}
/*踏遍棋盘算法*/
void Path(int xx, int yy)
{
int c[N*N]={0},h[N*N]={0};
SqStack a;
SElemType ptemp;
SElemType pop_temp,get_temp;
SElemType p,dest_p; /*当前点和目标点*/
int step=0,x,y,s,k=1,l=1,d =0;
char ch;
p.x = xx; p.y = yy;p.z = 0;/*初始化出发点*/
board[xx][yy]=1;
InitStack(&a);
Push(&a,p); /*起始点的坐标和首选方向入栈*/
while(1)
{
if (step==(N*N-1))
{
output(a);
printf("退出/返回/下一条路径?q/b/n\n");
printf("第%d条路径",k);
ch=getch();
if(ch=='b') {CLS;main();}
else
if(ch=='q') exit(1);
else /*寻找下一条路径*/
{
k++;/*路径数加1*/
Pop(&a,&pop_temp); /*退栈*/
GetTop(a,&get_temp); /*取当前栈顶元素*/
SetTop(a,&ptemp); /*更改方向*/
step--;
continue;
}
}
if(StackEmpty(a)) break;
GetTop(a,&p);
x=p.x; y=p.y; d=p.z;
if(d>=8)/*该点所有方向已走完，退栈*/
{
board[x][y]=0; /*抹去痕迹*/
step--; /*步数减一*/
Pop(&a,&pop_temp); /*退栈*/
GetTop(a,&get_temp); /*取当前栈顶元素*/
SetTop(a,&get_temp); /*更改方向*/
} /*end if (d>=8)*/
if(d<8)/*方向未走完*/
{
s=map[x][y][d];/*map[x][y][0]未必是(x,y)点的HTry[0]方向,
而是到该点可到的权值最小的点的方向即HTry[map[x][y][0]*/
dest_p.x=x+HTry[s].x;
dest_p.y=y+HTry[s].y;
if(check(dest_p.x,dest_p.y)&&board[dest_p.x][dest_p.y]==0)
/*目标点在棋盘内且未被走过,则将目标点入栈同时标记当前点为已走过*/
{
h[step]=step;
board[x][y]=1;step++;/*步数加一*/
dest_p.z=0;Push(&a,dest_p);/*存入目标点,方向栈初始*/
}
else/*目标点已被走过或目标点不在棋盘内,换方向*/
SetTop(a,&p);/*切换方向*/
} /*enf if(d<8)*/
} /*end while(1)*/
}
/// <summary>
/// Construct the scene which will have a fixed rect.
/// Construct all points, pens and axes.
/// </summary>
/// <param name="parent">Pass to the parent</param>
CurvesGraphicsView::CurvesGraphicsView(QWidget* parent)
: QGraphicsView(parent)
{
m_Scene.setSceneRect(0, 0, 245, 245);
m_AllP1 = new EllipseItem(QRectF(-5, -5, 10, 10), 0, 1, this);
m_AllP1->setBrush(QBrush(Qt::GlobalColor::black));
m_AllP2 = new EllipseItem(QRectF(-5, -5, 10, 10), 0, 2, this);
m_AllP2->setBrush(QBrush(Qt::GlobalColor::black));
m_RedP1 = new EllipseItem(QRectF(-5, -5, 10, 10), 1, 1, this);
m_RedP1->setBrush(QBrush(Qt::GlobalColor::red));
m_RedP2 = new EllipseItem(QRectF(-5, -5, 10, 10), 1, 2, this);
m_RedP2->setBrush(QBrush(Qt::GlobalColor::red));
m_GrnP1 = new EllipseItem(QRectF(-5, -5, 10, 10), 2, 1, this);
m_GrnP1->setBrush(QBrush(Qt::GlobalColor::green));
m_GrnP2 = new EllipseItem(QRectF(-5, -5, 10, 10), 2, 2, this);
m_GrnP2->setBrush(QBrush(Qt::GlobalColor::green));
m_BluP1 = new EllipseItem(QRectF(-5, -5, 10, 10), 3, 1, this);
m_BluP1->setBrush(QBrush(Qt::GlobalColor::blue));
m_BluP2 = new EllipseItem(QRectF(-5, -5, 10, 10), 3, 2, this);
m_BluP2->setBrush(QBrush(Qt::GlobalColor::blue));
m_AxisPen = QPen(Qt::GlobalColor::white);
m_XLine = new QGraphicsLineItem();
m_XLine->setPen(m_AxisPen);
m_XLine->setZValue(0);
m_YLine = new QGraphicsLineItem();
m_YLine->setPen(m_AxisPen);
m_YLine->setZValue(0);
m_Scene.addItem(m_AllP1); m_Points[0].first = m_AllP1; m_AllP1->setZValue(2);
m_Scene.addItem(m_AllP2); m_Points[0].second = m_AllP2; m_AllP2->setZValue(2);
m_Scene.addItem(m_RedP1); m_Points[1].first = m_RedP1;
m_Scene.addItem(m_RedP2); m_Points[1].second = m_RedP2;
m_Scene.addItem(m_GrnP1); m_Points[2].first = m_GrnP1;
m_Scene.addItem(m_GrnP2); m_Points[2].second = m_GrnP2;
m_Scene.addItem(m_BluP1); m_Points[3].first = m_BluP1;
m_Scene.addItem(m_BluP2); m_Points[3].second = m_BluP2;
m_Scene.addItem(m_XLine);
m_Scene.addItem(m_YLine);
m_APen = QPen(Qt::GlobalColor::black); m_Pens[0] = &m_APen;
m_RPen = QPen(Qt::GlobalColor::red); m_Pens[1] = &m_RPen;
m_GPen = QPen(Qt::GlobalColor::green); m_Pens[2] = &m_GPen;
m_BPen = QPen(Qt::GlobalColor::blue); m_Pens[3] = &m_BPen;
m_APen.setWidth(2);
m_RPen.setWidth(2);
m_GPen.setWidth(2);
m_BPen.setWidth(2);
setScene(&m_Scene);
SetTop(CurveIndex::ALL);
//qDebug() << "Original scene rect before setting anything is: " << sceneRect();
m_OriginalRect = sceneRect();
show();
//qDebug() << "Original scene rect is: " << m_OriginalRect;
}
// RAGE AGAINST THE VIRTUAL MACHINE =)
gmThread::State gmThread::Sys_Execute(gmVariable * a_return)
{
register union
{
const gmuint8 * instruction;
const gmuint32 * instruction32;
};
register gmVariable * top;
gmVariable * base;
gmVariable * operand;
const gmuint8 * code;
if(m_state != RUNNING) return m_state;
#if GMDEBUG_SUPPORT
if(m_debugFlags && m_machine->GetDebugMode() && m_machine->m_isBroken)
{
if(m_machine->m_isBroken(this))
return RUNNING;
}
#endif // GMDEBUG_SUPPORT
// make sure we have a stack frame
GM_ASSERT(m_frame);
GM_ASSERT(GetFunction()->m_type == GM_FUNCTION);
// cache our "registers"
gmFunctionObject * fn = (gmFunctionObject *) GM_MOBJECT(m_machine, GetFunction()->m_value.m_ref);
code = (const gmuint8 *) fn->GetByteCode();
if(m_instruction == NULL) instruction = code;
else instruction = m_instruction;
top = GetTop();
base = GetBase();
//
// start byte code execution
//
for(;;)
{
#ifdef GM_CHECK_USER_BREAK_CALLBACK // This may be defined in gmConfig_p.h
// Check external source to break execution with exception eg. Check for CTRL-BREAK
// Endless loop protection could be implemented with this, or in a similar manner.
if( gmMachine::s_userBreakCallback && gmMachine::s_userBreakCallback(this) )
{
GMTHREAD_LOG("User break. Execution halted.");
goto LabelException;
}
#endif //GM_CHECK_USER_BREAK_CALLBACK
switch(*(instruction32++))
{
//
// unary operator
//
#if GM_USE_INCDECOPERATORS
case BC_OP_INC :
case BC_OP_DEC :
#endif
case BC_BIT_INV :
case BC_OP_NEG :
case BC_OP_POS :
case BC_OP_NOT :
{
operand = top - 1;
gmOperatorFunction op = OPERATOR(operand->m_type, (gmOperator) instruction32[-1]);
if(op)
{
op(this, operand);
}
else if((fn = CALLOPERATOR(operand->m_type, (gmOperator) instruction32[-1])))
{
operand[2] = operand[0];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 3);
State res = PushStackFrame(1, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
else
{
GMTHREAD_LOG("unary operator %s undefined for type %s", gmGetOperatorName((gmOperator) instruction32[-1]), m_machine->GetTypeName(operand->m_type));
goto LabelException;
}
break;
}
//
// operator
//
case BC_OP_ADD :
case BC_OP_SUB :
case BC_OP_MUL :
case BC_OP_DIV :
case BC_OP_REM :
case BC_BIT_OR :
case BC_BIT_XOR :
case BC_BIT_AND :
case BC_BIT_SHL :
case BC_BIT_SHR :
case BC_OP_LT :
case BC_OP_GT :
case BC_OP_LTE :
case BC_OP_GTE :
case BC_OP_EQ :
case BC_OP_NEQ :
{
operand = top - 2;
--top;
// NOTE: Classic logic for operators. Higher type processes the operation.
register gmType t1 = operand[1].m_type;
if(operand->m_type > t1) t1 = operand->m_type;
gmOperatorFunction op = OPERATOR(t1, (gmOperator) instruction32[-1]);
if(op)
{
op(this, operand);
}
else if((fn = CALLOPERATOR(t1, (gmOperator) instruction32[-1])))
{
operand[2] = operand[0];
operand[3] = operand[1];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 4);
State res = PushStackFrame(2, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
else
{
GMTHREAD_LOG("operator %s undefined for type %s and %s", gmGetOperatorName((gmOperator) instruction32[-1]), m_machine->GetTypeName(operand->m_type), m_machine->GetTypeName((operand + 1)->m_type));
goto LabelException;
}
break;
}
case BC_GETIND :
{
operand = top - 2;
--top;
gmOperatorFunction op = OPERATOR(operand->m_type, (gmOperator) instruction32[-1]);
if(op)
{
op(this, operand);
}
else if((fn = CALLOPERATOR(operand->m_type, (gmOperator) instruction32[-1])))
{
operand[2] = operand[0];
operand[3] = operand[1];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 4);
State res = PushStackFrame(2, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
else
{
GMTHREAD_LOG("operator %s undefined for type %s and %s", gmGetOperatorName((gmOperator) instruction32[-1]), m_machine->GetTypeName(operand->m_type), m_machine->GetTypeName((operand + 1)->m_type));
goto LabelException;
}
break;
}
case BC_SETIND :
{
operand = top - 3;
top -= 3;
gmOperatorFunction op = OPERATOR(operand->m_type, O_SETIND);
if(op)
{
op(this, operand);
}
else if((fn = CALLOPERATOR(operand->m_type, O_SETIND)))
{
operand[4] = operand[2];
operand[3] = operand[1];
operand[2] = operand[0];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 5);
State res = PushStackFrame(3, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
else
{
GMTHREAD_LOG("setind failed.");
goto LabelException;
}
break;
}
case BC_NOP :
{
break;
}
case BC_LINE :
{
#if GMDEBUG_SUPPORT
if(m_machine->GetDebugMode() && m_machine->m_line)
{
SetTop(top);
m_instruction = instruction;
if(m_machine->m_line(this)) return RUNNING;
}
#endif // GMDEBUG_SUPPORT
break;
}
case BC_GETDOT :
{
operand = top - 1;
gmptr member = OPCODE_PTR(instruction);
top->m_type = GM_STRING;
top->m_value.m_ref = member;
gmType t1 = operand->m_type;
gmOperatorFunction op = OPERATOR(t1, O_GETDOT);
if(op)
{
op(this, operand);
if(operand->m_type) break;
}
if(t1 == GM_NULL)
{
GMTHREAD_LOG("getdot failed.");
goto LabelException;
}
*operand = m_machine->GetTypeVariable(t1, gmVariable(GM_STRING, member));
break;
}
case BC_SETDOT :
{
operand = top - 2;
gmptr member = OPCODE_PTR(instruction);
top->m_type = GM_STRING;
top->m_value.m_ref = member;
top -= 2;
gmOperatorFunction op = OPERATOR(operand->m_type, O_SETDOT);
if(op)
{
op(this, operand);
}
else
{
GMTHREAD_LOG("setdot failed.");
goto LabelException;
}
break;
}
case BC_BRA :
{
instruction = code + OPCODE_PTR_NI(instruction);
break;
}
case BC_BRZ :
{
#if GM_BOOL_OP
operand = top - 1;
--top;
if (operand->m_type > GM_USER)
{
// Look for overridden operator.
gmOperatorFunction op = OPERATOR(operand->m_type, O_BOOL);
if (op)
{
op(this, operand);
}
else if ((fn = CALLOPERATOR(operand->m_type, O_BOOL)))
{
operand[2] = operand[0];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 3);
// Return to the same instruction after making the call but it will be testing the results of the call.
--instruction32;
State res = PushStackFrame(1, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
}
if(operand->m_value.m_int == 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#else // !GM_BOOL_OP
--top;
if(top->m_value.m_int == 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#endif // !GM_BOOL_OP
break;
}
case BC_BRNZ :
{
#if GM_BOOL_OP
operand = top - 1;
--top;
if (operand->m_type > GM_USER)
{
// Look for overridden operator.
gmOperatorFunction op = OPERATOR(operand->m_type, O_BOOL);
if (op)
{
op(this, operand);
}
else if ((fn = CALLOPERATOR(operand->m_type, O_BOOL)))
{
operand[2] = operand[0];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 3);
// Return to the same instruction after making the call but it will be testing the results of the call.
--instruction32;
State res = PushStackFrame(1, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
}
if(operand->m_value.m_int != 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#else // !GM_BOOL_OP
--top;
if(top->m_value.m_int != 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#endif // !GM_BOOL_OP
break;
}
case BC_BRZK :
{
#if GM_BOOL_OP
operand = top - 1;
if (operand->m_type > GM_USER)
{
// Look for overridden operator.
gmOperatorFunction op = OPERATOR(operand->m_type, O_BOOL);
if (op)
{
op(this, operand);
}
else if ((fn = CALLOPERATOR(operand->m_type, O_BOOL)))
{
operand[2] = operand[0];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 3);
// Return to the same instruction after making the call but it will be testing the results of the call.
--instruction32;
State res = PushStackFrame(1, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
}
if(operand->m_value.m_int == 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#else // !GM_BOOL_OP
if(top[-1].m_value.m_int == 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#endif // !GM_BOOL_OP
break;
}
case BC_BRNZK :
{
#if GM_BOOL_OP
operand = top - 1;
if (operand->m_type > GM_USER)
{
// Look for overridden operator.
gmOperatorFunction op = OPERATOR(operand->m_type, O_BOOL);
if (op)
{
op(this, operand);
}
else if ((fn = CALLOPERATOR(operand->m_type, O_BOOL)))
{
operand[2] = operand[0];
operand[0] = gmVariable(GM_NULL, 0);
operand[1] = gmVariable(GM_FUNCTION, fn->GetRef());
SetTop(operand + 3);
// Return to the same instruction after making the call but it will be testing the results of the call.
--instruction32;
State res = PushStackFrame(1, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING) break;
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED) { m_machine->Sys_SwitchState(this, KILLED); GM_ASSERT(0); } // operator should not kill a thread
return res;
}
}
if(operand->m_value.m_int != 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#else // !GM_BOOL_OP
if(top[-1].m_value.m_int != 0)
{
instruction = code + OPCODE_PTR_NI(instruction);
}
else instruction += sizeof(gmptr);
#endif // !GM_BOOL_OP
break;
}
case BC_CALL :
{
SetTop(top);
int numParams = (int) OPCODE_INT(instruction);
State res = PushStackFrame(numParams, &instruction, &code);
top = GetTop();
base = GetBase();
if(res == RUNNING)
{
#if GMDEBUG_SUPPORT
if(m_debugFlags && m_machine->GetDebugMode() && m_machine->m_call)
{
m_instruction = instruction;
if(m_machine->m_call(this)) return RUNNING;
}
#endif // GMDEBUG_SUPPORT
break;
}
if(res == SYS_YIELD) return RUNNING;
if(res == SYS_EXCEPTION) goto LabelException;
if(res == KILLED)
{
if(a_return) *a_return = m_stack[m_top - 1];
m_machine->Sys_SwitchState(this, KILLED);
}
return res;
}
case BC_RET :
{
PUSHNULL;
}
case BC_RETV :
{
SetTop(top);
int res = Sys_PopStackFrame(instruction, code);
top = GetTop();
base = GetBase();
if(res == RUNNING)
{
#if GMDEBUG_SUPPORT
if(m_debugFlags && m_machine->GetDebugMode() && m_machine->m_return)
{
m_instruction = instruction;
if(m_machine->m_return(this)) return RUNNING;
}
#endif // GMDEBUG_SUPPORT
break;
}
if(res == KILLED)
{
if(a_return) *a_return = *(top - 1);
m_machine->Sys_SwitchState(this, KILLED);
return KILLED;
}
if(res == SYS_EXCEPTION) goto LabelException;
break;
}
#if GM_USE_FORK
// duplicates the current thread and just the local stack frame
// and branches around the forked section of code
case BC_FORK :
{
int id;
gmThread* newthr = GetMachine()->CreateThread(&id);
GM_ASSERT( newthr );
// make sure there is enough room
newthr->Touch( m_size - m_base + 2 - GMTHREAD_SLACKSPACE);
// copy stack and vars
memcpy( newthr->m_stack, &m_stack[ m_base - 2 ], sizeof( gmVariable ) * (m_top - m_base + 2 ) );
newthr->m_top = m_top - m_base + 2;
newthr->m_frame = m_machine->Sys_AllocStackFrame();
newthr->m_frame->m_prev = 0;
newthr->m_frame->m_returnAddress = 0;
newthr->m_frame->m_returnBase = 0;
newthr->m_base = 2;
newthr->m_instruction = instruction + sizeof(gmptr); // skip branch on other thread
newthr->PushInt( GetId() );
instruction = code + OPCODE_PTR_NI( instruction ); // branch
top->m_type = GM_INT;
top->m_value.m_int = newthr->GetId();
++top;
break;
}
#endif //GM_USE_FORK
case BC_FOREACH :
{
gmuint32 localvalue = OPCODE_INT(instruction);
gmuint32 localkey = localvalue >> 16;
localvalue &= 0xffff;
// iterator is at tos-1, table is at tos -2, push int 1 if continuing loop. write key and value into localkey and localvalue
if(top[-2].m_type != GM_TABLE)
{
#if GM_USER_FOREACH
gmTypeIteratorCallback itrfunc = m_machine->GetUserTypeIteratorCallback(top[-2].m_type);
if (!itrfunc)
{
GMTHREAD_LOG("foreach expression has no iterator function");
goto LabelException;
}
gmTypeIterator it = (gmTypeIterator) top[-1].m_value.m_int;
gmUserObject *obj = (gmUserObject*)GM_MOBJECT(m_machine, top[-2].m_value.m_ref);
// Do callback for getnext
gmVariable localvar;
gmVariable localkeyvar;
itrfunc(this, obj, it, &localkeyvar, &localvar);
if (it != GM_TYPE_ITR_NULL)
{
base[localkey] = localkeyvar;
base[localvalue] = localvar;
top->m_type = GM_INT; top->m_value.m_int = 1;
}
else
{
top->m_type = GM_INT; top->m_value.m_int = 0;
}
top[-1].m_value.m_int = it;
++top;
#else //GM_USER_FOREACH (original)
GMTHREAD_LOG("foreach expression is not table type");
goto LabelException;
#endif //GM_USER_FOREACH
}
else
{
GM_ASSERT(top[-1].m_type == GM_INT);
gmTableIterator it = (gmTableIterator) top[-1].m_value.m_int;
gmTableObject * table = (gmTableObject *) GM_MOBJECT(m_machine, top[-2].m_value.m_ref);
gmTableNode * node = table->GetNext(it);
top[-1].m_value.m_int = it;
if(node)
{
base[localkey] = node->m_key;
base[localvalue] = node->m_value;
top->m_type = GM_INT; top->m_value.m_int = 1;
}
else
{
top->m_type = GM_INT; top->m_value.m_int = 0;
}
++top;
}
break;
}
case BC_POP :
{
--top;
break;
}
case BC_POP2 :
{
top -= 2;
break;
}
case BC_DUP :
{
top[0] = top[-1];
++top;
break;
}
case BC_DUP2 :
{
top[0] = top[-2];
top[1] = top[-1];
top += 2;
break;
}
case BC_SWAP :
{
top[0] = top[-1];
top[-1] = top[-2];
top[-2] = top[0];
break;
}
case BC_PUSHNULL :
{
PUSHNULL;
break;
}
case BC_PUSHINT :
{
top->m_type = GM_INT;
top->m_value.m_int = OPCODE_INT(instruction);
++top;
break;
}
case BC_PUSHINT0 :
{
top->m_type = GM_INT;
top->m_value.m_int = 0;
++top;
break;
}
case BC_PUSHINT1 :
{
top->m_type = GM_INT;
top->m_value.m_int = 1;
++top;
break;
}
case BC_PUSHFP :
{
top->m_type = GM_FLOAT;
top->m_value.m_float = OPCODE_FLOAT(instruction);
++top;
break;
}
case BC_PUSHSTR :
{
top->m_type = GM_STRING;
top->m_value.m_ref = OPCODE_PTR(instruction);
++top;
break;
}
case BC_PUSHTBL :
{
SetTop(top);
top->m_type = GM_TABLE;
top->m_value.m_ref = m_machine->AllocTableObject()->GetRef();
++top;
break;
}
case BC_PUSHFN :
{
top->m_type = GM_FUNCTION;
top->m_value.m_ref = OPCODE_PTR(instruction);
++top;
break;
}
case BC_PUSHTHIS :
{
*top = *GetThis();
++top;
break;
}
case BC_GETLOCAL :
{
gmuint32 offset = OPCODE_INT(instruction);
*(top++) = base[offset];
break;
}
case BC_SETLOCAL :
{
gmuint32 offset = OPCODE_INT(instruction);
// Write barrier old local objects
{
gmGarbageCollector* gc = m_machine->GetGC();
if( !gc->IsOff() && base[offset].IsReference() )
{
gmObject * object = GM_MOBJECT(m_machine, base[offset].m_value.m_ref);
gc->WriteBarrier(object);
}
}
base[offset] = *(--top);
break;
}
case BC_GETGLOBAL :
{
top->m_type = GM_STRING;
top->m_value.m_ref = OPCODE_PTR(instruction);
*top = m_machine->GetGlobals()->Get(*top); ++top;
break;
}
case BC_SETGLOBAL :
{
top->m_type = GM_STRING;
top->m_value.m_ref = OPCODE_PTR(instruction);
m_machine->GetGlobals()->Set(m_machine, *top, *(top-1)); --top;
break;
}
case BC_GETTHIS :
{
gmptr member = OPCODE_PTR(instruction);
const gmVariable * thisVar = GetThis();
*top = *thisVar;
top[1].m_type = GM_STRING;
top[1].m_value.m_ref = member;
gmOperatorFunction op = OPERATOR(thisVar->m_type, O_GETDOT);
if(op)
{
op(this, top);
if(top->m_type) { ++top; break; }
}
if(thisVar->m_type == GM_NULL)
{
GMTHREAD_LOG("getthis failed. this is null");
goto LabelException;
}
*top = m_machine->GetTypeVariable(thisVar->m_type, top[1]);
++top;
break;
}
case BC_SETTHIS :
{
gmptr member = OPCODE_PTR(instruction);
const gmVariable * thisVar = GetThis();
operand = top - 1;
*top = *operand;
*operand = *thisVar;
top[1].m_type = GM_STRING;
top[1].m_value.m_ref = member;
--top;
gmOperatorFunction op = OPERATOR(thisVar->m_type, O_SETDOT);
if(op)
{
op(this, operand);
}
else
{
GMTHREAD_LOG("setthis failed.");
goto LabelException;
}
break;
}
default :
{
break;
}
}
}
LabelException:
//
// exception handler
//
m_instruction = instruction;
// spit out error info
LogLineFile();
LogCallStack();
// call machine exception handler
if(gmMachine::s_machineCallback)
{
if(gmMachine::s_machineCallback(m_machine, MC_THREAD_EXCEPTION, this))
{
#if GMDEBUG_SUPPORT
// if we are being debugged, put this thread into a limbo state, waiting for delete.
if(m_machine->GetDebugMode() && m_machine->m_debugUser)
{
m_machine->Sys_SwitchState(this, EXCEPTION);
return EXCEPTION;
}
#endif
}
}
// kill the thread
m_machine->Sys_SwitchState(this, KILLED);
return KILLED;
}
bool CGrayMapBlockState::CheckTile_Terrain( DWORD wItemBlockFlags, signed char z, DWORD dwID )
{
ADDTOCALLSTACK("CGrayMapBlockState::CheckTile_Terrain");
// RETURN:
// true = continue processing
if ( ! wItemBlockFlags ) // no effect.
return( true );
if ( z < m_Bottom.m_z ) // below something i can already step on.
{
return true;
}
if ( z < m_Lowest.m_z )
{
m_Lowest.m_dwBlockFlags = wItemBlockFlags;
m_Lowest.m_dwTile = dwID;
m_Lowest.m_z = z;
}
if ( z <= m_iHeight )
{
if ( z >= m_Bottom.m_z )
{
if ( (m_Bottom.m_dwBlockFlags & (CAN_I_PLATFORM|CAN_I_CLIMB)) && (z - m_Bottom.m_z <= 4) )
return true;
if ( z == m_Bottom.m_z )
{
if ( m_Bottom.m_dwBlockFlags & CAN_I_CLIMB ) // climbable items have the highest priority
{
return ( true );
}
if ( ( m_Bottom.m_dwBlockFlags & CAN_I_PLATFORM ) && (!( wItemBlockFlags & CAN_I_PLATFORM )) )
{
return ( true );
}
}
else if ( z > m_z + PLAYER_HEIGHT/2 )
{
if ( (m_Bottom.m_dwBlockFlags & (CAN_I_PLATFORM|CAN_I_CLIMB)) && (z >= m_Bottom.m_z + PLAYER_HEIGHT/2) ) // we can walk under it
{
SetTop( wItemBlockFlags, z, dwID );
return true;
}
}
else if ( z == m_z )
{
if ( (m_Bottom.m_dwBlockFlags & (CAN_I_PLATFORM|CAN_I_CLIMB)) && (z - m_Bottom.m_z <= 4) )
return true;
}
//DEBUG_ERR(("wItemBlockFlags 0x%lx\n",wItemBlockFlags));
m_Bottom.m_dwBlockFlags = wItemBlockFlags;
m_Bottom.m_dwTile = dwID;
m_Bottom.m_z = z;
m_zClimbHeight = 0;
}
}
else
{
SetTop( wItemBlockFlags, z, dwID ); // I could potentially fit under this. ( it would be above me )
}
return true;
}
