static void handleRequest(struct evcenter *center, int fd, void *data, int mask) { struct client *client; struct conn *conn; ssize_t nread, ret; struct timeval start, end; long time_use; struct slice slice; size_t parsed; parsed = 0; ret = 0; client = data; gettimeofday(&start, NULL); nread = WorkerProcess->worker->recvData(client); if (!isClientValid(client)) { freeClient(client); return ; } if (msgGetSize(client->req_buf) > getStatVal(StatBufferSize)) { getStatVal(StatBufferSize) = msgGetSize(client->req_buf); } while (msgCanRead(client->req_buf)) { conn = connGet(client); msgRead(client->req_buf, &slice); ret = client->protocol->parser(conn, &slice, &parsed); if (ret == WHEAT_WRONG) { wheatLog(WHEAT_NOTICE, "parse data failed"); msgSetReaded(client->req_buf, 0); setClientUnvalid(client); break; } else if (ret == WHEAT_OK) { msgSetReaded(client->req_buf, parsed); getStatVal(StatTotalRequest)++; client->pending = NULL; ret = client->protocol->spotAppAndCall(conn); if (ret != WHEAT_OK) { getStatVal(StatFailedRequest)++; client->should_close = 1; wheatLog(WHEAT_NOTICE, "app failed"); break; } } else if (ret == 1) { client->pending = conn; msgSetReaded(client->req_buf, parsed); continue; } } tryFreeClient(client); gettimeofday(&end, NULL); time_use = 1000000 * (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec); getStatVal(StatRunTime) += time_use; }
int isClientNeedSend(struct client *c) { struct listNode *node; struct conn *send_conn; if (listLength(c->conns) && isClientValid(c)) { node = listFirst(c->conns); send_conn = listNodeValue(node); if (listLength(send_conn->send_queue) || send_conn->ready_send) { return 1; } } return 0; }
void tryFreeClient(struct client *c) { if (isClientValid(c) && (isClientNeedSend(c) || !c->should_close)) return; freeClient(c); }
void EntityPlayer::onMove(EntityData & data, shared_ptr<World> world, float deltaTimeIn) const { getEntity(data, world); assert(data.extraData); auto eData = dynamic_pointer_cast<ExtraData>(data.extraData); assert(eData); data.deltaAcceleration = VectorF(0); data.acceleration = gravityVector; if(eData->flying) data.acceleration = VectorF(0); int count = iceil(deltaTimeIn * abs(data.velocity) / 0.5 + 1); BlockIterator bi = world->get((PositionI)data.position); data.entity->acceleration = data.acceleration; data.entity->deltaAcceleration = data.deltaAcceleration; auto pphysicsObject = make_shared<PhysicsBox>((VectorF)data.position + physicsOffset(), physicsExtents(), data.velocity, data.entity->acceleration, data.entity->deltaAcceleration, data.position.d, physicsProperties(), -physicsOffset()); PhysicsBox & physicsObject = *pphysicsObject; for(int step = 0; step < count; step++) { float deltaTime = deltaTimeIn / count; data.entity->age += deltaTime; int zeroCount = 0; while(deltaTime * deltaTime * absSquared(data.velocity) > eps * eps) { bool supported = false; PhysicsCollision firstCollision(data.position + deltaTime * data.velocity + deltaTime * deltaTime * 0.5f * data.entity->acceleration + deltaTime * deltaTime * deltaTime * (1 / 6.0f) * data.entity->deltaAcceleration, data.velocity + deltaTime * data.entity->acceleration + deltaTime * deltaTime * 0.5f * data.entity->deltaAcceleration, VectorF(0), deltaTime); physicsObject.reInit((VectorF)data.position + physicsOffset(), physicsExtents(), data.velocity, data.entity->acceleration, data.entity->deltaAcceleration); for(int dx = -1; dx <= 1; dx++) { for(int dy = -2; dy <= 2; dy++) { for(int dz = -1; dz <= 1; dz++) { BlockIterator curBI = bi; curBI += VectorI(dx, dy, dz); shared_ptr<PhysicsObject> otherObject; if(curBI.get().good()) otherObject = curBI.get().desc->getPhysicsObject(curBI.position()); else otherObject = static_pointer_cast<PhysicsObject>(make_shared<PhysicsBox>((VectorI)curBI.position() + VectorF(0.5), VectorF(0.5), VectorF(0), VectorF(0), VectorF(0), curBI.position().d, PhysicsProperties(PhysicsProperties::INFINITE_MASS, 1, 0))); assert(otherObject); { bool filled = false; float newY; switch(otherObject->type()) { case PhysicsObject::Type::Box: { const PhysicsBox * pbox = dynamic_cast<const PhysicsBox *>(otherObject.get()); VectorF min = pbox->center - pbox->extents; VectorF max = pbox->center + pbox->extents; if(min.x <= curBI.position().x && max.x >= curBI.position().x + 1 && min.y <= curBI.position().y && max.y >= curBI.position().y + 1 && min.z <= curBI.position().z && max.z >= curBI.position().z + 1) { newY = max.y + physicsObject.extents.y - physicsOffset().y; filled = true; } VectorF temp; if(isBoxCollision(pbox->center, pbox->extents, physicsObject.center - VectorF(0, eps * 10, 0) + physicsOffset(), physicsObject.extents, temp) && !isBoxCollision(pbox->center, pbox->extents, physicsObject.center + physicsOffset(), physicsObject.extents, temp)) { supported = true; } break; } case PhysicsObject::Type::None: break; } if(filled && zeroCount >= 2 && dx == 0 && dy == 0 && dz == 0) { firstCollision.time = 0; firstCollision.newPosition = data.position; firstCollision.newPosition.y = newY; firstCollision.newVelocity = VectorF(0); firstCollision.collisionNormal = VectorF(0, 1, 0); break; } } PhysicsCollision collision = physicsObject.collide(otherObject, deltaTime); if(collision.valid) { if(collision.time < eps) { if(zeroCount > 25) collision.valid = false; else zeroCount++; } else zeroCount = 0; } if(collision.valid && collision.time < firstCollision.time) firstCollision = collision; } } } deltaTime -= firstCollision.time; data.setPosition(firstCollision.newPosition + eps * (2 + abs(firstCollision.newVelocity)) * firstCollision.collisionNormal); data.setVelocity(firstCollision.newVelocity); data.setAcceleration(data.entity->acceleration + data.entity->deltaAcceleration * firstCollision.time); } } if(eData->pclient == nullptr || !isClientValid(*eData->pclient)) { data.clear(); return; } }