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;
}
}
