HashReturn Update(hashState *state, const BitSequence *data, DataLength databitlen)
{
if ((databitlen % 8) == 0)
return Absorb((spongeState*)state, data, databitlen);
else {
HashReturn ret = Absorb((spongeState*)state, data, databitlen - (databitlen % 8));
if (ret == HASH_SUCCESS) {
unsigned char lastByte;
// Align the last partial byte to the least significant bits
lastByte = data[databitlen/8] >> (8 - (databitlen % 8));
return Absorb((spongeState*)state, &lastByte, databitlen % 8);
}
else
return ret;
void SurfaceStream_TripleBuffer::Init(SurfaceStream* prevStream)
{
if (!prevStream)
return;
SharedSurface* prevProducer = nullptr;
SharedSurface* prevConsumer = nullptr;
prevStream->SurrenderSurfaces(prevProducer, prevConsumer);
if (prevConsumer == prevProducer)
prevConsumer = nullptr;
mProducer = Absorb(prevProducer);
mConsumer = Absorb(prevConsumer);
}
SurfaceStream_SingleBuffer::SurfaceStream_SingleBuffer(SurfaceStream* prevStream)
: SurfaceStream(SurfaceStreamType::SingleBuffer, prevStream)
, mConsumer(nullptr)
{
if (!prevStream)
return;
SharedSurface* prevProducer = nullptr;
SharedSurface* prevConsumer = nullptr;
prevStream->SurrenderSurfaces(prevProducer, prevConsumer);
if (prevConsumer == prevProducer)
prevConsumer = nullptr;
mProducer = Absorb(prevProducer);
mConsumer = Absorb(prevConsumer);
}
SurfaceStream_TripleBuffer_Copy::SurfaceStream_TripleBuffer_Copy(SurfaceStream* prevStream)
: SurfaceStream(SurfaceStreamType::TripleBuffer_Copy, prevStream)
, mStaging(nullptr)
, mConsumer(nullptr)
{
if (!prevStream)
return;
SharedSurface* prevProducer = nullptr;
SharedSurface* prevConsumer = nullptr;
prevStream->SurrenderSurfaces(prevProducer, prevConsumer);
if (prevConsumer == prevProducer)
prevConsumer = nullptr;
mProducer = Absorb(prevProducer);
mConsumer = Absorb(prevConsumer);
}
/**
* @brief Change the ion velocity due to the laser cooling and trapping forces.
* The trapping force is handled first by calling the parent class kick
* function. The radiation pressure and friction force (cooling) are calculated
* and applied.
*
* @param dt Time step.
*/
inline void LaserCooledIon::kick(double dt) {
this->TrappedIon::kick(dt);
// 1D radiation pressure force.
Vector3D pressure(0.0, 0.0, 0.015);
// Randomly apply pressure from positive or negative \c z direction,
// weighted by the `direction` parameter.
if (heater_.kick_direction(ionType_.direction))
this->Ion::kick(dt, pressure);
else
this->Ion::kick(dt, -pressure);
const double dtred = dt;
const double force_scale = std::pow(trap_params.energy_scale, 0.5)/trap_params.time_scale;
// 1D Laser cooling friction force
// This force must be evaluated last to allow its effect to be
// undone by the call to velocity_scale
Vector3D f(0,0,0);
double time_per_loop = (1e-9)/trap_params.time_scale;
for(double i = 0.0; i < (dtred); i += time_per_loop){
double fs1 = fscatt(1)*time_per_loop;
double fs2 = fscatt(-1)*time_per_loop;
double amu = 1.66053904e-27;
//std::cout<<fscatt(1)<<"\n"<<std::flush;
assert(fs1<1 && fs2<1);
if (ElecState == 1){
if (fs1>fs2 && heater_.testfscatt(fs1 + (time_per_loop*ionType_.A21))) {f = Emit(time_per_loop)*1.0/(time_per_loop*ionType_.mass*amu); this->Ion::kick(time_per_loop, f);}
if (fs2>fs1 && heater_.testfscatt(fs2 + (time_per_loop*ionType_.A21))) {f = Emit(time_per_loop)*1.0/(time_per_loop*ionType_.mass*amu); this->Ion::kick(time_per_loop, f);}
}
else if (ElecState == 0) {
if (fs1>fs2 && heater_.testfscatt(fs1)) {f = Absorb(time_per_loop) *-1.0/(time_per_loop*ionType_.mass*amu); this->Ion::kick(time_per_loop, f);}
if (fs2>fs1 && heater_.testfscatt(fs2)) {f = Absorb(time_per_loop) *1.0/(time_per_loop*ionType_.mass*amu); this->Ion::kick(time_per_loop, f);}
}
//std::cout<<fs<<"f\n"<<std::flush;
}
return;
}
static int
compress_keccak (uint8_t *out, const uint8_t *blocks[], unsigned int blocks_to_comp)
{
spongeState sponge;
if (InitSponge (&sponge, KECCAK_RATE, KECCAK_CAPACITY))
return ERROR_KECCAK;
for (unsigned int i = 0; i < blocks_to_comp; i++) {
if (Absorb (&sponge, blocks[i], 8 * KECCAK_1600_BLOCK_SIZE))
return ERROR_KECCAK;
}
if (Squeeze (&sponge, out, 8 * KECCAK_1600_BLOCK_SIZE))
return ERROR_KECCAK;
return ERROR_NONE;
}
FunctionT &&Absorb(FunctionT &&vFunction, FirstT &&vFirst, RemainingT &&...vRemaining){
std::forward<FunctionT>(vFunction)(std::forward<FirstT>(vFirst));
Absorb(std::forward<FunctionT>(vFunction), std::forward<RemainingT>(vRemaining)...);
return std::forward<FunctionT>(vFunction);
}
void keccak128(const unsigned char* in, const unsigned long long inlen, unsigned char *out) {
spongeState state;
InitSponge(&state, 1344, 256);
Absorb(&state, in, inlen*8);
Squeeze(&state, out, 128);
}
bool Officer::Advance( Unit *_unit )
{
if( !m_onGround ) AdvanceInAir(_unit);
bool amIDead = Entity::Advance(_unit);
if( m_inWater != -1.0f ) AdvanceInWater(_unit);
if( m_onGround && !m_dead ) m_pos.y = g_app->m_location->m_landscape.m_heightMap->GetValue( m_pos.x, m_pos.z );
//
// Advance in whatever state we are in
if( !amIDead && m_onGround && m_inWater == -1.0f )
{
switch( m_state )
{
case StateIdle : amIDead = AdvanceIdle(); break;
case StateToWaypoint : amIDead = AdvanceToWaypoint(); break;
case StateGivingOrders : amIDead = AdvanceGivingOrders(); break;
}
}
if( m_dead )
{
m_vel.y -= 20.0f;
m_pos.y += m_vel.y * SERVER_ADVANCE_PERIOD;
}
//
// If we are giving orders, render them
if( m_orders == OrderGoto )
{
if( syncfrand() < 0.05f )
{
OfficerOrders *orders = new OfficerOrders();
orders->m_pos = m_pos + Vector3(0,2,0);
orders->m_wayPoint = m_orderPosition;
int index = g_app->m_location->m_effects.PutData( orders );
orders->m_id.Set( m_id.GetTeamId(), UNIT_EFFECTS, index, -1 );
orders->m_id.GenerateUniqueId();
}
}
//
// If we are absorbing, look around for Darwinians
if( m_absorb ) Absorb();
//
// Attack anything nearby with our "shield"
if( m_shield > 0 )
{
WorldObjectId id = g_app->m_location->m_entityGrid->GetBestEnemy( m_pos.x, m_pos.z, 0.0f, OFFICER_ATTACKRANGE, m_id.GetTeamId() );
if( id.IsValid() )
{
Entity *entity = g_app->m_location->GetEntity( id );
entity->ChangeHealth( -10 );
m_shield --;
Vector3 themToUs = m_pos - entity->m_pos;
g_app->m_location->SpawnSpirit( m_pos, themToUs, 0, WorldObjectId() );
}
}
//
// Use teleports. Remember which teleport we entered,
// As there may be people following us
if( m_wayPointTeleportId != -1 )
{
int teleportId = EnterTeleports(m_wayPointTeleportId);
if( teleportId != -1 )
{
m_ordersBuildingId = teleportId;
Teleport *teleport = (Teleport *) g_app->m_location->GetBuilding( teleportId );
Vector3 exitPos, exitFront;
bool exitFound = teleport->GetExit( exitPos, exitFront );
if( exitFound ) m_wayPoint = exitPos + exitFront * 30.0f;
if( m_orders == OrderGoto ) m_orders = OrderNone;
m_wayPointTeleportId = -1;
}
}
return amIDead || m_demoted;
}