void Polynom::SetCoef(int ind, double val)
{
if (ind < 0) { // TODO : dublicated code
assert(!"Polynom::SetCoef : negative index");
return;
}
if (ind > Power() && val == 0.0)
return;
ExpandToIndex(ind);
m_coef[ind] = val;
}
std::vector<PowerControlStatus> PowerControlArbitrator::createInitialArbitratedPowerControlStatusVector()
{
// create a vector to temporarily store the arbitrated data. initialize to invalid.
std::vector<PowerControlStatus> arbitratedPowerControlStatusVector;
for (UIntN i = 0; i < PowerControlType::max; i++)
{
PowerControlStatus pcs = PowerControlStatus((PowerControlType::Type)i, Power(), Constants::Invalid, Percentage());
arbitratedPowerControlStatusVector.push_back(pcs);
}
return arbitratedPowerControlStatusVector;
}
static base_t my_powr(const base_t&i, int p, unsigned q)
{
base_t po(Power(i, p));
if((q & 0x1) && my_inf(po) < 0) {
if(my_sup(po) <= 0)
return -Root(Abs(po), q);
base_t r(Root(Abs(po), q));
r = base_t(-Sup(r), Sup(r));
return r;
}
return Root(po,q);
}
int main( void )
{
freopen("restore.in", "rt", stdin);
freopen("restore.out", "wt", stdout);
int M;
scanf("%d%d%d", &N, &M, &P);
memset(G, 0, sizeof(G));
for (int i = 0; i < M; i++)
{
int a, b;
scanf("%d%d", &a, &b);
G[a - 1][b - 1] = G[b - 1][a - 1] = 1;
}
int S, T;
scanf("%d%d", &S, &T), S--;
for (int i = 0; i < T; i++)
scanf("%d%d", &A[i], &B[i]);
memset(D, 0, sizeof(D));
memset(C, 0, sizeof(C));
int qs = 0, qz = 0;
Q[qs + qz++] = S, C[S] = 1;
while (qz)
{
int T = Q[qs++]; qz--;
for (int i = 0; i < N; i++)
if (G[T][i] && !C[i])
{
C[i] = 1, D[i] = D[T] + 1;
Q[qs + qz++] = i;
}
}
for (int i = 0; i < N; i++)
F[i] = 1;
for (int i = 0; i < T; i++)
{
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
X[j][k] = G[j][k] && D[k] == A[i];
Power(X, B[i]);
memset(R, 0, sizeof(R));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
R[j] = (R[j] + (Long)F[i] * X[i][j]) % P;
memcpy(F, R, sizeof(R));
}
int Ans = 0;
for (int i = 0; i < N; i++)
Ans = (Ans + F[i]) % P;
printf("%d\n", Ans);
return 0;
}
/**
* Calculates the two-loop beta function of vu.
*
* @return two-loop beta function
*/
double lowNE6SSM_susy_parameters::calc_beta_vu_two_loop(const Susy_traces& susy_traces) const
{
const auto QS = INPUT(QS);
const double tracefuAdjfu = TRACE_STRUCT.tracefuAdjfu;
const double traceYuAdjYu = TRACE_STRUCT.traceYuAdjYu;
const double tracefdAdjfd = TRACE_STRUCT.tracefdAdjfd;
const double traceYdAdjYd = TRACE_STRUCT.traceYdAdjYd;
const double traceYeAdjYe = TRACE_STRUCT.traceYeAdjYe;
const double traceKappaAdjKappa = TRACE_STRUCT.traceKappaAdjKappa;
const double traceLambda12AdjLambda12 =
TRACE_STRUCT.traceLambda12AdjLambda12;
const double tracefdAdjfdfuAdjfu = TRACE_STRUCT.tracefdAdjfdfuAdjfu;
const double tracefuAdjfufuAdjfu = TRACE_STRUCT.tracefuAdjfufuAdjfu;
const double tracefuAdjhEhEAdjfu = TRACE_STRUCT.tracefuAdjhEhEAdjfu;
const double tracefuAdjLambda12Lambda12Adjfu =
TRACE_STRUCT.tracefuAdjLambda12Lambda12Adjfu;
const double tracegDAdjgDTpYuconjYu =
TRACE_STRUCT.tracegDAdjgDTpYuconjYu;
const double traceYdAdjYuYuAdjYd = TRACE_STRUCT.traceYdAdjYuYuAdjYd;
const double traceYuAdjYuYuAdjYu = TRACE_STRUCT.traceYuAdjYuYuAdjYu;
double beta_vu;
beta_vu = -0.005*twoLoop*vu*(297*Power(g1,4) + 192*Power(g1p,4) + 725*
Power(g2,4) - 400*tracefdAdjfdfuAdjfu - 600*tracefuAdjfufuAdjfu - 200*
tracefuAdjhEhEAdjfu - 200*tracefuAdjLambda12Lambda12Adjfu - 600*
tracegDAdjgDTpYuconjYu - 600*traceYdAdjYuYuAdjYd - 1800*
traceYuAdjYuYuAdjYu + 340*traceYuAdjYu*Sqr(g1) + 60*traceYuAdjYu*Sqr(g1p)
+ 36*Sqr(g1)*Sqr(g1p) + 900*traceYuAdjYu*Sqr(g2) + 90*Sqr(g1)*Sqr(g2) +
60*Sqr(g1p)*Sqr(g2) + 20*tracefuAdjfu*(3*Sqr(g1) + 17*Sqr(g1p) + 15*Sqr(
g2)) + 3200*traceYuAdjYu*Sqr(g3) + Power(g1p,4)*Sqr(QS) + 10*AbsSqr(
Lambdax)*(-20*tracefdAdjfd - 60*traceKappaAdjKappa - 40*
traceLambda12AdjLambda12 - 60*traceYdAdjYd - 20*traceYeAdjYe - 20*AbsSqr(
Sigmax) + 6*Sqr(g1) + 9*Sqr(g1p) + 30*Sqr(g2) + Sqr(g1p)*Sqr(QS)) - 600*
Sqr(Conj(Lambdax))*Sqr(Lambdax));
return beta_vu;
}
// 指数为正整数
void test1()
{
printf("test1 begin:\n");
int exponent = 9;
double base = 10.0;
try
{
double result = Power(base, exponent);
printf("test result: %f.\n", result);
base = -9.9;
result = Power(base, exponent);
printf("test reslt: %f.\n", result);
base = 0.0;
result = Power(base, exponent);
printf("test result: %f.\n", result);
}
catch (std::exception& e)
{
printf("invalid input.\n");
}
printf("\n");
}
void CAmebaZone::Affect(SZoneObjectInfo* O)
{
CPhysicsShellHolder *pGameObject = smart_cast<CPhysicsShellHolder*>(O->object);
if(!pGameObject) return;
if(O->zone_ignore) return;
#ifdef DEBUG
char l_pow[255];
sprintf_s(l_pow, "zone hit. %.1f", Power(distance_to_center(O->object)));
if(bDebug) Msg("%s %s",*pGameObject->cName(), l_pow);
#endif
Fvector hit_dir;
hit_dir.set(::Random.randF(-.5f,.5f),
::Random.randF(.0f,1.f),
::Random.randF(-.5f,.5f));
hit_dir.normalize();
Fvector position_in_bone_space;
float power = Power(distance_to_center(O->object));
float impulse = m_fHitImpulseScale*power*pGameObject->GetMass();
//статистика по объекту
O->total_damage += power;
O->hit_num++;
if(power > 0.01f)
{
m_dwDeltaTime = 0;
position_in_bone_space.set(0.f,0.f,0.f);
CreateHit(pGameObject->ID(),ID(),hit_dir,power,0,position_in_bone_space,impulse,m_eHitTypeBlowout);
PlayHitParticles(pGameObject);
}
}
/**
* Calculates the two-loop beta function of g3.
*
* @return two-loop beta function
*/
double StandardModel_susy_parameters::calc_beta_g3_two_loop(const Susy_traces& susy_traces) const
{
const double traceYdAdjYd = TRACE_STRUCT.traceYdAdjYd;
const double traceYuAdjYu = TRACE_STRUCT.traceYuAdjYu;
double beta_g3;
beta_g3 = -0.1*Power(g3,3)*twoLoop*(20*traceYdAdjYd + 20*traceYuAdjYu
- 11*Sqr(g1) - 45*Sqr(g2) + 260*Sqr(g3));
return beta_g3;
}
void CMincer::AffectPullAlife(CEntityAlive* EA,const Fvector& throw_in_dir,float dist)
{
float power = Power(dist, Radius());
//Fvector dir;
//dir.random_dir(throw_in_dir,2.f*M_PI);
if(!smart_cast<CActor*>(EA))
{
Fvector pos_in_bone_space;
pos_in_bone_space.set(0,0,0);
CreateHit(EA->ID(),ID(),throw_in_dir,power,0,pos_in_bone_space,0.0f,m_eHitTypeBlowout);
}
inherited::AffectPullAlife(EA,throw_in_dir,dist);
}
void CMincer::AffectPullAlife(CEntityAlive* EA,const Fvector& throw_in_dir,float dist)
{
float power=Power(dist);
//Fvector dir;
//dir.random_dir(throw_in_dir,2.f*M_PI);
if(EA->CLS_ID!=CLSID_OBJECT_ACTOR)
{
Fvector pos_in_bone_space;
pos_in_bone_space.set(0,0,0);
CreateHit(EA->ID(),ID(),throw_in_dir,power,0,pos_in_bone_space,0.0f,m_eHitTypeBlowout);
}
inherited::AffectPullAlife(EA,throw_in_dir,dist);
}
void CBaseGraviZone::AffectThrow(SZoneObjectInfo* O, CPhysicsShellHolder* GO,const Fvector& throw_in_dir,float dist)
{
Fvector position_in_bone_space;
float power = Power(dist, Radius()); //Power(GO->Position().distance_to(zone_center));
float impulse = m_fHitImpulseScale*power*GO->GetMass();
if(power > 0.01f)
{
position_in_bone_space.set(0.f,0.f,0.f);
CreateHit(GO->ID(),ID(),throw_in_dir,power,0,position_in_bone_space,impulse,m_eHitTypeBlowout);
PlayHitParticles(GO);
}
}
Power Power::operator-(const Power& rhs) const
{
throwIfInvalid(*this);
throwIfInvalid(rhs);
if (rhs.m_power > this->m_power)
{
throw dptf_exception("Invalid power subtraction requested. Right side is greater than left side.");
}
else
{
return Power(this->m_power - rhs.m_power);
}
}
void InputDevice_DualShock::StateAction(StateMem* sm, const unsigned load, const bool data_only, const char* sname_prefix)
{
SFORMAT StateRegs[] =
{
SFVAR(cur_ana_button_state),
SFVAR(prev_ana_button_state),
SFVAR(combo_anatoggle_counter),
SFVAR(da_rumble_compat),
SFVAR(analog_mode),
SFVAR(analog_mode_locked),
SFVAR(mad_munchkins),
SFARRAY(rumble_magic, sizeof(rumble_magic)),
SFARRAY(rumble_param, sizeof(rumble_param)),
SFVAR(dtr),
SFARRAY(buttons, sizeof(buttons)),
SFARRAY(&axes[0][0], sizeof(axes)),
SFVAR(command_phase),
SFVAR(bitpos),
SFVAR(receive_buffer),
SFVAR(command),
SFARRAY(transmit_buffer, sizeof(transmit_buffer)),
SFVAR(transmit_pos),
SFVAR(transmit_count),
SFEND
};
char section_name[32];
trio_snprintf(section_name, sizeof(section_name), "%s_DualShock", sname_prefix);
if(!MDFNSS_StateAction(sm, load, data_only, StateRegs, section_name, true) && load)
Power();
else if(load)
{
if(((uint64)transmit_pos + transmit_count) > sizeof(transmit_buffer))
{
transmit_pos = 0;
transmit_count = 0;
}
}
}
void Polynom::SetCoefNZ(int ind, double val) // TODO : delete function?
{
if (ind < 0)
{
assert(!"Polynom::SetCoef : negative index");
return;
}
if (ind > Power() && AlmostZero(val))
return;
ExpandToIndex(ind);
m_coef[ind] = val;
DeleteTopZeros();
}
PlayerTrackBomb::PlayerTrackBomb(Point p, CList <GameObject*, GameObject*> *list):Weapon(Player_Track_Bomb_Height, Player_Track_Bomb_Width, p)
{
plane_ = NULL;
list_ = list;
Delayer(10);
Loop(TRUE);//PlayerTrackBomb
Group(1);
SpeedY(Player_Track_Bomb_Init_Speed);
SpeedX(Player_Track_Bomb_Init_Speed / 2);
Name(_T("PlayerBomb"));
Power(Player_Track_Bomb_Power);
Load_Image(bomb_up_1, Player_Track_Bomb_Image_Height, Player_Track_Bomb_Image_Width, Player_Track_Bomb_Image_Column, Player_Track_Bomb_Image_Row);
SelectTarget();
flyBehavior_ = new PlayerTrackFly(*(Position()),*(plane_),SpeedX(),SpeedY());
}
/**
* Calculates the two-loop beta function of Yu.
*
* @return two-loop beta function
*/
Eigen::Matrix<double,3,3> MSSM_susy_parameters::calc_beta_Yu_two_loop(const Susy_traces& susy_traces) const
{
const double traceYuAdjYu = TRACE_STRUCT.traceYuAdjYu;
const double traceYdAdjYuYuAdjYd = TRACE_STRUCT.traceYdAdjYuYuAdjYd;
const double traceYuAdjYuYuAdjYu = TRACE_STRUCT.traceYuAdjYuYuAdjYu;
const double traceYdAdjYd = TRACE_STRUCT.traceYdAdjYd;
const double traceYeAdjYe = TRACE_STRUCT.traceYeAdjYe;
Eigen::Matrix<double,3,3> beta_Yu;
beta_Yu = (twoLoop*(Yu*(6.095555555555555*Power(g1,4) + 7.5*Power(g2,4
) - 1.7777777777777777*Power(g3,4) - 3*traceYdAdjYuYuAdjYd - 9*
traceYuAdjYuYuAdjYu + Sqr(g1)*Sqr(g2) + 3.022222222222222*Sqr(g1)*Sqr(g3)
+ 8*Sqr(g2)*Sqr(g3) + 0.8*traceYuAdjYu*(Sqr(g1) + 20*Sqr(g3))) + (-3*
traceYdAdjYd - traceYeAdjYe + 0.4*Sqr(g1))*(Yu*Yd.adjoint()*Yd) - 9*
traceYuAdjYu*(Yu*Yu.adjoint()*Yu) + 0.4*Sqr(g1)*(Yu*Yu.adjoint()*Yu) + 6*
Sqr(g2)*(Yu*Yu.adjoint()*Yu) - 2*(Yu*Yd.adjoint()*Yd*Yd.adjoint()*Yd) - 2
*(Yu*Yd.adjoint()*Yd*Yu.adjoint()*Yu) - 4*(Yu*Yu.adjoint()*Yu*Yu.adjoint(
)*Yu))).real();
return beta_Yu;
}
int main()
{
double result = 0.0;
double base = 0.0;
int exponent = 0;
printf("Please input base and exponent: ");
scanf_s("%lf,%d", &base, &exponent);
result = Power(base,exponent);
if (g_InvalidInput == 1)
printf("The input is invailable!\n");
else
printf("%lf ^ %d = %lf\n",base,exponent,result);
return 0;
}
/**
* Calculates V_CKM angles from Wolfenstein parameters (see
* hep-ph/0406184)
*/
void CKM_parameters::set_from_wolfenstein(double lambdaW, double aCkm,
double rhobar, double etabar)
{
assert(Abs(lambdaW) <= 1. && "Error: Wolfenstein lambda out of range!");
assert(Abs(aCkm) <= 1. && "Error: Wolfenstein A parameter out of range!");
assert(Abs(rhobar) <= 1. && "Error: Wolfenstein rho-bar parameter out of range!");
assert(Abs(etabar) <= 1. && "Error: Wolfenstein eta-bar parameter out of range!");
theta_12 = ArcSin(lambdaW);
theta_23 = ArcSin(aCkm * Sqr(lambdaW));
const double lambdaW3 = Power(lambdaW, 3);
const double lambdaW4 = Power(lambdaW, 4);
const std::complex<double> rpe(rhobar, etabar);
const std::complex<double> V13conj = aCkm * lambdaW3 * rpe
* Sqrt(1.0 - Sqr(aCkm) * lambdaW4) /
Sqrt(1.0 - Sqr(lambdaW)) / (1.0 - Sqr(aCkm) * lambdaW4 * rpe);
if (std::isfinite(Re(V13conj)) && std::isfinite(Im(V13conj))) {
theta_13 = ArcSin(Abs(V13conj));
delta = Arg(V13conj);
}
}
void Compute()
{
DivisorSummatoryFunctionOdd algorithm;
CStopWatch timer;
for (int i = 1; i <= 24; i++)
{
Integer n = Power(Integer(10), i);
Integer x2 = sqrt(n);
timer.startTimer();
Integer s = algorithm.Evaluate(n, 1, x2);
timer.stopTimer();
std::string sRep = s.get_str();
printf("i = %d, s = %s, elapsed = %.3f\n", i, sRep.c_str(), timer.getElapsedTime() * 1000);
}
}
void CRadioactiveZone::Affect(SZoneObjectInfo* O)
{
float one = 0.1f;
float tg = Device.fTimeGlobal;
if(!O->object || O->f_time_affected+one > Device.fTimeGlobal)
return;
clamp (O->f_time_affected, tg-(one*3), tg);
Fvector pos;
XFORM().transform_tiny (pos,CFORM()->getSphere().P);
Fvector dir ={0,0,0};
float power = Power(O->object->Position().distance_to(pos),nearest_shape_radius(O));
float impulse = 0.0f;
if(power < EPS)
{
O->f_time_affected = tg;
return;
}
float send_power = power*one;
while(O->f_time_affected+one < tg)
{
CreateHit ( O->object->ID(),
ID(),
dir,
send_power,
BI_NONE,
Fvector().set(0.0f,0.0f,0.0f),
impulse,
m_eHitTypeBlowout);
#ifdef DEBUG
// if(bDebug)
/* Msg ( "Zone[%s]-hit->[%s] Power=%3.3f Frame=%d Time=%3.3f",
cName().c_str(),
O->object->cName().c_str(),
send_power,
Device.dwFrame,
tg);*/
/// Msg( "Zone hit ___ damage = %.4f Frame=%d ", send_power, Device.dwFrame );
#endif
O->f_time_affected += one;
}//while
}
TEST(PowerTest, PowerIfPowerIsShort)
{
BigInt left, right;
left.size = 2;
right.size = 1;
int leftDigits[] = {123, 4};
int rightDigits[] = {5};
SetDigits(&left, leftDigits);
SetDigits(&right, rightDigits);
BigInt* result = Power(&left, &right);
int digits[] = {6843, 8125, 6774, 2379, 8411, 1039};
ASSERT_EQ(6, result->size);
UnitTestsHelper::AssertDigits(digits, result);
}
TEST(PowerTest, PowerIfPowerIsZero)
{
BigInt left, right;
left.size = 2;
right.size = 1;
int leftDigits[] = {2};
int rightDigits[] = {0};
SetDigits(&left, leftDigits);
SetDigits(&right, rightDigits);
BigInt* result = Power(&left, &right);
int digits[] = {1};
ASSERT_EQ(1, result->size);
UnitTestsHelper::AssertDigits(digits, result);
}
int main(){
unsigned long result[N]={0};
result[0]=1;
for(int i=0;i<ULIMIT;++i){
if(Power(POW,result)){
printf("n=%3d: ",i);
PrintResult(result);
}
else{
return 1;
}
}
return 0;
}
void samplePhoton(Sampler *sampler, Photon &photon, int N, int nLights, Vector3f &unQuantDir) const {
const Point2f ls2 = sampler->next2D();
const Point3f pos = m_position;
//get a direction
const Vector3f cosDir = Warp::squareToUniformSphereCap(ls2, m_theta);
// transform it to world coordinates
Frame globalFrame = Frame(m_direction);
const Vector3f dir = globalFrame.toWorld(cosDir);
unQuantDir = dir;
const Color3f power = (Falloff(dir) * Power() * float(nLights)) / (float(N));
// create the photon
photon = Photon(pos, dir, power);
}
int main(void)
{
Init();
printf("start motor!");
PrgStop(); /* PWMの制御を停止します。おまじない（？）*/
PrgStart(); /* PWMのプログラムでの制御開始します。 */
Reset(CH1|CH2|CH3|CH4);
int mov_ch = CH2;
Start(); /* PWMによるモーター制御をEnableにします */
printf("Start\n");
sleep(6);
Power(CH2, 130);
Power(CH3, (unsigned char)-100);
sleep(5);
Power(CH2, (unsigned char)-100);
Power(CH3, 130);
sleep(5);
Power(CH2, 0);
Power(CH3, 0);
int i;
for (i = 0; i < 150; i+= 5) {
Power(mov_ch, i);
sleep(1);
}
Power(mov_ch, 0); /* Output mov_ch のモーターを0% のスピードにし停止します。*/
sleep(2);
Stop(mov_ch); /* PWMモーターの制御を停止します。この時点ではテンションが*/
printf("STOP\n"); /* かかった状態で停止しています。 */
sleep(2);
PrgStop(); /* PWMの処理を停止します。モーターに掛かっていたテンション*/
printf("ProgStop\n"); /* が解放されます。 */
return 1;
}
TEST(PowerTest, PowerIfPowerIsBig)
{
BigInt left, right;
left.size = 1;
right.size = 1;
int leftDigits[] = {99};
int rightDigits[] = {99};
SetDigits(&left, leftDigits);
SetDigits(&right, rightDigits);
BigInt* result = Power(&left, &right);
int digits[] = {9899, 49, 1592, 9999, 9977, 3849, 9301, 6765, 606, 8071, 1441, 6440, 193, 2157, 4516, 4359, 6949, 9967,
9429, 4011, 3265, 9548, 7888, 9409, 2727, 2823, 101, 650, 2141, 5234, 5277, 7045, 5525, 2423, 5997, 4302, 1102, 8174,
7642, 5668, 4059, 8054, 5628, 8790, 6571, 6772, 4972, 6376, 9729, 36};
FileOperations fileOperations;
fileOperations.PrintBigInt(result);
ASSERT_EQ(50, result->size);
UnitTestsHelper::AssertDigits(digits, result);
}
/**
* Calculates the two-loop beta function of g1.
*
* @return two-loop beta function
*/
double E6SSM_susy_parameters::calc_beta_g1_two_loop(const Susy_traces& susy_traces) const
{
const double traceYdAdjYd = TRACE_STRUCT.traceYdAdjYd;
const double traceYeAdjYe = TRACE_STRUCT.traceYeAdjYe;
const double traceYuAdjYu = TRACE_STRUCT.traceYuAdjYu;
const double traceKappaAdjKappa = TRACE_STRUCT.traceKappaAdjKappa;
const double traceLambda12AdjLambda12 =
TRACE_STRUCT.traceLambda12AdjLambda12;
double beta_g1;
beta_g1 = 0.04*Power(g1,3)*twoLoop*(-20*traceKappaAdjKappa - 30*
traceLambda12AdjLambda12 - 70*traceYdAdjYd - 90*traceYeAdjYe - 130*
traceYuAdjYu - 30*AbsSqr(Lambdax) + 234*Sqr(g1) + 270*Sqr(g2) + 600*Sqr(
g3) + 81*Sqr(gN));
return beta_g1;
}
void TT_params::Init_epsilon_lower()
{
Int_t i[4];
for (i[0]=0;i[0]<4;i[0]++) {
for (i[1]=0;i[1]<4;i[1]++) {
for (i[2]=0;i[2]<4;i[2]++) {
for (i[3]=0;i[3]<4;i[3]++) {
Int_t c=0;
for (Int_t j=0;j<4;j++) c+=1<<i[j];
if (c==15) {
f_epsilon_lower[i[0]] [i[1]] [i[2]] [i[3]]=Power(-1,Count_transpositions(i));
//printf("%d,%d,%d,%d: %d,%g",i[0],i[1],i[2],i[3],Count_transpositions(i),f_epsilon_lower[i[0]] [i[1]] [i[2]] [i[3]]);
}
else f_epsilon_lower[i[0]] [i[1]] [i[2]] [i[3]]=0.0;
}
}
}
}
}
int MillerRabin(uint64_t n, uint64_t k)
{
// Factor n-1 as d*2^s
uint64_t s = 0;
uint64_t d = n - 1;
for(; !(d & 1); s++)
d >>= 1;
// Verify x = k^(d 2^i) mod n != 1
uint64_t x = Power(k % n, d, n);
if(x == 1 || x == n-1)
return 1;
while(s-- > 1) {
// x = x^2 mod n
x = Multiplication(x, x, n);
if(x == 1)
return 0;
if(x == n-1)
return 1;
}
return 0;
}
void CRadioactiveZone::UpdateWorkload (u32 dt)
{
if (IsEnabled() && GameID() != GAME_SINGLE)
{
OBJECT_INFO_VEC_IT it;
Fvector pos;
XFORM().transform_tiny(pos,CFORM()->getSphere().P);
for(it = m_ObjectInfoMap.begin(); m_ObjectInfoMap.end() != it; ++it)
{
if( !(*it).object->getDestroy() && (*it).object->CLS_ID == CLSID_OBJECT_ACTOR)
{
//=====================================
NET_Packet l_P;
l_P.write_start();
l_P.read_start();
float dist = (*it).object->Position().distance_to(pos);
float power = Power(dist)*dt/1000;
/// Msg("Zone Dist %f, Radiation Power %f, ", dist, power);
SHit HS;
HS.GenHeader(GE_HIT, (*it).object->ID());
HS.whoID =ID();
HS.weaponID = ID();
HS.dir = Fvector().set(0,0,0);
HS.power = power;
HS.boneID = BI_NONE;
HS.p_in_bone_space = Fvector().set(0, 0, 0);
HS.impulse = 0.0f;
HS.hit_type = ALife::eHitTypeRadiation;
HS.Write_Packet_Cont(l_P);
(*it).object->OnEvent(l_P, HS.PACKET_TYPE);
//=====================================
};
}
}
inherited::UpdateWorkload(dt);
}
