string RadomFormula::GetFormula() { p1 = rand() % 30; p2 = rand() % 30; op1 = rand() % OpArr.size(); int pi = Operate(op1, p1, p2); int s1 = -pi; int s2 = 30 - pi; if (s1 < -30) { s1 = -30; } if (s2 > 30) { s2 = 30; } p3 = s1 + rand() % (s2 - s1); if (p3 >= 0) { op2 = 0; } else { op2 = 1; p3 = -p3; } return Transport(p1) + OpArr[op1] + Transport(p2) + OpArr[op2] + Transport(p3) + "="; }
status_t BnRTCNode::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case kIDTransport: { rtc_binder_data_t out; out.data = &data; out.reply = reply; // Reserved 4 bytes; reply->writeInt32(0); int ret = Transport(&out); int pos = reply->dataPosition(); reply->setDataPosition(0); reply->writeInt32(ret); reply->setDataPosition(pos); return NO_ERROR; } break; case kIDResigerObs: { CHECK_INTERFACE(IRTCNode, data, reply); sp<IBinder> handle = data.readStrongBinder(); sp<IRTCNode> node = interface_cast<IRTCNode>(handle); int ret = RegisterObserver(node); reply->writeInt32(ret); return NO_ERROR; }break; default: return BBinder::onTransact(code, data, reply, flags); } }
status_t BnRTCBinder::onTransact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { switch(code) { case kDefault_CALL_ID: { rtc_binder_data_t out; out.data = &data; out.reply = reply; // Reserved 4 bytes reply->writeInt32(0); int ret = Transport(&out); int pos = reply->dataPosition(); reply->setDataPosition(0); // Rewrite 4 bytes reply->writeInt32(ret); reply->setDataPosition(pos); return NO_ERROR; } break; case kDefault_CreateNodeID: { CHECK_INTERFACE(IRTCBinder, data, reply); int type = 0; type = data.readInt32(); sp<IRTCNode> node = NewNode(type); #if ANDROID_SDK_VERSION >=23 reply->writeStrongBinder(node->asBinder(node.get())); #else reply->writeStrongBinder(node->asBinder()); #endif return NO_ERROR; } break; default: return BBinder::onTransact(code, data, reply, flags); } }
vector<Input::MetaCode> EventUserInput::AddCodesFromRawEvent(const RawEvent& RawEvent_) { vector<Input::MetaCode> Results; switch(RawEvent_.type) { case SDL_KEYUP: case SDL_KEYDOWN: case SDL_MOUSEBUTTONUP: case SDL_MOUSEBUTTONDOWN: case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP: Results.push_back(this->AddCode(RawEvent_)); break; case SDL_MOUSEMOTION:{ //Can contain Multiple Metacodes std::vector<Input::MetaCode> Transport(this->AddCodesFromSDLMouseMotion(RawEvent_)); Results.insert(Results.end(), Transport.begin(),Transport.end()); break;} case SDL_JOYAXISMOTION: { //Can contain Multiple Metacodes std::vector<Input::MetaCode> Transport(this->AddCodesFromSDLJoyStickMotion(RawEvent_)); Results.insert(Results.end(), Transport.begin(),Transport.end()); break;} case SDL_JOYBALLMOTION:{ std::vector<Input::MetaCode> Transport(this->AddCodeFromSDLJoyStickBall(RawEvent_)); Results.insert(Results.end(), Transport.begin(),Transport.end()); break;} case SDL_JOYHATMOTION:{ std::vector<Input::MetaCode> Transport(this->AddCodeFromSDLJoyStickHat(RawEvent_)); Results.insert(Results.end(), Transport.begin(),Transport.end()); break;} default: MEZZ_EXCEPTION(Exception::PARAMETERS_EXCEPTION,"Unknown SDL Event Inserted"); break; } return Results; }
nsresult nsHttpPipeline::FillSendBuf() { // reads from request queue, moving transactions to response queue // when they have been completely read. nsresult rv; if (!mSendBufIn) { // allocate a single-segment pipe rv = NS_NewPipe(getter_AddRefs(mSendBufIn), getter_AddRefs(mSendBufOut), nsIOService::gDefaultSegmentSize, /* segment size */ nsIOService::gDefaultSegmentSize, /* max size */ true, true); if (NS_FAILED(rv)) return rv; } PRUint32 n, avail; nsAHttpTransaction *trans; nsITransport *transport = Transport(); while ((trans = Request(0)) != nsnull) { avail = trans->Available(); if (avail) { // if there is already a response in the responseq then this // new data comprises a pipeline. Update the transaction in the // response queue to reflect that if necessary. We are now sending // out a request while we haven't received all responses. nsAHttpTransaction *response = Response(0); if (response && !response->PipelinePosition()) response->SetPipelinePosition(1); rv = trans->ReadSegments(this, avail, &n); if (NS_FAILED(rv)) return rv; if (n == 0) { LOG(("send pipe is full")); break; } mSendingToProgress += n; if (!mSuppressSendEvents && transport) { // Simulate a SENDING_TO event trans->OnTransportStatus(transport, NS_NET_STATUS_SENDING_TO, mSendingToProgress); } } avail = trans->Available(); if (avail == 0) { // move transaction from request queue to response queue mRequestQ.RemoveElementAt(0); mResponseQ.AppendElement(trans); mRequestIsPartial = false; if (!mSuppressSendEvents && transport) { // Simulate a WAITING_FOR event trans->OnTransportStatus(transport, NS_NET_STATUS_WAITING_FOR, mSendingToProgress); } // It would be good to re-enable data read handlers via ResumeRecv() // except the read handler code can be synchronously dispatched on // the stack. } else mRequestIsPartial = true; } return NS_OK; }
nsresult nsHttpPipeline::WriteSegments(nsAHttpSegmentWriter *writer, PRUint32 count, PRUint32 *countWritten) { LOG(("nsHttpPipeline::WriteSegments [this=%x count=%u]\n", this, count)); NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread"); if (mClosed) return NS_SUCCEEDED(mStatus) ? NS_BASE_STREAM_CLOSED : mStatus; nsAHttpTransaction *trans; nsresult rv; trans = Response(0); // This code deals with the establishment of a CONNECT tunnel through // an HTTP proxy. It allows the connection to do the CONNECT/200 // HTTP transaction to establish an SSL tunnel as a precursor to the // actual pipeline of regular HTTP transactions. if (!trans && mRequestQ.Length() && mConnection->IsProxyConnectInProgress()) { LOG(("nsHttpPipeline::WriteSegments [this=%p] Forced Delegation\n", this)); trans = Request(0); } if (!trans) { if (mRequestQ.Length() > 0) rv = NS_BASE_STREAM_WOULD_BLOCK; else rv = NS_BASE_STREAM_CLOSED; } else { // // ask the transaction to consume data from the connection. // PushBack may be called recursively. // rv = trans->WriteSegments(writer, count, countWritten); if (rv == NS_BASE_STREAM_CLOSED || trans->IsDone()) { trans->Close(NS_OK); // Release the transaction if it is not IsProxyConnectInProgress() if (trans == Response(0)) { NS_RELEASE(trans); mResponseQ.RemoveElementAt(0); mResponseIsPartial = false; ++mHttp1xTransactionCount; } // ask the connection manager to add additional transactions // to our pipeline. nsRefPtr<nsHttpConnectionInfo> ci; GetConnectionInfo(getter_AddRefs(ci)); if (ci) gHttpHandler->ConnMgr()->ProcessPendingQForEntry(ci); } else mResponseIsPartial = true; } if (mPushBackLen) { nsHttpPushBackWriter writer(mPushBackBuf, mPushBackLen); PRUint32 len = mPushBackLen, n; mPushBackLen = 0; // This progress notification has previously been sent from // the socket transport code, but it was delivered to the // previous transaction on the pipeline. nsITransport *transport = Transport(); if (transport) OnTransportStatus(transport, nsISocketTransport::STATUS_RECEIVING_FROM, mReceivingFromProgress); // the push back buffer is never larger than NS_HTTP_SEGMENT_SIZE, // so we are guaranteed that the next response will eat the entire // push back buffer (even though it might again call PushBack). rv = WriteSegments(&writer, len, &n); } return rv; }
void Army::Update( Logic& l, float delta_time, int i ) { if( !used ) return; int farm = l.GetFarmIndex( from ); int city = l.GetCityIndex( from ); int structure = l.GetStructureIndex( from ); // Feed if( state == Stationary && city != -1 ) { City& c( l.GetCityByIndex( city ) ); if( hunger > 0 ) { c.food_contained -= hunger; hunger = 0; } c.food_contained -= food_consumed * delta_time; } else if( state == Stationary && farm != -1 ) { Farm& f( l.GetFarmByIndex( farm ) ); if( hunger > 0 ) { f.food -= hunger; hunger = 0; } f.food -= food_consumed * delta_time; } else if( food_stored <= 0 ) { hunger += food_consumed * delta_time; float limit = soldiers + carts; if( hunger > limit ) { // Start the starving... muahahahaha. if( soldiers ) soldiers -= soldiers * 0.1 <= 1 ? 1: soldiers * 0.1; if( carts ) carts -= carts * 0.2 <= 1 ? 1: carts * 0.1; limit = soldiers + carts; hunger = limit - limit / 10; Calculate(); if( soldiers + carts < 1 ) { rectangles[ (int)Type::Army ].erase( l.GetArmies()[i].rectangle ); l.GetArmies().erase( i ); return; } } } else { if( hunger > 0 ) { food_stored -= hunger; hunger = 0; } food_stored -= food_consumed * delta_time; } if( state == Moving ) { Point& p = l.GetPoint( to ); float distance = speed * delta_time; float d_x = p.x - x; float d_y = p.y - y; if( d_y == 0 ) d_y = 0.0001; float t = Logic::L(d_x) / ( Logic::L(d_x) + Logic::L(d_y) ); float x_ = (p.x > x ? distance : -distance) * t; float y_ = (p.y > y ? distance : -distance) * (1-t); if( Logic::L(p.x - x) <= Logic::L(x_) ) x = p.x; if( Logic::L(p.y - y) <= Logic::L(y_) ) y = p.y; if( x == p.x && y == p.y ) { if( transporting != Resource::Nothing ) Transport( l, delta_time ); else Move( l, delta_time, i ); } else { x += x_; y += y_; } Calculate(); } else if( state == CollectFood && farm != -1 ) { Farm& f( l.GetFarmByIndex( farm ) ); float collected = soldiers * delta_time; f.food -= collected; food_stored += collected; if( food_stored > storage_capacity ) // TODO: Change later when more resources can be transported state = Stationary; } else if( state == CollectPeople ) { if( farm != -1 ) { Farm& f( l.GetFarmByIndex( farm ) ); float collected = soldiers * 10 * delta_time; people += collected; f.population -= collected; if( people > people_max ) { people = people_max; state = Stationary; } else if( f.population < 0 ) { f.population = 0; state = Stationary; } } else if( city != -1 ) { City& c( l.GetCityByIndex( city ) ); float collected = soldiers * 10 * delta_time; people += collected; c.population -= collected; if( people > people_max ) { people = people_max; state = Stationary; } else if( c.population < 0 ) { c.population = 0; state = Stationary; } } else if( structure != -1 ) { Structure& s( l.GetStructureByIndex( structure ) ); float collected = soldiers * 10 * delta_time; people += collected; s.population -= collected; if( people > people_max ) { people = people_max; state = Stationary; } else if( s.population < 0 ) { s.population = 0; state = Stationary; } } } else if( state == KillPeople ) { if( structure != -1 ) { Structure& s( l.GetStructureByIndex( structure ) ); s.population -= soldiers * 100 * delta_time; if( s.population < 0 ) { s.population = 0; state = Stationary; } } else if( city != -1 ) { City& c( l.GetCityByIndex( city ) ); c.population -= soldiers * 100 * delta_time; if( c.population < 0 ) { c.population = 0; state = Stationary; } } else if( farm != -1 ) { Farm& f( l.GetFarmByIndex( farm ) ); f.population -= soldiers * 100 * delta_time; if( f.population < 0 ) { f.population = 0; state = Stationary; } } } else if( state == DestroyFarm && farm != -1 ) { Farm& f( l.GetFarmByIndex( farm ) ); Rectangle& r( rectangles[ (int)Type::Farm ][f.rectangle] ); float size = r.scale * r.scale; size -= soldiers * 0.1 * delta_time; if( size <= 0.1 ) { l.RemoveFarm( from ); state = Stationary; } else { r.scale = size / r.scale; f.Calculate(); } } else if( state == DestroyCity && city != -1 ) { City& c( l.GetCityByIndex( city ) ); Rectangle& r( rectangles[ (int)Type::City ][c.rectangle] ); float size = r.scale * r.scale; size -= soldiers * 0.1 * delta_time; if( size <= 0.1 ) { l.RemoveCity( from ); state = Stationary; } else { r.scale = size / r.scale; c.Calculate(); } } else if( state == DestroyStructure && structure != -1 ) { Structure& s( l.GetStructureByIndex( structure ) ); Rectangle& r( rectangles[ (int)Type::Structure ][s.rectangle] ); if( s.build_progress <= 0.1 ) { l.RemoveStructure( from ); state = Stationary; } else s.build_progress -= soldiers * delta_time; } else if( state == Fighting ) { // TODO: Add later } }
nsresult nsHttpPipeline::FillSendBuf() { // reads from request queue, moving transactions to response queue // when they have been completely read. nsresult rv; if (!mSendBufIn) { // allocate a single-segment pipe rv = NS_NewPipe(getter_AddRefs(mSendBufIn), getter_AddRefs(mSendBufOut), nsIOService::gDefaultSegmentSize, /* segment size */ nsIOService::gDefaultSegmentSize, /* max size */ true, true); if (NS_FAILED(rv)) return rv; } PRUint32 n, avail; nsAHttpTransaction *trans; nsITransport *transport = Transport(); while ((trans = Request(0)) != nsnull) { avail = trans->Available(); if (avail) { rv = trans->ReadSegments(this, avail, &n); if (NS_FAILED(rv)) return rv; if (n == 0) { LOG(("send pipe is full")); break; } mSendingToProgress += n; if (!mSuppressSendEvents && transport) { // Simulate a SENDING_TO event trans->OnTransportStatus(transport, NS_NET_STATUS_SENDING_TO, mSendingToProgress); } } avail = trans->Available(); if (avail == 0) { // move transaction from request queue to response queue mRequestQ.RemoveElementAt(0); mResponseQ.AppendElement(trans); mRequestIsPartial = false; if (!mSuppressSendEvents && transport) { // Simulate a WAITING_FOR event trans->OnTransportStatus(transport, NS_NET_STATUS_WAITING_FOR, mSendingToProgress); } } else mRequestIsPartial = true; } return NS_OK; }
nsresult nsHttpPipeline::WriteSegments(nsAHttpSegmentWriter *writer, PRUint32 count, PRUint32 *countWritten) { LOG(("nsHttpPipeline::WriteSegments [this=%x count=%u]\n", this, count)); NS_ASSERTION(PR_GetCurrentThread() == gSocketThread, "wrong thread"); if (mClosed) return NS_SUCCEEDED(mStatus) ? NS_BASE_STREAM_CLOSED : mStatus; nsAHttpTransaction *trans; nsresult rv; trans = Response(0); if (!trans) { if (mRequestQ.Length() > 0) rv = NS_BASE_STREAM_WOULD_BLOCK; else rv = NS_BASE_STREAM_CLOSED; } else { // // ask the transaction to consume data from the connection. // PushBack may be called recursively. // rv = trans->WriteSegments(writer, count, countWritten); if (rv == NS_BASE_STREAM_CLOSED || trans->IsDone()) { trans->Close(NS_OK); NS_RELEASE(trans); mResponseQ.RemoveElementAt(0); mResponseIsPartial = false; ++mHttp1xTransactionCount; // ask the connection manager to add additional transactions // to our pipeline. gHttpHandler->ConnMgr()->AddTransactionToPipeline(this); } else mResponseIsPartial = true; } if (mPushBackLen) { nsHttpPushBackWriter writer(mPushBackBuf, mPushBackLen); PRUint32 len = mPushBackLen, n; mPushBackLen = 0; // This progress notification has previously been sent from // the socket transport code, but it was delivered to the // previous transaction on the pipeline. nsITransport *transport = Transport(); if (transport) OnTransportStatus(transport, nsISocketTransport::STATUS_RECEIVING_FROM, mReceivingFromProgress); // the push back buffer is never larger than NS_HTTP_SEGMENT_SIZE, // so we are guaranteed that the next response will eat the entire // push back buffer (even though it might again call PushBack). rv = WriteSegments(&writer, len, &n); } return rv; }