void GBStackBrain::FirePeriodic(GBSensorState & sensor, GBWorld * world) {
	GBFrames period = PopInteger();
	if ( world->CurrentFrame() >= sensor.Time() + period || sensor.Time() <= 0 ) {
		sensor.Fire();
		remaining = 0;
		PushBoolean(true);
	} else PushBoolean(false);
}
Beispiel #2
0
int KeyEvent::PushToStack(lua_State * l)
{
	PushInteger(l, key);
	PushInteger(l, scan);
	PushBoolean(l, repeat);
	PushBoolean(l, shift);
	PushBoolean(l, ctrl);
	PushBoolean(l, alt);

	return 6;
}
void GBStackBrain::ExecutePrimitive(GBSymbolIndex index, GBRobot * robot, GBWorld * world) {
	GBStackDatum temp, temp2, temp3;
	long tempInt;
	switch ( index ) {
		case opNop: break;
	// stack manipulation
		case opDrop: Pop(); break;
		case op2Drop: Pop(); Pop(); break;
		case opNip: temp = Pop(); Pop(); Push(temp); break;
		case opRDrop: PopReturn(); break;
		case opDropN: {
			int n = PopInteger();
			if ( n > stackHeight ) throw GBBadArgumentError();
			stackHeight -= n;
		} break;
		case opSwap: temp = Pop(); temp2 = Pop(); Push(temp); Push(temp2); break;
		case op2Swap: { GBVector v1 = PopVector(); GBVector v2 = PopVector();
			PushVector(v1); PushVector(v2); } break;
		case opRotate: temp = Pop(); temp2 = Pop(); temp3 = Pop(); Push(temp2); Push(temp); Push(temp3); break;
		case opReverseRotate: temp = Pop(); temp2 = Pop(); temp3 = Pop(); Push(temp); Push(temp3); Push(temp2); break;
		case opDup: temp = Peek(); Push(temp); break;
		case op2Dup: temp = Peek(2); temp2 = Peek(); Push(temp); Push(temp2); break;
		case opTuck: temp = Pop(); temp2 = Pop(); Push(temp); Push(temp2); Push(temp); break;
		case opOver: temp = Peek(2); Push(temp); break;
		case op2Over: temp = Peek(4); temp2 = Peek(3); Push(temp); Push(temp2); break;
		case opStackHeight: Push(stackHeight); break;
		case opStackLimit: Push(kStackLimit); break;
		case opPick: Push(Peek(PopInteger())); break;
		case opToReturn: PushReturn(ToAddress(Pop())); break;
		case opFromReturn: Push(PopReturn()); break;
	// branches
		case opJump: pc = ToAddress(Pop()); break;
		case opCall: ExecuteCall(ToAddress(Pop())); break;
		case opReturn: pc = PopReturn(); break;
		case opIfGo: temp = Pop(); if ( Pop().Nonzero() ) pc = ToAddress(temp); break;
		case opIfElseGo: temp = Pop(); temp2 = Pop();
			if ( Pop().Nonzero() ) pc = ToAddress(temp2); else pc = ToAddress(temp); break;
		case opIfCall: temp = Pop(); if ( Pop().Nonzero() ) ExecuteCall(ToAddress(temp)); break;
		case opIfElseCall: temp = Pop(); temp2 = Pop();
			if ( Pop().Nonzero() ) ExecuteCall(ToAddress(temp2)); else ExecuteCall(ToAddress(temp)); break;
		case opIfReturn: if ( Pop().Nonzero() ) pc = PopReturn(); break;
		case opNotIfGo: temp = Pop(); if ( ! Pop().Nonzero() ) pc = ToAddress(temp); break;
		case opNotIfReturn: if ( ! Pop().Nonzero() ) pc = PopReturn(); break;
		case opNotIfCall: temp = Pop(); if ( ! Pop().Nonzero() ) ExecuteCall(ToAddress(temp)); break;
	// arithmetic
		case opAdd: TwoNumberToNumberOp(&GBNumber::operator +); break;
		case opSubtract: TwoNumberToNumberOp(&GBNumber::operator -); break;
		case opNegate: NumberToNumberOp(&GBNumber::operator -); break;
		// mult and divide are written out because of MrCpp internal error
		case opMultiply: temp = Pop(); Push(Pop() * temp); break;
		case opDivide: temp = Pop(); Push(Pop() / temp); break;
		case opReciprocal: Push(GBNumber(1) / Pop()); break;
		case opMod: TwoNumberToNumberOp(&GBNumber::Mod); break;
		case opRem: TwoNumberToNumberOp(&GBNumber::Rem); break;
		case opSqrt: NumberToNumberOp(&GBNumber::Sqrt); break;
		case opExponent: TwoNumberToNumberOp(&GBNumber::Exponent); break;
		case opIsInteger: PushBoolean(Pop().IsInteger()); break;
		case opFloor: Push(Pop().Floor()); break;
		case opCeiling: Push(Pop().Ceiling()); break;
		case opRound: Push(Pop().Round()); break;
		case opMin: TwoNumberToNumberOp(&GBNumber::Min); break;
		case opMax: TwoNumberToNumberOp(&GBNumber::Max); break;
		case opAbs: NumberToNumberOp(&GBNumber::Abs); break;
		case opSignum: NumberToNumberOp(&GBNumber::Signum); break;
		case opReorient: NumberToNumberOp(&GBNumber::Reorient); break;
		case opSine: NumberToNumberOp(&GBNumber::Sin); break;
		case opCosine: NumberToNumberOp(&GBNumber::Cos); break;
		case opTangent: NumberToNumberOp(&GBNumber::Tan); break;
		case opArcSine: NumberToNumberOp(&GBNumber::ArcSin); break;
		case opArcCosine: NumberToNumberOp(&GBNumber::ArcCos); break;
		case opArcTangent: NumberToNumberOp(&GBNumber::ArcTan); break;
		case opRandom: temp = Pop(); Push(world->Randoms().InRange(Pop(), temp)); break;
		case opRandomAngle: Push(world->Randoms().Angle()); break;
		case opRandomInt: temp = Pop(); Push(world->Randoms().LongInRange(Pop().Ceiling(), temp.Floor())); break;
		case opRandomBoolean: PushBoolean(world->Randoms().Boolean(Pop())); break;
	// constants
		case opPi: Push(GBNumber::pi); break;
		case op2Pi: Push(GBNumber::pi * 2); break;
		case opPiOver2: Push(GBNumber::pi / 2); break;
		case opE: Push(GBNumber::e); break;
		case opEpsilon: Push(GBNumber::epsilon); break;
		case opInfinity: Push(GBNumber::infinity); break;
	// vector operations
		case opRectToPolar: { GBVector v = PopVector(); Push(v.Norm()); Push(v.Angle()); } break;
		case opPolarToRect: temp = Pop(); temp2 = Pop(); PushVector(GBFinePoint::MakePolar(temp2, temp)); break;
		case opVectorAdd: TwoVectorToVectorOp(&GBFinePoint::operator +); break;
		case opVectorSubtract: TwoVectorToVectorOp(&GBFinePoint::operator -); break;
		case opVectorNegate: VectorToVectorOp(&GBFinePoint::operator -); break;
		case opVectorScalarMultiply: temp = Pop(); PushVector(PopVector() * temp); break;
		case opVectorScalarDivide: temp = Pop(); PushVector(PopVector() / temp); break;
		case opVectorNorm: VectorToScalarOp(&GBFinePoint::Norm); break;
		case opVectorAngle: VectorToScalarOp(&GBFinePoint::Angle); break;
		case opDotProduct: TwoVectorToScalarOp(&GBFinePoint::DotProduct);  break;
		case opProject: TwoVectorToVectorOp(&GBFinePoint::Projection); break;
		case opCross: TwoVectorToScalarOp(&GBFinePoint::Cross); break;
		case opUnitize: VectorToVectorOp(&GBFinePoint::Unit); break;
		case opDistance: Push((PopVector() - PopVector()).Norm()); break;
		case opInRange: temp = Pop(); PushBoolean(PopVector().InRange(PopVector(), temp)); break;
		case opRestrictPosition: {
			temp = Pop(); //wall distance
			GBVector pos = PopVector();
			Push(pos.x.Max(temp).Min(world->Size().x - temp));
			Push(pos.y.Max(temp).Min(world->Size().y - temp));
			} break;
		case opVectorEqual: PushBoolean(PopVector() == PopVector()); break;
		case opVectorNotEqual: PushBoolean(PopVector() != PopVector()); break;
	// comparisons
		case opEqual: PushBoolean(Pop() == Pop()); break;
		case opNotEqual: PushBoolean(Pop() != Pop()); break;
		case opLessThan: temp = Pop(); PushBoolean(Pop() < temp); break;
		case opLessThanOrEqual: temp = Pop(); PushBoolean(Pop() <= temp); break;
		case opGreaterThan: temp = Pop(); PushBoolean(Pop() > temp); break;
		case opGreaterThanOrEqual: temp = Pop(); PushBoolean(Pop() >= temp); break;
	// booleans
		case opNot: PushBoolean(! Pop().Nonzero()); break;
		case opAnd: temp = Pop(); temp2 = Pop(); PushBoolean(temp.Nonzero() && temp2.Nonzero()); break;
		case opOr: temp = Pop(); temp2 = Pop(); PushBoolean(temp.Nonzero() || temp2.Nonzero()); break;
		case opXor: temp = Pop(); temp2 = Pop();
			PushBoolean(temp.Nonzero() && ! temp2.Nonzero() || ! temp.Nonzero() && temp2.Nonzero()); break;
		case opNand: temp = Pop(); temp2 = Pop(); PushBoolean(! (temp.Nonzero() && temp2.Nonzero())); break;
		case opNor: temp = Pop(); temp2 = Pop(); PushBoolean(! (temp.Nonzero() || temp2.Nonzero())); break;
		case opValueConditional: temp = Pop(); temp2 = Pop();
			if ( Pop().Nonzero() ) Push(temp2); else Push(temp);
			break;
	// misc external
		case opPrint:
			DoPrint(ToString(Pop()));
			if ( world->reportPrints )
				NonfatalError(robot->Description() + " prints: " + *lastPrint);
			break;
		case opPrintVector:
			DoPrint(ToString(PopVector()));
			if ( world->reportPrints )
				NonfatalError(robot->Description() + " prints: " + *lastPrint);
			break;
		case opBeep: StartSound(siBeep); break;
		case opStop: SetStatus(bsStopped); break;
		case opPause: if ( world->reportErrors ) world->running = false; break;
		case opSync: remaining = 0; break;
	// basic hardware
		case opSeekLocation: robot->EngineSeek(PopVector(), GBVector(0, 0)); break;
		case opSeekMovingLocation: {
			GBVector vel = PopVector();
			robot->EngineSeek(PopVector(), vel);
			} break;
		case opDie: robot->Die(robot->Owner()); SetStatus(bsStopped); break;
		case opWriteLocalMemory:
			tempInt = PopInteger();
			WriteLocalMemory(tempInt, Pop(), robot);
			break;
		case opReadLocalMemory:
			tempInt = PopInteger();
			Push(ReadLocalMemory(tempInt, robot));
			break;
		case opWriteLocalVector:
			tempInt = PopInteger();
			WriteLocalMemory(tempInt + 1, Pop(), robot);
			WriteLocalMemory(tempInt, Pop(), robot);
			break;
		case opReadLocalVector:
			tempInt = PopInteger();
			Push(ReadLocalMemory(tempInt, robot));
			Push(ReadLocalMemory(tempInt + 1, robot));
			break;
		case opWriteSharedMemory:
			tempInt = PopInteger();
			robot->hardware.radio.Write(Pop(), tempInt, robot->Owner());
			break;
		case opReadSharedMemory:
			Push(robot->hardware.radio.Read(PopInteger(), robot->Owner()));
			break;
		case opWriteSharedVector:
			tempInt = PopInteger();
			robot->hardware.radio.Write(Pop(), tempInt + 1, robot->Owner());
			robot->hardware.radio.Write(Pop(), tempInt, robot->Owner());
			break;
		case opReadSharedVector:
			tempInt = PopInteger();
			Push(robot->hardware.radio.Read(tempInt, robot->Owner()));
			Push(robot->hardware.radio.Read(tempInt + 1, robot->Owner()));
			break;
		case opMessagesWaiting:
			Push(robot->hardware.radio.MessagesWaiting(PopInteger(), robot->Owner()));
			break;
		case opSendMessage: {
				GBMessage sendee;
				tempInt = PopInteger(); //channel
				int numArgs = ToInteger(Pop()); //number of numbers
				for ( int i = 0; i < numArgs; i++ ) {
					sendee.AddDatum(Pop()); //higher indices in message correspond with earlier numbers in stack. :(
				}
				if ( numArgs <= 0 )
					throw GBGenericError("Cannot send message of non-positive length");
				robot->hardware.radio.Send(sendee, tempInt, robot->Owner());
			} break;
		case opReceiveMessage: {
				tempInt = PopInteger();
				const GBMessage * received = robot->hardware.radio.Receive(tempInt, robot->Owner());
				if ( received == 0 ) {
					Push(0);
				} else {
					if ( received->Length() <= 0 ) {
						throw GBGenericError("non-positive length message received");
					}
					for ( int i = received->Length() - 1; i >= 0; i-- )
						Push(received->Datum(i));
					Push(received->Length());
				}
			} break;
		case opClearMessages:
			robot->hardware.radio.ClearChannel(PopInteger(), robot->Owner());
			break;
		case opSkipMessages:
			tempInt = PopInteger();
			robot->hardware.radio.SkipMessages(tempInt, PopInteger(), robot->Owner());
			break;
		case opTypePopulation: {
				GBRobotType * theType = robot->Owner()->GetType(PopInteger());
				if (theType)
					Push(theType->Population());
				else
					Push(-1);
			} break;
		case opAutoConstruct: {
			GBConstructorState & ctor = robot->hardware.constructor;
			if ( robot->Energy() > robot->hardware.MaxEnergy() * .9 ) {
				if ( ! ctor.Type() ) ctor.Start(robot->Type());
				ctor.SetRate(ctor.MaxRate());
			} else
				ctor.SetRate(ctor.Type() && robot->Energy() > ctor.Remaining() + 10 ? ctor.MaxRate() : GBNumber(0));
			} break;
		case opBalanceTypes: { // frac type --
				GBRobotType * theType = robot->Owner()->GetType(PopInteger());
				GBNumber fraction = Pop();
				if (theType && GBNumber(theType->Population()) < fraction * robot->Owner()->Scores().Population())
					robot->hardware.constructor.Start(theType); //FIXME don't abort?
			} break;
	// sensors
		case opFireRobotSensor: robot->hardware.sensor1.Fire(); break;
		case opFireFoodSensor: robot->hardware.sensor2.Fire(); break;
		case opFireShotSensor: robot->hardware.sensor3.Fire(); break;
		case opRobotSensorNext: Push(robot->hardware.sensor1.NextResult() ? 1 : 0); break;
		case opFoodSensorNext: Push(robot->hardware.sensor2.NextResult() ? 1 : 0); break;
		case opShotSensorNext: Push(robot->hardware.sensor3.NextResult() ? 1 : 0); break;
		case opPeriodicRobotSensor:
			FirePeriodic(robot->hardware.sensor1, world);
			break;
		case opPeriodicFoodSensor:
			FirePeriodic(robot->hardware.sensor2, world);
			break;
		case opPeriodicShotSensor:
			FirePeriodic(robot->hardware.sensor3, world);
			break;
	// weapons
		case opFireBlaster: robot->hardware.blaster.Fire(Pop()); break;
		case opFireGrenade: temp = Pop(); robot->hardware.grenades.Fire(Pop(), temp); break;
		case opLeadBlaster: { //pos vel --
			GBVelocity vel = PopVector() - robot->Velocity();
			GBPosition pos = PopVector() - robot->Position();
			GBPosition target = LeadShot(pos, vel, robot->hardware.blaster.Speed(), robot->Radius());
			if ( target.Nonzero() && target.Norm() <= robot->hardware.blaster.MaxRange() + robot->Radius() )
				robot->hardware.blaster.Fire(target.Angle());
			} break;
		case opLeadGrenade: { //pos vel --
			GBVelocity vel = PopVector() - robot->Velocity();
			GBPosition pos = PopVector() - robot->Position();
			GBPosition target = LeadShot(pos, vel, robot->hardware.grenades.Speed(), robot->Radius());
			if ( target.Nonzero() && target.Norm() <= robot->hardware.grenades.MaxRange() + robot->Radius() )
				robot->hardware.grenades.Fire(target.Norm(), target.Angle()); //worry about short range?
			} break;
		case opSetForceField: { //pos angle --
			temp = Pop();
			GBPosition pos = PopVector() - robot->Position();
			robot->hardware.forceField.SetDistance(pos.Norm());
			robot->hardware.forceField.SetDirection(pos.Angle());
			robot->hardware.forceField.SetAngle(temp);
			robot->hardware.forceField.SetPower(robot->hardware.forceField.MaxPower());
			} break;
	// otherwise...
		default:	
			throw GBUnknownInstructionError();
			break;
	}
}
Beispiel #4
0
Datei: vm.cpp Projekt: pangc/pvm
void VMachine::Execute(){
	int step=0;
	int index = -1;
	int index1,index2;
	ip = 0;
    void *op_lables[13];
    goto PREPARE;
LABEL_NOP:
    goto NEXT_INSTR;
LABEL_PUSH:
    operstack.push(instr[ip]._operand);
    goto NEXT_INSTR;
LABEL_POP:
     index = operstack.top();
     operstack.pop();
     FreeIndex.insert(index);
    goto NEXT_INSTR;
LABEL_GETTOP:
    index = operstack.top();
    goto NEXT_INSTR;
LABEL_JMP:
    step = instr[ip]._operand;
    goto NEXT_INSTR;
LABEL_IFJMP:
    index= operstack.top();
    operstack.pop();
    if(ObjTable[index].t == BOOLEAN)
        if(ObjTable[index].v.b ==1)
            step = instr[ip]._operand;
    goto NEXT_INSTR;
LABEL_ADD:
    index1 = operstack.top();
    operstack.pop();
    index2 = operstack.top();
    operstack.pop();
    if(ObjTable[index1].t != ObjTable[index2].t)
        vmerror("diffrent type to add\n");
    else{
        if(ObjTable[index1].t == NUMBER){
            ObjTable[index1].v.num = ObjTable[index1].v.num + ObjTable[index2].v.num;
            operstack.push(index1);
            FreeIndex.insert(index2);
        }
        else if(ObjTable[index1].t = STRING){
            ObjTable[index1].v.str = strcat(ObjTable[index1].v.str,ObjTable[index2].v.str);
            operstack.push(index1);
            FreeIndex.insert(index2);
        }
        else{
            vmerror("can not add this type\n");
        }
    }
    goto NEXT_INSTR;
LABEL_SUB:
    index1 = operstack.top();
    operstack.pop();
    index2 = operstack.top();
    operstack.pop();
    if(ObjTable[index1].t != ObjTable[index2].t)
        vmerror("diffrent type to add\n");
    else{
        if(ObjTable[index1].t == NUMBER){
            ObjTable[index1].v.num = ObjTable[index1].v.num + ObjTable[index2].v.num;
            operstack.push(index1);
            FreeIndex.insert(index2);
        }
        else{
            vmerror("can not add this type\n");
        }
    }
    goto NEXT_INSTR;
LABEL_MUL:
    index1 = operstack.top();
    operstack.pop();
    index2 = operstack.top();
    operstack.pop();
    if(ObjTable[index1].t != ObjTable[index2].t)
        vmerror("diffrent type to mul\n");
    else if(ObjTable[index1].t != NUMBER)
        vmerror("can not multiply non-numeric\n");
    else{
        ObjTable[index1].v.num = ObjTable[index1].v.num * ObjTable[index2].v.num;
        operstack.push(index1);
        FreeIndex.insert(index2);
    }
    goto NEXT_INSTR;
LABEL_DIV:
    index1 = operstack.top();
    operstack.pop();
    index2 = operstack.top();
    operstack.pop();
    if(ObjTable[index1].t != ObjTable[index2].t)
        vmerror("diffrent type to mul\n");
    else if(ObjTable[index1].t != NUMBER)
        vmerror("can not multiply non-numeric\n");
    else{
        ObjTable[index1].v.num = ObjTable[index1].v.num / ObjTable[index2].v.num;
        operstack.push(index1);
        FreeIndex.insert(index2);
    }
    goto NEXT_INSTR;
LABEL_EQ:
    index1 = operstack.top();
    operstack.pop();
    index2 = operstack.top();
    operstack.pop();
    if(ObjTable[index1].t != ObjTable[index2].t){
           vmerror("diffrent type");
    }
    else{
        switch(ObjTable[index1].t){
            case NUMBER:
                if(ObjTable[index1].v.num == ObjTable[index1].v.num)
                    PushBoolean(1);         //1表示真,压入栈vmstark
                else
                    PushBoolean(0);           //0表示假
                break;
            case STRING:
                if(strcmp(ObjTable[index1].v.str,ObjTable[index2].v.str)==0)
                    PushBoolean(1);
                else
                    PushBoolean(0);
                break;
            case BOOLEAN:
                if(ObjTable[index1].v.b == ObjTable[index1].v.b)
                    PushBoolean(1);         //1表示真,压入栈vmstark
                else
                    PushBoolean(0);           //0表示假
                break;
        }
    }
    goto NEXT_INSTR;
LABEL_LT:
    index1 = operstack.top();
    operstack.pop();
    index2 = operstack.top();
    operstack.pop();
    if(ObjTable[index1].t != ObjTable[index2].t){
           vmerror("diffrent type");
    }
    else{
        switch(ObjTable[index1].t){
            case NUMBER:
                if(ObjTable[index1].v.num < ObjTable[index1].v.num)
                    PushBoolean(1);         //1表示真,压入栈vmstark
                else
                    PushBoolean(0);           //0表示假
                break;
            case STRING:
                if(strcmp(ObjTable[index1].v.str,ObjTable[index2].v.str)<0)
                    PushBoolean(1);
                else
                    PushBoolean(0);
                break;
            case BOOLEAN:
                PushNil();
                break;
        }
    }
    goto NEXT_INSTR;
LABEL_GT:
    index1 = operstack.top();
    operstack.pop();
    index2 = operstack.top();
    operstack.pop();
    if(ObjTable[index1].t != ObjTable[index2].t){
           vmerror("diffrent type");
    }
    else{
        switch(ObjTable[index1].t){
            case NUMBER:
                if(ObjTable[index1].v.num > ObjTable[index1].v.num)
                    PushBoolean(1);         //1表示真,压入栈vmstark
                else
                    PushBoolean(0);           //0表示假
                break;
            case STRING:
                if(strcmp(ObjTable[index1].v.str,ObjTable[index2].v.str)>0)
                    PushBoolean(1);
                else
                    PushBoolean(0);
                break;
            case BOOLEAN:
                PushNil();
                break;
        }
    }
    goto NEXT_INSTR;
LABLE_UNKNOWN:
    vmerror("unknown opcode");
    goto NEXT_INSTR;
PREPARE:
    op_lables[0] = &&LABEL_NOP;
    op_lables[1] = &&LABEL_PUSH;
    op_lables[2] = &&LABEL_POP;
    op_lables[3] = &&LABEL_GETTOP;
    op_lables[4] = &&LABEL_JMP;
    op_lables[5] = &&LABEL_IFJMP;
    op_lables[6] = &&LABEL_ADD;
    op_lables[7] = &&LABEL_SUB;
    op_lables[8] = &&LABEL_MUL;
    op_lables[9] = &&LABEL_DIV;
    op_lables[10] = &&LABEL_EQ;
    op_lables[11] = &&LABEL_LT;
    op_lables[12] = &&LABEL_GT;
NEXT_INSTR:
    if(ip > 14) goto END;
    ip = ip+step;
    step = 1;
  //  showFree();
    showStack();
//    showObj();
    if(instr[ip]._opcode<256 || instr[ip]._opcode>(257+13)) goto LABLE_UNKNOWN;
    goto *op_lables[instr[ip]._opcode-257];
END:
	getchar();
}
Beispiel #5
0
void lua_pushboolean(lua_State* L, int b)
{
    PushBoolean(L, b != 0);
}